static bool renderchain_set_pass_size(cg_renderchain_t *chain,
unsigned pass_index, unsigned width, unsigned height)
{
Pass *pass = (Pass*)&chain->passes[pass_index];
if (width != pass->info.tex_w || height != pass->info.tex_h)
{
d3d_texture_free(pass->tex);
pass->info.tex_w = width;
pass->info.tex_h = height;
pass->tex = d3d_texture_new(chain->dev, NULL,
width, height, 1,
D3DUSAGE_RENDERTARGET,
chain->passes.back().info.pass->fbo.fp_fbo ?
D3DFMT_A32B32G32R32F : D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT, 0, 0, 0,
NULL, NULL);
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);
}
return true;
}
static bool renderchain_create_first_pass(cg_renderchain_t *chain,
const LinkInfo *info, unsigned fmt)
{
unsigned i;
Pass pass;
D3DXMATRIX ident;
if (!chain)
return false;
D3DXMatrixIdentity(&ident);
d3d_set_transform(chain->dev, D3DTS_WORLD, &ident);
d3d_set_transform(chain->dev, D3DTS_VIEW, &ident);
pass.info = *info;
pass.last_width = 0;
pass.last_height = 0;
chain->prev.ptr = 0;
for (i = 0; i < TEXTURES; i++)
{
chain->prev.last_width[i] = 0;
chain->prev.last_height[i] = 0;
chain->prev.vertex_buf[i] = d3d_vertex_buffer_new(
chain->dev, 4 * sizeof(Vertex), 0, 0, D3DPOOL_DEFAULT, NULL);
if (!chain->prev.vertex_buf[i])
return false;
chain->prev.tex[i] = d3d_texture_new(chain->dev, NULL,
info->tex_w, info->tex_h, 1, 0,
(fmt == RETRO_PIXEL_FORMAT_RGB565) ? D3DFMT_R5G6B5 : D3DFMT_X8R8G8B8,
D3DPOOL_MANAGED, 0, 0, 0, NULL, NULL);
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_cg_load_program(chain, &pass.fPrg,
&pass.vPrg, info->pass->source.path, true);
if (!cg_d3d9_renderchain_init_shader_fvf(chain, &pass))
return false;
chain->passes.push_back(pass);
return true;
}
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 bool cg_d3d9_renderchain_add_pass(void *data, const void *info_data)
{
Pass pass;
const LinkInfo *info = (const LinkInfo*)info_data;
cg_renderchain_t *chain = (cg_renderchain_t*)data;
pass.info = *info;
pass.last_width = 0;
pass.last_height = 0;
d3d9_cg_load_program(chain, &pass.fPrg,
&pass.vPrg, info->pass->source.path, true);
if (!cg_d3d9_renderchain_init_shader_fvf(chain, &pass))
return false;
pass.vertex_buf = d3d_vertex_buffer_new(chain->dev, 4 * sizeof(Vertex),
0, 0, D3DPOOL_DEFAULT, NULL);
if (!pass.vertex_buf)
return false;
pass.tex = d3d_texture_new(
chain->dev,
NULL,
info->tex_w,
info->tex_h,
1,
D3DUSAGE_RENDERTARGET,
chain->passes.back().info.pass->fbo.fp_fbo
? D3DFMT_A32B32G32R32F : D3DFMT_A8R8G8B8,
D3DPOOL_DEFAULT, 0, 0, 0, NULL, NULL);
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);
chain->passes.push_back(pass);
renderchain_log_info(chain, info);
return true;
}
static void menu_display_d3d_bind_texture(void *data)
{
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;
d3d_set_texture(d3d->dev, 0, (LPDIRECT3DTEXTURE)draw->texture);
}
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 bool cg_d3d9_renderchain_add_lut(void *data,
const char *id, const char *path, bool smooth)
{
lut_info info;
cg_renderchain_t *chain = (cg_renderchain_t*)data;
LPDIRECT3DTEXTURE lut = d3d_texture_new(
chain->dev,
path,
D3DX_DEFAULT_NONPOW2,
D3DX_DEFAULT_NONPOW2,
0,
0,
D3DFMT_FROM_FILE,
D3DPOOL_MANAGED,
smooth ? D3DX_FILTER_LINEAR : D3DX_FILTER_POINT,
0,
0,
NULL,
NULL
);
RARCH_LOG("[D3D]: LUT texture loaded: %s.\n", path);
info.tex = lut;
info.smooth = smooth;
strcpy(info.id, id);
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);
chain->luts.push_back(info);
return true;
}
static void menu_display_d3d_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);
}
static void menu_display_d3d_bind_texture(void *data)
{
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;
d3d_set_texture(d3d->dev, 0, (LPDIRECT3DTEXTURE)draw->texture);
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);
}
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 cg_d3d9_renderchain_add_lut_internal(void *data,
unsigned index, unsigned i)
{
cg_renderchain_t *chain = (cg_renderchain_t*)data;
if (!chain)
return;
d3d_set_texture(chain->dev, index, chain->luts[i].tex);
d3d_set_sampler_magfilter(chain->dev, index,
d3d_translate_filter(chain->luts[i].smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST));
d3d_set_sampler_minfilter(chain->dev, index,
d3d_translate_filter(chain->luts[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);
chain->bound_tex.push_back(index);
}
void d3d_texture_blit(void *data, unsigned pixel_size,
LPDIRECT3DTEXTURE tex, D3DLOCKED_RECT *lr, const void *frame,
unsigned width, unsigned height, unsigned pitch)
{
unsigned y;
d3d_video_t *d3d = (d3d_video_t*)data;
(void)y;
if (!d3d)
return;
#ifdef _XBOX
/* Set the texture to NULL so D3D doesn't complain about it being in use... */
d3d_set_texture(d3d->dev, 0, NULL);
D3DTexture_LockRect(tex, 0, lr, NULL, D3DLOCK_NOSYSLOCK);
#if defined(_XBOX360)
D3DSURFACE_DESC desc;
tex->GetLevelDesc(0, &desc);
XGCopySurface(lr->pBits, lr->Pitch, width, height, desc.Format, NULL,
frame, pitch, desc.Format, NULL, 0, 0);
#elif defined(_XBOX1)
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 * d3d->pixel_size);
}
#endif
D3DTexture_UnlockRect(tex, 0);
#else
if (SUCCEEDED(tex->LockRect(0, lr, NULL, D3DLOCK_NOSYSLOCK)))
{
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);
}
tex->UnlockRect(0);
}
#endif
}
static void renderchain_blit_to_texture(void *data, const void *frame,
unsigned width, unsigned height, unsigned pitch)
{
D3DLOCKED_RECT d3dlr;
xdk_renderchain_t *chain = (xdk_renderchain_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)chain->dev;
d3d_frame_postprocess(chain);
if (chain->last_width != width || chain->last_height != height)
{
d3d_lockrectangle_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);
d3d_texture_blit(chain->pixel_size, chain->tex,
&d3dlr, frame, width, height, pitch);
}
static void renderchain_bind_orig(cg_renderchain_t *chain, void *pass_data)
{
unsigned index;
CGparameter param;
D3DXVECTOR2 video_size, texture_size;
Pass *pass = (Pass*)pass_data;
video_size.x = chain->passes[0].last_width;
video_size.y = chain->passes[0].last_height;
texture_size.x = chain->passes[0].info.tex_w;
texture_size.y = chain->passes[0].info.tex_h;
set_cg_param(pass->vPrg, "ORIG.video_size", video_size);
set_cg_param(pass->fPrg, "ORIG.video_size", video_size);
set_cg_param(pass->vPrg, "ORIG.texture_size", texture_size);
set_cg_param(pass->fPrg, "ORIG.texture_size", texture_size);
param = cgGetNamedParameter(pass->fPrg, "ORIG.texture");
if (param)
{
index = cgGetParameterResourceIndex(param);
d3d_set_texture(chain->dev, index, chain->passes[0].tex);
d3d_set_sampler_magfilter(chain->dev, index,
d3d_translate_filter(chain->passes[0].info.pass->filter));
d3d_set_sampler_minfilter(chain->dev, index,
d3d_translate_filter(chain->passes[0].info.pass->filter));
d3d_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER);
d3d_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER);
chain->bound_tex.push_back(index);
}
param = cgGetNamedParameter(pass->vPrg, "ORIG.tex_coord");
if (param)
{
LPDIRECT3DVERTEXBUFFER vert_buf = (LPDIRECT3DVERTEXBUFFER)chain->passes[0].vertex_buf;
index = pass->attrib_map[cgGetParameterResourceIndex(param)];
d3d_set_stream_source(chain->dev, index, vert_buf, 0, sizeof(Vertex));
chain->bound_vert.push_back(index);
}
}
static void renderchain_unbind_all(cg_renderchain_t *chain)
{
unsigned i;
/* Have to be a bit anal about it.
* Render targets hate it when they have filters apparently.
*/
for (i = 0; i < chain->bound_tex.size(); i++)
{
d3d_set_sampler_minfilter(chain->dev,
chain->bound_tex[i], D3DTEXF_POINT);
d3d_set_sampler_magfilter(chain->dev,
chain->bound_tex[i], D3DTEXF_POINT);
d3d_set_texture(chain->dev, chain->bound_tex[i], NULL);
}
for (i = 0; i < chain->bound_vert.size(); i++)
d3d_set_stream_source(chain->dev, chain->bound_vert[i], 0, 0, 0);
chain->bound_tex.clear();
chain->bound_vert.clear();
}
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 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);
}
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 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 void renderchain_bind_prev(void *data, void *pass_data)
{
unsigned i, index;
D3DXVECTOR2 texture_size;
char attr_texture[64] = {0};
char attr_input_size[64] = {0};
char attr_tex_size[64] = {0};
char attr_coord[64] = {0};
cg_renderchain_t *chain = (cg_renderchain_t*)data;
Pass *pass = (Pass*)pass_data;
static const char *prev_names[] = {
"PREV",
"PREV1",
"PREV2",
"PREV3",
"PREV4",
"PREV5",
"PREV6",
};
texture_size.x = chain->passes[0].info.tex_w;
texture_size.y = chain->passes[0].info.tex_h;
for (i = 0; i < TEXTURES - 1; i++)
{
CGparameter param;
D3DXVECTOR2 video_size;
snprintf(attr_texture, sizeof(attr_texture), "%s.texture", prev_names[i]);
snprintf(attr_input_size, sizeof(attr_input_size), "%s.video_size", prev_names[i]);
snprintf(attr_tex_size, sizeof(attr_tex_size), "%s.texture_size", prev_names[i]);
snprintf(attr_coord, sizeof(attr_coord), "%s.tex_coord", prev_names[i]);
video_size.x = chain->prev.last_width[(chain->prev.ptr - (i + 1)) & TEXTURESMASK];
video_size.y = chain->prev.last_height[(chain->prev.ptr - (i + 1)) & TEXTURESMASK];
set_cg_param(pass->vPrg, attr_input_size, video_size);
set_cg_param(pass->fPrg, attr_input_size, video_size);
set_cg_param(pass->vPrg, attr_tex_size, texture_size);
set_cg_param(pass->fPrg, attr_tex_size, texture_size);
param = cgGetNamedParameter(pass->fPrg, attr_texture);
if (param)
{
LPDIRECT3DTEXTURE tex;
index = cgGetParameterResourceIndex(param);
tex = (LPDIRECT3DTEXTURE)
chain->prev.tex[(chain->prev.ptr - (i + 1)) & TEXTURESMASK];
d3d_set_texture(chain->dev, index, tex);
chain->bound_tex.push_back(index);
d3d_set_sampler_magfilter(chain->dev, index,
d3d_translate_filter(chain->passes[0].info.pass->filter));
d3d_set_sampler_minfilter(chain->dev, index,
d3d_translate_filter(chain->passes[0].info.pass->filter));
d3d_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER);
d3d_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER);
}
param = cgGetNamedParameter(pass->vPrg, attr_coord);
if (param)
{
LPDIRECT3DVERTEXBUFFER vert_buf = (LPDIRECT3DVERTEXBUFFER)
chain->prev.vertex_buf[(chain->prev.ptr - (i + 1)) & TEXTURESMASK];
index = pass->attrib_map[cgGetParameterResourceIndex(param)];
d3d_set_stream_source(chain->dev, index, vert_buf, 0, sizeof(Vertex));
chain->bound_vert.push_back(index);
}
}
}
static void renderchain_bind_pass(cg_renderchain_t *chain,
Pass *pass, unsigned pass_index)
{
unsigned i, index;
/* We only bother binding passes which are two indices behind. */
if (pass_index < 3)
return;
for (i = 1; i < pass_index - 1; i++)
{
CGparameter param;
D3DXVECTOR2 video_size, texture_size;
char pass_base[64] = {0};
char attr_texture[64] = {0};
char attr_input_size[64] = {0};
char attr_tex_size[64] = {0};
char attr_coord[64] = {0};
snprintf(pass_base, sizeof(pass_base), "PASS%u", i);
snprintf(attr_texture, sizeof(attr_texture), "%s.texture", pass_base);
snprintf(attr_input_size, sizeof(attr_input_size), "%s.video_size", pass_base);
snprintf(attr_tex_size, sizeof(attr_tex_size), "%s.texture_size", pass_base);
snprintf(attr_coord, sizeof(attr_coord), "%s.tex_coord", pass_base);
video_size.x = chain->passes[i].last_width;
video_size.y = chain->passes[i].last_height;
texture_size.x = chain->passes[i].info.tex_w;
texture_size.y = chain->passes[i].info.tex_h;
set_cg_param(pass->vPrg, attr_input_size, video_size);
set_cg_param(pass->fPrg, attr_input_size, video_size);
set_cg_param(pass->vPrg, attr_tex_size, texture_size);
set_cg_param(pass->fPrg, attr_tex_size, texture_size);
param = cgGetNamedParameter(pass->fPrg, attr_texture);
if (param)
{
index = cgGetParameterResourceIndex(param);
chain->bound_tex.push_back(index);
d3d_set_texture(chain->dev, index, chain->passes[i].tex);
d3d_set_sampler_magfilter(chain->dev, index,
d3d_translate_filter(chain->passes[i].info.pass->filter));
d3d_set_sampler_minfilter(chain->dev, index,
d3d_translate_filter(chain->passes[i].info.pass->filter));
d3d_set_sampler_address_u(chain->dev, index, D3DTADDRESS_BORDER);
d3d_set_sampler_address_v(chain->dev, index, D3DTADDRESS_BORDER);
}
param = cgGetNamedParameter(pass->vPrg, attr_coord);
if (param)
{
index = pass->attrib_map[cgGetParameterResourceIndex(param)];
d3d_set_stream_source(chain->dev, index, chain->passes[i].vertex_buf,
0, sizeof(Vertex));
chain->bound_vert.push_back(index);
}
}
}
