static const gfx_ctx_driver_t *d3d_get_context(void *data)
{
/* Default to Direct3D9 for now.
TODO: GL core contexts through ANGLE? */
enum gfx_ctx_api api = GFX_CTX_DIRECT3D9_API;
unsigned major = 9, minor = 0;
#if defined(_XBOX1)
api = GFX_CTX_DIRECT3D8_API;
major = 8;
#endif
return gfx_ctx_init_first(driver.video_data,
g_settings.video.context_driver,
api, major, minor, false);
}
static const gfx_ctx_driver_t *d3d_get_context(void *data)
{
/* Default to Direct3D9 for now.
TODO: GL core contexts through ANGLE? */
unsigned minor = 0;
settings_t *settings = config_get_ptr();
#if defined(HAVE_D3D8)
unsigned major = 8;
enum gfx_ctx_api api = GFX_CTX_DIRECT3D8_API;
#else
unsigned major = 9;
enum gfx_ctx_api api = GFX_CTX_DIRECT3D9_API;
#endif
return gfx_ctx_init_first(data,
settings->video.context_driver,
api, major, minor, false);
}
static void *xdk_d3d_init(const video_info_t *video, const input_driver_t **input, void **input_data)
{
HRESULT ret;
if (driver.video_data)
{
xdk_d3d_video_t *d3d = (xdk_d3d_video_t*)driver.video_data;
// Reinitialize textures as we might have changed pixel formats.
xdk_d3d_reinit_textures(d3d, video);
return driver.video_data;
}
//we'll just use driver.video_data throughout here because it needs to
//exist when we delegate initing to the context file
driver.video_data = (xdk_d3d_video_t*)calloc(1, sizeof(xdk_d3d_video_t));
if (!driver.video_data)
return NULL;
xdk_d3d_video_t *d3d = (xdk_d3d_video_t*)driver.video_data;
d3d->vsync = video->vsync;
d3d->tex_w = RARCH_SCALE_BASE * video->input_scale;
d3d->tex_h = RARCH_SCALE_BASE * video->input_scale;
#if defined(_XBOX1)
d3d->ctx_driver = gfx_ctx_init_first(GFX_CTX_DIRECT3D8_API, 8, 0);
#elif defined(_XBOX360)
d3d->ctx_driver = gfx_ctx_init_first(GFX_CTX_DIRECT3D9_API, 9, 0);
#endif
if (d3d->ctx_driver)
{
D3DPRESENT_PARAMETERS d3dpp;
xdk_d3d_generate_pp(&d3dpp, video);
ret = d3d->d3d_device->CreateDevice(0, D3DDEVTYPE_HAL, NULL, D3DCREATE_HARDWARE_VERTEXPROCESSING,
&d3dpp, &d3d->d3d_render_device);
if (ret != S_OK)
RARCH_ERR("Failed at CreateDevice.\n");
RD3DDevice_Clear(d3d->d3d_render_device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 1.0f, 0);
}
else
{
free(d3d);
return NULL;
}
RARCH_LOG("Found D3D context: %s\n", d3d->ctx_driver->ident);
xdk_d3d_init_textures(d3d, video);
#if defined(_XBOX1)
// use an orthogonal matrix for the projection matrix
D3DXMATRIX mat;
D3DXMatrixOrthoOffCenterLH(&mat, 0, d3d->win_width , d3d->win_height , 0, 0.0f, 1.0f);
d3d->d3d_render_device->SetTransform(D3DTS_PROJECTION, &mat);
// use an identity matrix for the world and view matrices
D3DXMatrixIdentity(&mat);
d3d->d3d_render_device->SetTransform(D3DTS_WORLD, &mat);
d3d->d3d_render_device->SetTransform(D3DTS_VIEW, &mat);
ret = d3d->d3d_render_device->CreateVertexBuffer(4 * sizeof(DrawVerticeFormats),
D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEX, D3DPOOL_MANAGED, &d3d->vertex_buf);
if (ret != S_OK)
{
RARCH_ERR("[xdk_d3d_init::] Failed at CreateVertexBuffer.\n");
return NULL;
}
const DrawVerticeFormats init_verts[] = {
{ -1.0f, -1.0f, 1.0f, 0.0f, 1.0f },
{ 1.0f, -1.0f, 1.0f, 1.0f, 1.0f },
{ -1.0f, 1.0f, 1.0f, 0.0f, 0.0f },
{ 1.0f, 1.0f, 1.0f, 1.0f, 0.0f },
};
BYTE *verts_ptr;
RD3DVertexBuffer_Lock(d3d->vertex_buf, 0, 0, &verts_ptr, 0);
memcpy(verts_ptr, init_verts, sizeof(init_verts));
RD3DVertexBuffer_Unlock(d3d->vertex_buf);
RD3DDevice_SetVertexShader(d3d->d3d_render_device, D3DFVF_XYZ | D3DFVF_TEX1);
#elif defined(_XBOX360)
ret = d3d->d3d_render_device->CreateVertexBuffer(4 * sizeof(DrawVerticeFormats),
0, 0, 0, &d3d->vertex_buf, NULL);
if (ret != S_OK)
{
RARCH_ERR("[xdk_d3d_init::] Failed at CreateVertexBuffer.\n");
return NULL;
}
static const DrawVerticeFormats init_verts[] = {
{ -1.0f, -1.0f, 0.0f, 1.0f },
{ 1.0f, -1.0f, 1.0f, 1.0f },
{ -1.0f, 1.0f, 0.0f, 0.0f },
{ 1.0f, 1.0f, 1.0f, 0.0f },
};
void *verts_ptr;
RD3DVertexBuffer_Lock(d3d->vertex_buf, 0, 0, &verts_ptr, 0);
memcpy(verts_ptr, init_verts, sizeof(init_verts));
RD3DVertexBuffer_Unlock(d3d->vertex_buf);
static const D3DVERTEXELEMENT VertexElements[] =
{
{ 0, 0 * sizeof(float), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 2 * sizeof(float), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};
ret = d3d->d3d_render_device->CreateVertexDeclaration(VertexElements, &d3d->v_decl);
if (ret != S_OK)
{
RARCH_ERR("[xdk_d3d_init::] Failed at CreateVertexDeclaration.\n");
}
#endif
d3d->ctx_driver->get_video_size(&d3d->win_width, &d3d->win_height);
RARCH_LOG("Detecting screen resolution: %ux%u.\n", d3d->win_width, d3d->win_height);
d3d->ctx_driver->swap_interval(d3d->vsync ? 1 : 0);
#ifdef HAVE_HLSL
if (!hlsl_shader_init())
{
RARCH_ERR("Shader init failed.\n");
d3d->ctx_driver->destroy();
free(d3d);
return NULL;
}
RARCH_LOG("D3D: Loaded %u program(s).\n", d3d->shader->num_shaders());
#endif
#if 0 /* ifdef HAVE_FBO */
xdk_d3d_init_fbo(d3d);
#endif
xdk_d3d_set_rotation(d3d, g_settings.video.rotation);
//really returns driver.video_data to driver.video_data - see comment above
return d3d;
}
static void *vg_init(const video_info_t *video, const input_driver_t **input, void **input_data)
{
vg_t *vg = (vg_t*)calloc(1, sizeof(vg_t));
if (!vg)
return NULL;
vg->driver = gfx_ctx_init_first(GFX_CTX_OPENVG_API, 0, 0);
if (!vg->driver)
{
free(vg);
return NULL;
}
vg->driver->get_video_size(&vg->mScreenWidth, &vg->mScreenHeight);
RARCH_LOG("Detecting screen resolution %ux%u.\n", vg->mScreenWidth, vg->mScreenHeight);
vg->driver->swap_interval(video->vsync ? 1 : 0);
vg->driver->update_window_title();
vg->mTexType = video->rgb32 ? VG_sXRGB_8888 : VG_sRGB_565;
vg->mKeepAspect = video->force_aspect;
unsigned win_width = video->width;
unsigned win_height = video->height;
if (video->fullscreen && (win_width == 0) && (win_height == 0))
{
win_width = vg->mScreenWidth;
win_height = vg->mScreenHeight;
}
if (!vg->driver->set_video_mode(win_width, win_height, video->fullscreen))
{
free(vg);
return NULL;
}
vg->driver->get_video_size(&vg->mScreenWidth, &vg->mScreenHeight);
RARCH_LOG("Verified window resolution %ux%u.\n", vg->mScreenWidth, vg->mScreenHeight);
vg->should_resize = true;
if (vg->driver->translate_aspect)
vg->mScreenAspect = vg->driver->translate_aspect(vg->mScreenWidth, vg->mScreenHeight);
else
vg->mScreenAspect = (float)vg->mScreenWidth / vg->mScreenHeight;
VGfloat clearColor[4] = {0, 0, 0, 1};
vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
vg->mTextureWidth = vg->mTextureHeight = video->input_scale * RARCH_SCALE_BASE;
vg->mImage = vgCreateImage(vg->mTexType, vg->mTextureWidth, vg->mTextureHeight,
video->smooth ? VG_IMAGE_QUALITY_BETTER : VG_IMAGE_QUALITY_NONANTIALIASED);
vg_set_nonblock_state(vg, !video->vsync);
vg->driver->input_driver(input, input_data);
if (g_settings.video.font_enable && font_renderer_create_default(&vg->font_driver, &vg->mFontRenderer))
{
vg->mFont = vgCreateFont(0);
if (vg->mFont != VG_INVALID_HANDLE)
{
vg->mFontsOn = true;
vg->mFontHeight = g_settings.video.font_size * (g_settings.video.font_scale ? (float) vg->mScreenWidth / 1280.0f : 1.0f);
vg->mPaintFg = vgCreatePaint();
vg->mPaintBg = vgCreatePaint();
VGfloat paintFg[] = { g_settings.video.msg_color_r, g_settings.video.msg_color_g, g_settings.video.msg_color_b, 1.0f };
VGfloat paintBg[] = { g_settings.video.msg_color_r / 2.0f, g_settings.video.msg_color_g / 2.0f, g_settings.video.msg_color_b / 2.0f, 0.5f };
vgSetParameteri(vg->mPaintFg, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetParameterfv(vg->mPaintFg, VG_PAINT_COLOR, 4, paintFg);
vgSetParameteri(vg->mPaintBg, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetParameterfv(vg->mPaintBg, VG_PAINT_COLOR, 4, paintBg);
}
}
if (vg_query_extension("KHR_EGL_image") && vg->driver->init_egl_image_buffer(video))
{
pvgCreateEGLImageTargetKHR = (PFNVGCREATEEGLIMAGETARGETKHRPROC)vg->driver->get_proc_address("vgCreateEGLImageTargetKHR");
if (pvgCreateEGLImageTargetKHR)
{
RARCH_LOG("[VG] Using EGLImage buffer\n");
vg->mEglImageBuf = true;
}
}
#if 0
const char *ext = (const char*)vgGetString(VG_EXTENSIONS);
if (ext)
RARCH_LOG("[VG] Supported extensions: %s\n", ext);
#endif
return vg;
}
static void *vg_init(const video_info_t *video, const input_driver_t **input, void **input_data)
{
unsigned temp_width = 0, temp_height = 0;
VGfloat clearColor[4] = {0, 0, 0, 1};
settings_t *settings = config_get_ptr();
driver_t *driver = driver_get_ptr();
const gfx_ctx_driver_t *ctx = NULL;
vg_t *vg = (vg_t*)calloc(1, sizeof(vg_t));
if (!vg)
goto error;
ctx = gfx_ctx_init_first(vg, settings->video.context_driver,
GFX_CTX_OPENVG_API, 0, 0, false);
if (!ctx)
goto error;
driver->video_context = ctx;
gfx_ctx_get_video_size(vg, &temp_width, &temp_height);
RARCH_LOG("Detecting screen resolution %ux%u.\n", temp_width, temp_height);
if (temp_width != 0 && temp_height != 0)
{
video_driver_set_size_width(temp_width);
video_driver_set_size_width(temp_height);
}
gfx_ctx_swap_interval(vg, video->vsync ? 1 : 0);
gfx_ctx_update_window_title(vg);
vg->mTexType = video->rgb32 ? VG_sXRGB_8888 : VG_sRGB_565;
vg->keep_aspect = video->force_aspect;
unsigned win_width = video->width;
unsigned win_height = video->height;
if (video->fullscreen && (win_width == 0) && (win_height == 0))
{
video_driver_get_size(&temp_width, &temp_height);
win_width = temp_width;
win_height = temp_height;
}
if (!gfx_ctx_set_video_mode(vg, win_width, win_height, video->fullscreen))
goto error;
video_driver_get_size(&temp_width, &temp_height);
temp_width = 0;
temp_height = 0;
gfx_ctx_get_video_size(vg, &temp_width, &temp_height);
vg->should_resize = true;
if (temp_width != 0 && temp_height != 0)
{
RARCH_LOG("Verified window resolution %ux%u.\n", temp_width, temp_height);
video_driver_set_size_width(temp_width);
video_driver_set_size_height(temp_height);
}
video_driver_get_size(&temp_width, &temp_height);
vg->mScreenAspect = (float)temp_width / temp_height;
gfx_ctx_translate_aspect(vg, &vg->mScreenAspect, temp_width, temp_height);
vgSetfv(VG_CLEAR_COLOR, 4, clearColor);
vg->mTextureWidth = vg->mTextureHeight = video->input_scale * RARCH_SCALE_BASE;
vg->mImage = vgCreateImage(vg->mTexType, vg->mTextureWidth, vg->mTextureHeight,
video->smooth ? VG_IMAGE_QUALITY_BETTER : VG_IMAGE_QUALITY_NONANTIALIASED);
vg_set_nonblock_state(vg, !video->vsync);
gfx_ctx_input_driver(vg, input, input_data);
if (settings->video.font_enable && font_renderer_create_default(&vg->font_driver, &vg->mFontRenderer,
*settings->video.font_path ? settings->video.font_path : NULL, settings->video.font_size))
{
vg->mFont = vgCreateFont(0);
if (vg->mFont != VG_INVALID_HANDLE)
{
vg->mFontsOn = true;
vg->mFontHeight = settings->video.font_size;
vg->mPaintFg = vgCreatePaint();
vg->mPaintBg = vgCreatePaint();
VGfloat paintFg[] = { settings->video.msg_color_r, settings->video.msg_color_g, settings->video.msg_color_b, 1.0f };
VGfloat paintBg[] = { settings->video.msg_color_r / 2.0f, settings->video.msg_color_g / 2.0f, settings->video.msg_color_b / 2.0f, 0.5f };
vgSetParameteri(vg->mPaintFg, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetParameterfv(vg->mPaintFg, VG_PAINT_COLOR, 4, paintFg);
vgSetParameteri(vg->mPaintBg, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);
vgSetParameterfv(vg->mPaintBg, VG_PAINT_COLOR, 4, paintBg);
}
}
if (vg_query_extension("KHR_EGL_image") && gfx_ctx_image_buffer_init(vg, video))
{
pvgCreateEGLImageTargetKHR = (PFNVGCREATEEGLIMAGETARGETKHRPROC)gfx_ctx_get_proc_address("vgCreateEGLImageTargetKHR");
if (pvgCreateEGLImageTargetKHR)
{
RARCH_LOG("[VG] Using EGLImage buffer\n");
vg->mEglImageBuf = true;
}
}
#if 0
const char *ext = (const char*)vgGetString(VG_EXTENSIONS);
if (ext)
RARCH_LOG("[VG] Supported extensions: %s\n", ext);
#endif
return vg;
error:
if (vg)
free(vg);
if (driver)
driver->video_context = NULL;
return NULL;
}
