/**
* It reset the Direct3D9 device and its resources.
*/
static int Direct3DReset(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
LPDIRECT3DDEVICE9 d3ddev = sys->d3ddev;
if (Direct3DFillPresentationParameters(vd))
return VLC_EGENERIC;
/* release all D3D objects */
Direct3DDestroyResources(vd);
/* */
HRESULT hr = IDirect3DDevice9_Reset(d3ddev, &sys->d3dpp);
if (FAILED(hr)) {
msg_Err(vd, "%s failed ! (hr=%08lX)", __FUNCTION__, hr);
return VLC_EGENERIC;
}
UpdateRects(vd, NULL, NULL, true);
/* re-create them */
if (Direct3DCreateResources(vd, &vd->fmt)) {
msg_Dbg(vd, "%s failed !", __FUNCTION__);
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
static int
D3D_Reset(SDL_Renderer * renderer)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
HRESULT result;
/* Release the default render target before reset */
if (data->defaultRenderTarget) {
IDirect3DSurface9_Release(data->defaultRenderTarget);
data->defaultRenderTarget = NULL;
}
result = IDirect3DDevice9_Reset(data->device, &data->pparams);
if (FAILED(result)) {
if (result == D3DERR_DEVICELOST) {
/* Don't worry about it, we'll reset later... */
return 0;
} else {
return D3D_SetError("Reset()", result);
}
}
IDirect3DDevice9_SetVertexShader(data->device, NULL);
IDirect3DDevice9_SetFVF(data->device,
D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE,
D3DCULL_NONE);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_LIGHTING, FALSE);
IDirect3DDevice9_GetRenderTarget(data->device, 0, &data->defaultRenderTarget);
return 0;
}
static bool d3d9_reset_internal(void *data,
D3DPRESENT_PARAMETERS *d3dpp
)
{
LPDIRECT3DDEVICE9 dev = (LPDIRECT3DDEVICE9)data;
if (dev &&
IDirect3DDevice9_Reset(dev, d3dpp) == D3D_OK)
return true;
return false;
}
static void d3d9_init( sgui_context* context )
{
float m[16], f, iNF, fov_deg = 60.0f, Near = 0.1f, Far = 100.0f;
CUSTOMVERTEX vdat[ sizeof(indices)/sizeof(indices[0]) ];
sgui_d3d9_context* ctx = (sgui_d3d9_context*)context;
float aspectratio = (float)WIDTH / (float)HEIGHT;
unsigned int i, idx, r, g, b;
for( i=0; i<sizeof(indices)/sizeof(indices[0]); ++i )
{
idx = indices[ i ];
r = vertices[ idx*6+3 ] * 255.0f;
g = vertices[ idx*6+4 ] * 255.0f;
b = vertices[ idx*6+5 ] * 255.0f;
vdat[ i ].x = vertices[ idx*6 ];
vdat[ i ].y = vertices[ idx*6+1 ];
vdat[ i ].z = vertices[ idx*6+2 ];
vdat[ i ].color = D3DCOLOR_ARGB(0xFF,r,g,b);
}
IDirect3DDevice9_Reset( ctx->device, &ctx->present );
IDirect3DDevice9_CreateVertexBuffer( ctx->device, sizeof(vdat), 0,
CUSTOMFVF, D3DPOOL_MANAGED,
&v_buffer, NULL );
/* load vertex data */
IDirect3DVertexBuffer9_Lock( v_buffer, 0, 0, (void**)&pVoid, 0 );
memcpy( pVoid, vdat, sizeof(vdat) );
IDirect3DVertexBuffer9_Unlock( v_buffer );
/* setup renderer state */
IDirect3DDevice9_SetRenderState(ctx->device,D3DRS_CULLMODE,D3DCULL_NONE);
IDirect3DDevice9_SetRenderState(ctx->device,D3DRS_LIGHTING,FALSE );
IDirect3DDevice9_SetRenderState(ctx->device,D3DRS_ZENABLE, TRUE );
/* set up perspective projection matrix */
f = 1.0 / tan( fov_deg * DEGTORAD * 0.5 );
iNF = 1.0 / ( Near - Far );
m[0]=f/aspectratio; m[4]=0; m[ 8]=0; m[12]=0;
m[1]=0; m[5]=f; m[ 9]=0; m[13]=0;
m[2]=0; m[6]=0; m[10]=(Far+Near)*iNF; m[14]=2*Far*Near*iNF;
m[3]=0; m[7]=0; m[11]=-1; m[15]=0;
IDirect3DDevice9_SetTransform(ctx->device,D3DTS_PROJECTION,(D3DMATRIX*)m);
drawgui = 0;
}
/** @brief Create a new backbuffer. Create or Reset the D3D
* device.
* @return 1 on success, 0 on failure
*/
static int change_d3d_backbuffer(back_buffer_action_e action)
{
D3DPRESENT_PARAMETERS present_params;
destroy_d3d_surfaces();
/* Grow the backbuffer in the required dimension. */
if (vo_dwidth > priv->cur_backbuf_width)
priv->cur_backbuf_width = vo_dwidth;
if (vo_dheight > priv->cur_backbuf_height)
priv->cur_backbuf_height = vo_dheight;
/* The grown backbuffer dimensions are ready and fill_d3d_presentparams
* will use them, so we can reset the device.
*/
fill_d3d_presentparams(&present_params);
/* vo_w32_window is w32_common variable. It's a handle to the window. */
if (action == BACKBUFFER_CREATE &&
FAILED(IDirect3D9_CreateDevice(priv->d3d_handle,
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL, vo_w32_window,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&present_params, &priv->d3d_device))) {
mp_msg(MSGT_VO, MSGL_V,
"<vo_direct3d>Creating Direct3D device failed.\n");
return 0;
}
if (action == BACKBUFFER_RESET &&
FAILED(IDirect3DDevice9_Reset(priv->d3d_device, &present_params))) {
mp_msg(MSGT_VO, MSGL_ERR,
"<vo_direct3d>Reseting Direct3D device failed.\n");
return 0;
}
mp_msg(MSGT_VO, MSGL_V,
"<vo_direct3d>New backbuffer (%dx%d), VO (%dx%d)\n",
present_params.BackBufferWidth, present_params.BackBufferHeight,
vo_dwidth, vo_dheight);
return 1;
}
static int
D3D_Reset(SDL_Renderer * renderer)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
HRESULT result;
result = IDirect3DDevice9_Reset(data->device, &data->pparams);
if (FAILED(result)) {
if (result == D3DERR_DEVICELOST) {
/* Don't worry about it, we'll reset later... */
return 0;
} else {
D3D_SetError("Reset()", result);
return -1;
}
}
IDirect3DDevice9_SetVertexShader(data->device, NULL);
IDirect3DDevice9_SetFVF(data->device,
D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_CULLMODE,
D3DCULL_NONE);
IDirect3DDevice9_SetRenderState(data->device, D3DRS_LIGHTING, FALSE);
return 0;
}
HRESULT video_canvas_reset_dx9(video_canvas_t *canvas)
{
LPDIRECT3DSWAPCHAIN9 d3dsc;
HRESULT ddresult;
if ((canvas->d3dsurface != NULL)
&& (S_OK != IDirect3DSurface9_Release(canvas->d3dsurface))
|| (canvas->d3ddev != NULL &&
((S_OK != IDirect3DDevice9_GetSwapChain(canvas->d3ddev, 0, &d3dsc))
|| (S_OK != IDirect3DSwapChain9_Release(d3dsc)))
))
{
log_debug("video_dx9: Failed to release the DirectX9 device resources!");
}
canvas->d3dsurface = NULL;
//if (canvas->d3dpp.Windowed == 0) {
// int device, width, height, bitdepth, refreshrate;
// GetCurrentModeParameters(&device, &width, &height, &bitdepth, &refreshrate);
// canvas->d3dpp.BackBufferWidth = width;
// canvas->d3dpp.BackBufferHeight = height;
//} else {
RECT wrect;
GetClientRect(canvas->render_hwnd, &wrect);
canvas->d3dpp.BackBufferWidth = wrect.right - wrect.left;
canvas->d3dpp.BackBufferHeight = wrect.bottom - wrect.top;
//}
if (dx_primary_surface_rendering) {
canvas->d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
} else {
canvas->d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
}
if (canvas->d3ddev == NULL) {
if (S_OK != IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, canvas->render_hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &canvas->d3dpp, &canvas->d3ddev)) {
log_debug("video_dx9: Failed to create the DirectX9 device!");
return -1;
}
}
else {
if (S_OK != (ddresult = IDirect3DDevice9_Reset(
canvas->d3ddev,
&canvas->d3dpp))) {
log_debug("video_dx9: Failed to reset the DirectX9 device!");
}
}
if (S_OK != (ddresult = IDirect3DDevice9_CreateOffscreenPlainSurface(
canvas->d3ddev, canvas->draw_buffer->canvas_physical_width, canvas->draw_buffer->canvas_physical_height,
D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT,
&canvas->d3dsurface, NULL)))
{
log_debug("video_dx9: Failed to create new offscreen surface!");
return ddresult;
}
return IDirect3DDevice9_TestCooperativeLevel(canvas->d3ddev);
}
int main( void )
{
LPDIRECT3DVERTEXBUFFER9 v_buffer;
sgui_window_description desc;
IDirect3DTexture9* texture;
sgui_d3d9_context* ctx;
sgui_canvas* texcanvas;
IDirect3DDevice9* dev;
sgui_widget* check2;
sgui_widget* check;
sgui_widget* butt;
sgui_window* wnd;
float a=0.0f;
VOID* pVoid;
float m[16];
sgui_init( );
/*************************** create a window **************************/
desc.parent = NULL;
desc.share = NULL;
desc.width = 640;
desc.height = 480;
desc.flags = SGUI_FIXED_SIZE|SGUI_DOUBLEBUFFERED;
desc.backend = SGUI_DIRECT3D_9;
desc.bits_per_pixel = 32;
desc.depth_bits = 16;
desc.stencil_bits = 0;
desc.samples = 0;
wnd = sgui_window_create_desc( &desc );
sgui_window_set_title( wnd, "Direct3D 9 Texture Canvas" );
sgui_window_move_center( wnd );
sgui_window_set_visible( wnd, SGUI_VISIBLE );
sgui_window_set_vsync( wnd, 1 );
/************************ createtexture canvas ************************/
texcanvas = sgui_tex_canvas_create( wnd, sgui_window_get_context( wnd ),
128, 128 );
butt = sgui_button_create( 10, 10, 60, 25, "Button", 0 );
check = sgui_checkbox_create( 10, 40, "Direct3D" );
check2 = sgui_checkbox_create( 10, 65, "Texture" );
sgui_button_set_state( check, 1 );
sgui_button_set_state( check2, 1 );
sgui_widget_add_child( &texcanvas->root, butt );
sgui_widget_add_child( &texcanvas->root, check );
sgui_widget_add_child( &texcanvas->root, check2 );
/************** connect keyboard input to texture canvas **************/
sgui_event_connect( wnd, SGUI_KEY_PRESSED_EVENT,
sgui_canvas_send_window_event, texcanvas,
SGUI_FROM_EVENT, SGUI_EVENT );
sgui_event_connect( wnd, SGUI_KEY_RELEASED_EVENT,
sgui_canvas_send_window_event, texcanvas,
SGUI_FROM_EVENT, SGUI_EVENT );
sgui_event_connect( wnd, SGUI_CHAR_EVENT,
sgui_canvas_send_window_event, texcanvas,
SGUI_FROM_EVENT, SGUI_EVENT );
/*************************** Direct3D setup ***************************/
/* get the device context, set new present parameters */
ctx = (sgui_d3d9_context*)sgui_window_get_context( wnd );
dev = ctx->device;
IDirect3DDevice9_Reset( dev, &ctx->present );
/* create a vertex buffer */
IDirect3DDevice9_CreateVertexBuffer( dev, sizeof(vertices), 0,
CUSTOMFVF, D3DPOOL_MANAGED,
&v_buffer, NULL );
/* load vertex data */
IDirect3DVertexBuffer9_Lock( v_buffer, 0, 0, (void**)&pVoid, 0 );
memcpy( pVoid, vertices, sizeof(vertices) );
IDirect3DVertexBuffer9_Unlock( v_buffer );
/* setup renderer state */
IDirect3DDevice9_SetRenderState( dev, D3DRS_CULLMODE, D3DCULL_NONE );
IDirect3DDevice9_SetRenderState( dev, D3DRS_LIGHTING, FALSE );
IDirect3DDevice9_SetRenderState( dev, D3DRS_ZENABLE, TRUE );
/* set up perspective projection matrix */
perspective( m, 45.0f, (float)desc.width/(float)desc.height,
0.1f, 100.0f );
IDirect3DDevice9_SetTransform( dev, D3DTS_PROJECTION, (D3DMATRIX*)m );
/* set up texturing, bind canvas texture to stage 0 */
texture = sgui_tex_canvas_get_texture( texcanvas );
IDirect3DDevice9_SetTexture( dev, 0, (IDirect3DBaseTexture9*)texture );
IDirect3DDevice9_SetTextureStageState( dev, 0, D3DTSS_COLOROP,
D3DTOP_BLENDTEXTUREALPHA );
IDirect3DDevice9_SetTextureStageState( dev, 0, D3DTSS_COLORARG1,
D3DTA_TEXTURE );
IDirect3DDevice9_SetTextureStageState( dev, 0, D3DTSS_COLORARG2,
D3DTA_DIFFUSE );
IDirect3DDevice9_SetTextureStageState( dev, 0, D3DTSS_ALPHAOP,
D3DTOP_DISABLE );
IDirect3DDevice9_SetSamplerState(dev,0,D3DSAMP_MINFILTER,D3DTEXF_LINEAR);
IDirect3DDevice9_SetSamplerState(dev,0,D3DSAMP_MAGFILTER,D3DTEXF_LINEAR);
/****************************** main loop *****************************/
while( sgui_main_loop_step( ) )
{
/* redraw widgets in dirty areas */
sgui_canvas_redraw_widgets( texcanvas, 1 );
/* draw scene */
IDirect3DDevice9_Clear( dev, 0, NULL,
D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
0, 1.0f, 0 );
IDirect3DDevice9_BeginScene( dev );
transform( m, a );
IDirect3DDevice9_SetTransform( dev, D3DTS_VIEW, (D3DMATRIX*)m );
a += 0.01f;
IDirect3DDevice9_SetFVF( dev, CUSTOMFVF );
IDirect3DDevice9_SetStreamSource( dev, 0, v_buffer, 0,
sizeof(CUSTOMVERTEX) );
IDirect3DDevice9_DrawPrimitive( dev, D3DPT_TRIANGLELIST, 0, 8 );
IDirect3DDevice9_EndScene( dev );
/* swap front and back buffer */
sgui_window_swap_buffers( wnd );
}
/****************************** clean up ******************************/
sgui_canvas_destroy( texcanvas );
sgui_widget_destroy( check2 );
sgui_widget_destroy( check );
sgui_widget_destroy( butt );
IDirect3DVertexBuffer9_Release( v_buffer );
sgui_window_destroy( wnd );
sgui_deinit( );
return 0;
}