static bool xdk_renderchain_render(void *data, const void *frame,
unsigned width, unsigned height, unsigned pitch, unsigned rotation)
{
unsigned i;
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
xdk_renderchain_t *chain = (xdk_renderchain_t*)d3d->renderchain_data;
renderchain_blit_to_texture(chain, frame, width, height, pitch);
renderchain_set_vertices(d3d, 1, width, height);
d3d_set_texture(d3dr, 0, chain->tex);
d3d_set_viewport(chain->dev, &d3d->final_viewport);
d3d_set_sampler_minfilter(d3dr, 0, settings->video.smooth ?
D3DTEXF_LINEAR : D3DTEXF_POINT);
d3d_set_sampler_magfilter(d3dr, 0, settings->video.smooth ?
D3DTEXF_LINEAR : D3DTEXF_POINT);
d3d_set_vertex_declaration(d3dr, chain->vertex_decl);
for (i = 0; i < 4; i++)
d3d_set_stream_source(d3dr, i, chain->vertex_buf, 0, sizeof(Vertex));
d3d_draw_primitive(d3dr, D3DPT_TRIANGLESTRIP, 0, 2);
renderchain_set_mvp(d3d, global->video_data.width,
global->video_data.height, d3d->dev_rotation);
return true;
}
static bool xdk_renderchain_render(void *data, const void *frame,
unsigned frame_width, unsigned frame_height,
unsigned pitch, unsigned rotation)
{
unsigned i;
unsigned width, height;
uint64_t *frame_count = NULL;
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
settings_t *settings = config_get_ptr();
xdk_renderchain_t *chain = (xdk_renderchain_t*)d3d->renderchain_data;
video_driver_ctl(RARCH_DISPLAY_CTL_GET_FRAME_COUNT, &frame_count);
video_driver_get_size(&width, &height);
renderchain_blit_to_texture(chain, frame, frame_width, frame_height, pitch);
renderchain_set_vertices(d3d, 1, frame_width, frame_height, *frame_count);
d3d_set_texture(d3dr, 0, chain->tex);
d3d_set_viewports(chain->dev, &d3d->final_viewport);
d3d_set_sampler_minfilter(d3dr, 0, settings->video.smooth ?
D3DTEXF_LINEAR : D3DTEXF_POINT);
d3d_set_sampler_magfilter(d3dr, 0, settings->video.smooth ?
D3DTEXF_LINEAR : D3DTEXF_POINT);
d3d_set_vertex_declaration(d3dr, chain->vertex_decl);
for (i = 0; i < 4; i++)
d3d_set_stream_source(d3dr, i, chain->vertex_buf, 0, sizeof(Vertex));
d3d_draw_primitive(d3dr, D3DPT_TRIANGLESTRIP, 0, 2);
renderchain_set_mvp(d3d, width, height, d3d->dev_rotation);
return true;
}
static void menu_display_d3d_draw(void *data)
{
#if 0
math_matrix_4x4 *mat = NULL;
#endif
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(false);
menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;
if (!d3d || !draw)
return;
if (!draw->coords->vertex)
draw->coords->vertex = menu_display_d3d_get_default_vertices();
if (!draw->coords->tex_coord)
draw->coords->tex_coord = menu_display_d3d_get_default_tex_coords();
if (!draw->coords->lut_tex_coord)
draw->coords->lut_tex_coord = menu_display_d3d_get_default_tex_coords();
menu_display_d3d_viewport(draw);
menu_display_d3d_bind_texture(draw);
#if 0
mat = (math_matrix_4x4*)draw->matrix_data;
if (!mat)
mat = (math_matrix_4x4*)
menu_display_d3d_get_default_mvp();
video_shader_driver_set_coords(d3d, draw->coords);
video_shader_driver_set_mvp(d3d, mat);
#endif
d3d_draw_primitive(d3d->dev, (D3DPRIMITIVETYPE)
menu_display_prim_to_d3d_enum(draw->prim_type),
0, draw->coords->vertices);
}
static bool texture_image_render(d3d_video_t *d3d,
struct texture_image *out_img,
int x, int y, int w, int h, bool force_fullscreen)
{
LPDIRECT3DTEXTURE d3dt;
LPDIRECT3DVERTEXBUFFER d3dv;
void *verts = NULL;
float fX = (float)(x);
float fY = (float)(y);
if (!d3d)
return false;
d3dt = (LPDIRECT3DTEXTURE)out_img->texture_buf;
d3dv = (LPDIRECT3DVERTEXBUFFER)out_img->vertex_buf;
if (!d3dt || !d3dv)
return false;
/* Create the new vertices. */
Vertex newVerts[] =
{
// x, y, z, color, u ,v
{fX, fY, 0.0f, 0, 0, 0},
{fX + w, fY, 0.0f, 0, 1, 0},
{fX + w, fY + h, 0.0f, 0, 1, 1},
{fX, fY + h, 0.0f, 0, 0, 1}
};
/* Load the existing vertices */
verts = d3d_vertex_buffer_lock(d3dv);
if (!verts)
return false;
/* Copy the new verts over the old verts */
memcpy(verts, newVerts, sizeof(newVerts));
d3d_vertex_buffer_unlock(d3dv);
d3d_enable_blend_func(d3d->dev);
d3d_enable_alpha_blend_texture_func(d3d->dev);
/* Draw the quad. */
d3d_set_texture(d3d->dev, 0, d3dt);
d3d_set_stream_source(d3d->dev, 0,
d3dv, 0, sizeof(Vertex));
d3d_set_vertex_shader(d3d->dev, D3DFVF_CUSTOMVERTEX, NULL);
if (force_fullscreen)
d3d_set_viewport(d3d, w, h, force_fullscreen, false);
d3d_draw_primitive(d3d->dev, D3DPT_QUADLIST, 0, 1);
return true;
}
static void menu_display_d3d_draw(
unsigned x, unsigned y,
unsigned width, unsigned height,
struct gfx_coords *coords,
void *matrix_data,
uintptr_t texture,
enum menu_display_prim_type prim_type
)
{
D3DVIEWPORT vp = {0};
driver_t *driver = driver_get_ptr();
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);
math_matrix_4x4 *mat = (math_matrix_4x4*)matrix_data;
if (!d3d)
return;
/* TODO - edge case */
if (height <= 0)
height = 1;
if (!mat)
mat = (math_matrix_4x4*)menu_display_d3d_get_default_mvp();
if (!coords->vertex)
coords->vertex = &d3d_vertexes[0];
if (!coords->tex_coord)
coords->tex_coord = &d3d_tex_coords[0];
if (!coords->lut_tex_coord)
coords->lut_tex_coord = &d3d_tex_coords[0];
vp.X = x;
vp.Y = y;
vp.Width = width;
vp.Height = height;
vp.MinZ = 0.0f;
vp.MaxZ = 1.0f;
d3d_set_viewport(d3d->dev, &vp);
d3d_set_texture(d3d->dev, 0, (LPDIRECT3DTEXTURE)texture);
#if 0
gl->shader->set_coords(coords);
gl->shader->set_mvp(driver->video_data, mat);
#endif
d3d_draw_primitive(d3d->dev, (D3DPRIMITIVETYPE)menu_display_prim_to_d3d_enum(prim_type), 0, coords->vertices);
#if 0
gl->coords.color = gl->white_color_ptr;
#endif
}
static void menu_display_d3d_draw(void *data)
{
D3DVIEWPORT vp = {0};
math_matrix_4x4 *mat = NULL;
d3d_video_t *d3d = d3d_get_ptr();
menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;
if (!d3d || !draw)
return;
mat = (math_matrix_4x4*)draw->matrix_data;
/* TODO - edge case */
if (draw->height <= 0)
draw->height = 1;
if (!mat)
mat = (math_matrix_4x4*)
menu_display_d3d_get_default_mvp();
if (!draw->coords->vertex)
draw->coords->vertex = &d3d_vertexes[0];
if (!draw->coords->tex_coord)
draw->coords->tex_coord = &d3d_tex_coords[0];
if (!draw->coords->lut_tex_coord)
draw->coords->lut_tex_coord = &d3d_tex_coords[0];
vp.X = draw->x;
vp.Y = draw->y;
vp.Width = draw->width;
vp.Height = draw->height;
vp.MinZ = 0.0f;
vp.MaxZ = 1.0f;
d3d_set_viewports(d3d->dev, &vp);
d3d_set_texture(d3d->dev, 0, (LPDIRECT3DTEXTURE)draw->texture);
#if 0
video_shader_driver_set_coords(d3d, draw->coords);
video_shader_driver_set_mvp(d3d, mat);
#endif
d3d_draw_primitive(d3d->dev, (D3DPRIMITIVETYPE)
menu_display_prim_to_d3d_enum(draw->prim_type),
0, draw->coords->vertices);
#if 0
gl->coords.color = gl->white_color_ptr;
#endif
}
static void renderchain_render_pass(
cg_renderchain_t *chain,
Pass *pass,
unsigned pass_index)
{
unsigned i;
if (!chain)
return;
renderchain_set_shaders(chain, &pass->fPrg, &pass->vPrg);
d3d_set_texture(chain->dev, 0, pass->tex);
d3d_set_sampler_minfilter(chain->dev, 0,
translate_filter(pass->info.pass->filter));
d3d_set_sampler_magfilter(chain->dev, 0,
translate_filter(pass->info.pass->filter));
d3d_set_vertex_declaration(chain->dev, pass->vertex_decl);
for (i = 0; i < 4; i++)
d3d_set_stream_source(chain->dev, i,
pass->vertex_buf, 0, sizeof(Vertex));
renderchain_bind_orig(chain, pass);
renderchain_bind_prev(chain, pass);
renderchain_bind_pass(chain, pass, pass_index);
renderchain_bind_luts(chain, pass);
renderchain_bind_tracker(chain, pass, pass_index);
d3d_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);
renderchain_unbind_all(chain);
}
static void d3d_overlay_render(d3d_video_t *d3d, overlay_t *overlay)
{
struct video_viewport vp;
unsigned width, height;
void *verts;
unsigned i;
float vert[4][9];
float overlay_width, overlay_height;
#ifndef _XBOX1
LPDIRECT3DVERTEXDECLARATION vertex_decl;
/* set vertex declaration for overlay. */
D3DVERTEXELEMENT vElems[4] = {
{0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_POSITION, 0},
{0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_TEXCOORD, 0},
{0, 20, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_COLOR, 0},
D3DDECL_END()
};
#endif
if (!d3d)
return;
if (!overlay || !overlay->tex)
return;
if (!overlay->vert_buf)
{
overlay->vert_buf = d3d_vertex_buffer_new(
d3d->dev, sizeof(vert), 0, 0, D3DPOOL_MANAGED, NULL);
if (!overlay->vert_buf)
return;
}
for (i = 0; i < 4; i++)
{
vert[i][2] = 0.5f;
vert[i][5] = 1.0f;
vert[i][6] = 1.0f;
vert[i][7] = 1.0f;
vert[i][8] = overlay->alpha_mod;
}
d3d_viewport_info(d3d, &vp);
overlay_width = vp.width;
overlay_height = vp.height;
vert[0][0] = overlay->vert_coords[0] * overlay_width;
vert[1][0] = (overlay->vert_coords[0] + overlay->vert_coords[2])
* overlay_width;
vert[2][0] = overlay->vert_coords[0] * overlay_width;
vert[3][0] = (overlay->vert_coords[0] + overlay->vert_coords[2])
* overlay_width;
vert[0][1] = overlay->vert_coords[1] * overlay_height;
vert[1][1] = overlay->vert_coords[1] * overlay_height;
vert[2][1] = (overlay->vert_coords[1] + overlay->vert_coords[3])
* overlay_height;
vert[3][1] = (overlay->vert_coords[1] + overlay->vert_coords[3])
* overlay_height;
vert[0][3] = overlay->tex_coords[0];
vert[1][3] = overlay->tex_coords[0] + overlay->tex_coords[2];
vert[2][3] = overlay->tex_coords[0];
vert[3][3] = overlay->tex_coords[0] + overlay->tex_coords[2];
vert[0][4] = overlay->tex_coords[1];
vert[1][4] = overlay->tex_coords[1];
vert[2][4] = overlay->tex_coords[1] + overlay->tex_coords[3];
vert[3][4] = overlay->tex_coords[1] + overlay->tex_coords[3];
/* Align texels and vertices. */
for (i = 0; i < 4; i++)
{
vert[i][0] -= 0.5f;
vert[i][1] += 0.5f;
}
overlay->vert_buf->Lock(0, sizeof(vert), &verts, 0);
memcpy(verts, vert, sizeof(vert));
d3d_vertex_buffer_unlock(overlay->vert_buf);
d3d_enable_blend_func(d3d->dev);
#ifndef _XBOX1
d3d->dev->CreateVertexDeclaration(vElems, &vertex_decl);
d3d_set_vertex_declaration(d3d->dev, vertex_decl);
vertex_decl->Release();
#endif
d3d_set_stream_source(d3d->dev, 0, overlay->vert_buf,
0, sizeof(*vert));
video_driver_get_size(&width, &height);
if (overlay->fullscreen)
{
D3DVIEWPORT vp_full;
vp_full.X = 0;
vp_full.Y = 0;
vp_full.Width = width;
vp_full.Height = height;
vp_full.MinZ = 0.0f;
vp_full.MaxZ = 1.0f;
d3d_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);
/* Restore previous state. */
d3d_disable_blend_func(d3d->dev);
d3d_set_viewports(d3d->dev, &d3d->final_viewport);
}
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*)
d3d_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_d3d_get_default_vertices();
if (!tex_coord)
tex_coord = menu_display_d3d_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++;
#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(
colors[3], /* A */
colors[0], /* R */
colors[1], /* G */
colors[2] /* B */
);
}
d3d_vertex_buffer_unlock(d3d->menu_display.buffer);
if(!draw->matrix_data)
draw->matrix_data = menu_display_d3d_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_d3d_bind_texture(draw, (d3d_video_t*)video_info->userdata);
d3d_draw_primitive(d3d->dev,
menu_display_prim_to_d3d_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 renderchain_render_pass(
cg_renderchain_t *chain,
Pass *pass,
unsigned pass_index)
{
unsigned i, index;
if (!chain)
return;
renderchain_set_shaders(pass->fPrg, 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));
d3d_set_vertex_declaration(chain->dev, pass->vertex_decl);
for (i = 0; i < 4; i++)
d3d_set_stream_source(chain->dev, i,
pass->vertex_buf, 0, sizeof(Vertex));
/* Set orig texture. */
renderchain_bind_orig(chain, pass);
/* Set prev textures. */
renderchain_bind_prev(chain, pass);
/* Set lookup textures */
for (i = 0; i < chain->luts.size(); i++)
{
CGparameter vparam;
CGparameter fparam = cgGetNamedParameter(
pass->fPrg, chain->luts[i].id);
int bound_index = -1;
if (fparam)
{
index = cgGetParameterResourceIndex(fparam);
bound_index = index;
cg_d3d9_renderchain_add_lut_internal(chain, index, i);
}
vparam = cgGetNamedParameter(pass->vPrg, chain->luts[i].id);
if (vparam)
{
index = cgGetParameterResourceIndex(vparam);
if (index != (unsigned)bound_index)
cg_d3d9_renderchain_add_lut_internal(chain, index, i);
}
}
renderchain_bind_pass(chain, pass, pass_index);
/* Set state parameters. */
if (chain->state_tracker)
{
/* Only query uniforms in first pass. */
static struct state_tracker_uniform tracker_info[GFX_MAX_VARIABLES];
static unsigned cnt = 0;
if (pass_index == 1)
cnt = state_tracker_get_uniform(chain->state_tracker, tracker_info,
GFX_MAX_VARIABLES, chain->frame_count);
for (i = 0; i < cnt; i++)
{
CGparameter param_f = cgGetNamedParameter(
pass->fPrg, tracker_info[i].id);
CGparameter param_v = cgGetNamedParameter(
pass->vPrg, tracker_info[i].id);
cg_d3d9_set_param_1f(param_f, &tracker_info[i].value);
cg_d3d9_set_param_1f(param_v, &tracker_info[i].value);
}
}
d3d_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);
renderchain_unbind_all(chain);
}
static bool texture_image_render(d3d_video_t *d3d,
struct texture_image *out_img,
int x, int y, int w, int h, bool force_fullscreen)
{
void *verts = NULL;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
float fX = (float)(x);
float fY = (float)(y);
if (!d3d)
return false;
if (!out_img->pixels || !out_img->vertex_buf)
return false;
/* Create the new vertices. */
Vertex newVerts[] =
{
// x, y, z, color, u ,v
{fX, fY, 0.0f, 0, 0, 0},
{fX + w, fY, 0.0f, 0, 1, 0},
{fX + w, fY + h, 0.0f, 0, 1, 1},
{fX, fY + h, 0.0f, 0, 0, 1}
};
/* Load the existing vertices */
verts = d3d_vertex_buffer_lock(out_img->vertex_buf);
if (!verts)
return false;
/* Copy the new verts over the old verts */
memcpy(verts, newVerts, sizeof(newVerts));
d3d_vertex_buffer_unlock(out_img->vertex_buf);
d3d_enable_blend_func(d3d->dev);
/* Also blend the texture with the set alpha value. */
d3d->dev->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
d3d->dev->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
d3d->dev->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
/* Draw the quad. */
d3d_set_texture(d3dr, 0, out_img->texture_buf);
d3d_set_stream_source(d3dr, 0,
out_img->vertex_buf, 0, sizeof(Vertex));
d3d_set_vertex_shader(d3dr, D3DFVF_CUSTOMVERTEX, NULL);
if (force_fullscreen)
{
D3DVIEWPORT vp = {0};
vp.Width = w;
vp.Height = h;
vp.X = 0;
vp.Y = 0;
vp.MinZ = 0.0f;
vp.MaxZ = 1.0f;
d3d_set_viewport(d3dr, &vp);
}
d3d_draw_primitive(d3dr, D3DPT_QUADLIST, 0, 1);
return true;
}
static void d3d_overlay_render(d3d_video_t *d3d, overlay_t *overlay)
{
void *verts;
unsigned i;
struct overlay_vertex
{
float x, y, z;
float u, v;
float r, g, b, a;
} vert[4];
float overlay_width, overlay_height;
#ifndef _XBOX1
LPDIRECT3DVERTEXDECLARATION vertex_decl;
/* set vertex declaration for overlay. */
D3DVERTEXELEMENT vElems[4] = {
{0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_POSITION, 0},
{0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_TEXCOORD, 0},
{0, 20, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT,
D3DDECLUSAGE_COLOR, 0},
D3DDECL_END()
};
#endif
if (!d3d)
return;
if (!overlay || !overlay->tex)
return;
if (!overlay->vert_buf)
{
overlay->vert_buf = (LPDIRECT3DVERTEXBUFFER)d3d_vertex_buffer_new(
d3d->dev, sizeof(vert), 0, 0, D3DPOOL_MANAGED, NULL);
if (!overlay->vert_buf)
return;
}
for (i = 0; i < 4; i++)
{
vert[i].z = 0.5f;
vert[i].r = vert[i].g = vert[i].b = 1.0f;
vert[i].a = overlay->alpha_mod;
}
overlay_width = d3d->final_viewport.Width;
overlay_height = d3d->final_viewport.Height;
vert[0].x = overlay->vert_coords.x * overlay_width;
vert[1].x = (overlay->vert_coords.x + overlay->vert_coords.w)
* overlay_width;
vert[2].x = overlay->vert_coords.x * overlay_width;
vert[3].x = (overlay->vert_coords.x + overlay->vert_coords.w)
* overlay_width;
vert[0].y = overlay->vert_coords.y * overlay_height;
vert[1].y = overlay->vert_coords.y * overlay_height;
vert[2].y = (overlay->vert_coords.y + overlay->vert_coords.h)
* overlay_height;
vert[3].y = (overlay->vert_coords.y + overlay->vert_coords.h)
* overlay_height;
vert[0].u = overlay->tex_coords.x;
vert[1].u = overlay->tex_coords.x + overlay->tex_coords.w;
vert[2].u = overlay->tex_coords.x;
vert[3].u = overlay->tex_coords.x + overlay->tex_coords.w;
vert[0].v = overlay->tex_coords.y;
vert[1].v = overlay->tex_coords.y;
vert[2].v = overlay->tex_coords.y + overlay->tex_coords.h;
vert[3].v = overlay->tex_coords.y + overlay->tex_coords.h;
/* Align texels and vertices. */
for (i = 0; i < 4; i++)
{
vert[i].x -= 0.5f;
vert[i].y += 0.5f;
}
overlay->vert_buf->Lock(0, sizeof(vert), &verts, 0);
memcpy(verts, vert, sizeof(vert));
d3d_vertex_buffer_unlock(overlay->vert_buf);
d3d_enable_blend_func(d3d->dev);
#ifndef _XBOX1
d3d->dev->CreateVertexDeclaration(vElems, &vertex_decl);
d3d->dev->SetVertexDeclaration(vertex_decl);
vertex_decl->Release();
#endif
d3d_set_stream_source(d3d->dev, 0, overlay->vert_buf,
0, sizeof(overlay_vertex));
if (overlay->fullscreen)
{
/* Set viewport to full window. */
D3DVIEWPORT vp_full = {0};
vp_full.X = 0;
vp_full.Y = 0;
vp_full.Width = d3d->screen_width;
vp_full.Height = d3d->screen_height;
vp_full.MinZ = 0.0f;
vp_full.MaxZ = 1.0f;
d3d_set_viewport(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);
/* Restore previous state. */
d3d_disable_blend_func(d3d->dev);
d3d_set_viewport(d3d->dev, &d3d->final_viewport);
}
