int renderer_dd::create_clipper()
{
HRESULT result;
// create a clipper for the primary surface
result = IDirectDraw7_CreateClipper(ddraw, 0, &clipper, NULL);
if (result != DD_OK)
{
osd_printf_verbose("DirectDraw: Error %08X creating clipper\n", (int)result);
return 1;
}
// set the clipper's hwnd
result = IDirectDrawClipper_SetHWnd(clipper, 0, window().m_hwnd);
if (result != DD_OK)
{
osd_printf_verbose("DirectDraw: Error %08X setting clipper hwnd\n", (int)result);
return 1;
}
// set the clipper on the primary surface
result = IDirectDrawSurface7_SetClipper(primary, clipper);
if (result != DD_OK)
{
osd_printf_verbose("DirectDraw: Error %08X setting clipper on primary surface\n", (int)result);
return 1;
}
return 0;
}
static int create_clipper(win_window_info *window)
{
dd_info *dd = window->drawdata;
HRESULT result;
// create a clipper for the primary surface
result = IDirectDraw7_CreateClipper(dd->ddraw, 0, &dd->clipper, NULL);
if (result != DD_OK)
{
mame_printf_verbose("DirectDraw: Error %08X creating clipper\n", (int)result);
return 1;
}
// set the clipper's hwnd
result = IDirectDrawClipper_SetHWnd(dd->clipper, 0, window->hwnd);
if (result != DD_OK)
{
mame_printf_verbose("DirectDraw: Error %08X setting clipper hwnd\n", (int)result);
return 1;
}
// set the clipper on the primary surface
result = IDirectDrawSurface7_SetClipper(dd->primary, dd->clipper);
if (result != DD_OK)
{
mame_printf_verbose("DirectDraw: Error %08X setting clipper on primary surface\n", (int)result);
return 1;
}
return 0;
}
static IDirect3DDevice7 *create_device(HWND window, DWORD coop_level)
{
IDirect3DDevice7 *device = NULL;
IDirectDrawSurface7 *surface;
DDSURFACEDESC2 surface_desc;
IDirectDraw7 *ddraw;
IDirect3D7 *d3d7;
HRESULT hr;
if (!(ddraw = create_ddraw()))
return NULL;
hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, coop_level);
ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
memset(&surface_desc, 0, sizeof(surface_desc));
surface_desc.dwSize = sizeof(surface_desc);
surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
surface_desc.dwWidth = 640;
surface_desc.dwHeight = 480;
hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &surface, NULL);
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
if (coop_level & DDSCL_NORMAL)
{
IDirectDrawClipper *clipper;
hr = IDirectDraw7_CreateClipper(ddraw, 0, &clipper, NULL);
ok(SUCCEEDED(hr), "Failed to create clipper, hr %#x.\n", hr);
hr = IDirectDrawClipper_SetHWnd(clipper, 0, window);
ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
hr = IDirectDrawSurface7_SetClipper(surface, clipper);
ok(SUCCEEDED(hr), "Failed to set surface clipper, hr %#x.\n", hr);
IDirectDrawClipper_Release(clipper);
}
hr = IDirectDraw7_QueryInterface(ddraw, &IID_IDirect3D7, (void **)&d3d7);
IDirectDraw7_Release(ddraw);
if (FAILED(hr))
{
IDirectDrawSurface7_Release(surface);
return NULL;
}
hr = IDirect3D7_CreateDevice(d3d7, &IID_IDirect3DTnLHalDevice, surface, &device);
IDirect3D7_Release(d3d7);
IDirectDrawSurface7_Release(surface);
if (FAILED(hr))
return NULL;
return device;
}
boolean CreatePrimary( win32_driver_t * win32_driver )
{
LPDIRECTDRAW ddobj;
DDSURFACEDESC2 ddsd;
HRESULT result;
// create direct draw object
result = DirectDrawCreate( 0, &ddobj, 0 );
if( result != DD_OK )
{
Error( 0, "DirectDrawCreate : error %i", result );
printf( "vo_out_directx : DirectDrawCreate : error %i\n", result );
return 0;
}
// set cooperative level
result = IDirectDraw_SetCooperativeLevel( ddobj, win32_driver->win32_visual->WndHnd, DDSCL_NORMAL );
if( result != DD_OK )
{
Error( 0, "SetCooperativeLevel : error %i", result );
return 0;
}
// try to get new interface
result = IDirectDraw_QueryInterface( ddobj, &IID_IDirectDraw7, (LPVOID *) &win32_driver->ddobj );
if( result != DD_OK )
{
Error( 0, "ddobj->QueryInterface : DirectX 7 or higher required" );
return 0;
}
// release our old interface
IDirectDraw_Release( ddobj );
// create primary_surface
memset( &ddsd, 0, sizeof( ddsd ) );
ddsd.dwSize = sizeof( ddsd );
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
result = IDirectDraw7_CreateSurface( win32_driver->ddobj, &ddsd, &win32_driver->primary, 0 );
if( result != DD_OK )
{
Error( 0, "CreateSurface ( primary ) : error %i ", result );
return 0;
}
// create our clipper object
result = IDirectDraw7_CreateClipper( win32_driver->ddobj, 0, &win32_driver->ddclipper, 0 );
if( result != DD_OK )
{
Error( 0, "CreateClipper : error %i", result );
return 0;
}
// associate our clipper with our window
result = IDirectDrawClipper_SetHWnd( win32_driver->ddclipper, 0, win32_driver->win32_visual->WndHnd );
if( result != DD_OK )
{
Error( 0, "ddclipper->SetHWnd : error %i", result );
return 0;
}
// associate our primary surface with our clipper
result = IDirectDrawSurface7_SetClipper( win32_driver->primary, win32_driver->ddclipper );
if( result != DD_OK )
{
Error( 0, "ddclipper->SetHWnd : error %i", result );
return 0;
}
// store our objects in our visual struct
UpdateRect( win32_driver->win32_visual );
return 1;
}
static void test_clipper_blt(void)
{
IDirectDrawSurface7 *src_surface, *dst_surface;
RECT client_rect, src_rect, *rect;
IDirectDrawClipper *clipper;
DDSURFACEDESC2 surface_desc;
unsigned int i, j, x, y;
IDirectDraw7 *ddraw;
RGNDATA *rgn_data;
D3DCOLOR color;
HRGN r1, r2;
HWND window;
DDBLTFX fx;
HRESULT hr;
DWORD ret;
static const D3DCOLOR expected1[] =
{
0x000000ff, 0x0000ff00, 0x00000000, 0x00000000,
0x000000ff, 0x0000ff00, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00ff0000, 0x00ffffff,
0x00000000, 0x00000000, 0x00ff0000, 0x00ffffff,
};
static const D3DCOLOR expected2[] =
{
0x000000ff, 0x000000ff, 0x00000000, 0x00000000,
0x000000ff, 0x000000ff, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x000000ff, 0x000000ff,
0x00000000, 0x00000000, 0x000000ff, 0x000000ff,
};
window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
10, 10, 640, 480, 0, 0, 0, 0);
ShowWindow(window, SW_SHOW);
if (!(ddraw = create_ddraw()))
{
skip("Failed to create a ddraw object, skipping test.\n");
DestroyWindow(window);
return;
}
ret = GetClientRect(window, &client_rect);
ok(ret, "Failed to get client rect.\n");
ret = MapWindowPoints(window, NULL, (POINT *)&client_rect, 2);
ok(ret, "Failed to map client rect.\n");
hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
hr = IDirectDraw7_CreateClipper(ddraw, 0, &clipper, NULL);
ok(SUCCEEDED(hr), "Failed to create clipper, hr %#x.\n", hr);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr);
hr = IDirectDrawClipper_SetHWnd(clipper, 0, window);
ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
ok(SUCCEEDED(hr), "Failed to get clip list size, hr %#x.\n", hr);
rgn_data = HeapAlloc(GetProcessHeap(), 0, ret);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, rgn_data, &ret);
ok(SUCCEEDED(hr), "Failed to get clip list, hr %#x.\n", hr);
ok(rgn_data->rdh.dwSize == sizeof(rgn_data->rdh), "Got unexpected structure size %#x.\n", rgn_data->rdh.dwSize);
ok(rgn_data->rdh.iType == RDH_RECTANGLES, "Got unexpected type %#x.\n", rgn_data->rdh.iType);
ok(rgn_data->rdh.nCount == 1, "Got unexpected count %u.\n", rgn_data->rdh.nCount);
ok(rgn_data->rdh.nRgnSize == 16, "Got unexpected region size %u.\n", rgn_data->rdh.nRgnSize);
ok(EqualRect(&rgn_data->rdh.rcBound, &client_rect),
"Got unexpected bounding rect {%d, %d, %d, %d}, expected {%d, %d, %d, %d}.\n",
rgn_data->rdh.rcBound.left, rgn_data->rdh.rcBound.top,
rgn_data->rdh.rcBound.right, rgn_data->rdh.rcBound.bottom,
client_rect.left, client_rect.top, client_rect.right, client_rect.bottom);
rect = (RECT *)&rgn_data->Buffer[0];
ok(EqualRect(rect, &client_rect),
"Got unexpected clip rect {%d, %d, %d, %d}, expected {%d, %d, %d, %d}.\n",
rect->left, rect->top, rect->right, rect->bottom,
client_rect.left, client_rect.top, client_rect.right, client_rect.bottom);
HeapFree(GetProcessHeap(), 0, rgn_data);
r1 = CreateRectRgn(0, 0, 320, 240);
ok(!!r1, "Failed to create region.\n");
r2 = CreateRectRgn(320, 240, 640, 480);
ok(!!r2, "Failed to create region.\n");
CombineRgn(r1, r1, r2, RGN_OR);
ret = GetRegionData(r1, 0, NULL);
rgn_data = HeapAlloc(GetProcessHeap(), 0, ret);
ret = GetRegionData(r1, ret, rgn_data);
ok(!!ret, "Failed to get region data.\n");
DeleteObject(r2);
DeleteObject(r1);
hr = IDirectDrawClipper_SetClipList(clipper, rgn_data, 0);
ok(hr == DDERR_CLIPPERISUSINGHWND, "Got unexpected hr %#x.\n", hr);
hr = IDirectDrawClipper_SetHWnd(clipper, 0, NULL);
ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
hr = IDirectDrawClipper_SetClipList(clipper, rgn_data, 0);
ok(SUCCEEDED(hr), "Failed to set clip list, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, rgn_data);
memset(&surface_desc, 0, sizeof(surface_desc));
surface_desc.dwSize = sizeof(surface_desc);
surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
surface_desc.dwWidth = 640;
surface_desc.dwHeight = 480;
U4(surface_desc).ddpfPixelFormat.dwSize = sizeof(U4(surface_desc).ddpfPixelFormat);
U4(surface_desc).ddpfPixelFormat.dwFlags = DDPF_RGB;
U1(U4(surface_desc).ddpfPixelFormat).dwRGBBitCount = 32;
U2(U4(surface_desc).ddpfPixelFormat).dwRBitMask = 0x00ff0000;
U3(U4(surface_desc).ddpfPixelFormat).dwGBitMask = 0x0000ff00;
U4(U4(surface_desc).ddpfPixelFormat).dwBBitMask = 0x000000ff;
hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &src_surface, NULL);
ok(SUCCEEDED(hr), "Failed to create source surface, hr %#x.\n", hr);
hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &dst_surface, NULL);
ok(SUCCEEDED(hr), "Failed to create destination surface, hr %#x.\n", hr);
memset(&fx, 0, sizeof(fx));
fx.dwSize = sizeof(fx);
hr = IDirectDrawSurface7_Blt(src_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
ok(SUCCEEDED(hr), "Failed to clear source surface, hr %#x.\n", hr);
hr = IDirectDrawSurface7_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
ok(SUCCEEDED(hr), "Failed to clear destination surface, hr %#x.\n", hr);
hr = IDirectDrawSurface7_Lock(src_surface, NULL, &surface_desc, 0, NULL);
ok(SUCCEEDED(hr), "Failed to lock source surface, hr %#x.\n", hr);
((DWORD *)surface_desc.lpSurface)[0] = 0xff0000ff;
((DWORD *)surface_desc.lpSurface)[1] = 0xff00ff00;
((DWORD *)surface_desc.lpSurface)[2] = 0xffff0000;
((DWORD *)surface_desc.lpSurface)[3] = 0xffffffff;
hr = IDirectDrawSurface7_Unlock(src_surface, NULL);
ok(SUCCEEDED(hr), "Failed to unlock source surface, hr %#x.\n", hr);
hr = IDirectDrawSurface7_SetClipper(dst_surface, clipper);
ok(SUCCEEDED(hr), "Failed to set clipper, hr %#x.\n", hr);
SetRect(&src_rect, 0, 0, 4, 1);
hr = IDirectDrawSurface7_Blt(dst_surface, NULL, src_surface, &src_rect, DDBLT_WAIT, NULL);
ok(SUCCEEDED(hr), "Failed to blit, hr %#x.\n", hr);
for (i = 0; i < 4; ++i)
{
for (j = 0; j < 4; ++j)
{
x = 80 * ((2 * j) + 1);
y = 60 * ((2 * i) + 1);
color = get_surface_color(dst_surface, x, y);
ok(compare_color(color, expected1[i * 4 + j], 1),
"Expected color 0x%08x at %u,%u, got 0x%08x.\n", expected1[i * 4 + j], x, y, color);
}
}
U5(fx).dwFillColor = 0xff0000ff;
hr = IDirectDrawSurface7_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
ok(SUCCEEDED(hr), "Failed to clear destination surface, hr %#x.\n", hr);
for (i = 0; i < 4; ++i)
{
for (j = 0; j < 4; ++j)
{
x = 80 * ((2 * j) + 1);
y = 60 * ((2 * i) + 1);
color = get_surface_color(dst_surface, x, y);
ok(compare_color(color, expected2[i * 4 + j], 1),
"Expected color 0x%08x at %u,%u, got 0x%08x.\n", expected2[i * 4 + j], x, y, color);
}
}
hr = IDirectDrawSurface7_BltFast(dst_surface, 0, 0, src_surface, NULL, DDBLTFAST_WAIT);
ok(hr == DDERR_BLTFASTCANTCLIP, "Got unexpected hr %#x.\n", hr);
hr = IDirectDrawClipper_SetHWnd(clipper, 0, window);
ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
ok(SUCCEEDED(hr), "Failed to get clip list size, hr %#x.\n", hr);
DestroyWindow(window);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
ok(hr == E_FAIL, "Got unexpected hr %#x.\n", hr);
hr = IDirectDrawClipper_SetHWnd(clipper, 0, NULL);
ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
ok(SUCCEEDED(hr), "Failed to get clip list size, hr %#x.\n", hr);
hr = IDirectDrawClipper_SetClipList(clipper, NULL, 0);
ok(SUCCEEDED(hr), "Failed to set clip list, hr %#x.\n", hr);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr);
hr = IDirectDrawSurface7_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr);
IDirectDrawSurface7_Release(dst_surface);
IDirectDrawSurface7_Release(src_surface);
IDirectDrawClipper_Release(clipper);
IDirectDraw7_Release(ddraw);
}
BOOL gldCreateDrawable_DX(
DGL_ctx *ctx,
// BOOL bDefaultDriver,
BOOL bDirectDrawPersistant,
BOOL bPersistantBuffers)
{
//
// bDirectDrawPersistant: applies to IDirect3D8
// bPersistantBuffers: applies to IDirect3DDevice8
//
// D3DDEVTYPE d3dDevType;
// D3DPRESENT_PARAMETERS d3dpp;
// D3DDISPLAYMODE d3ddm;
// DWORD dwBehaviourFlags;
// D3DADAPTER_IDENTIFIER8 d3dIdent;
HRESULT hr;
GLD_driver_dx7 *lpCtx = NULL;
D3DX_VIDMODEDESC d3ddm;
// Parameters for D3DXCreateContextEx
// These will be different for fullscreen and windowed
DWORD dwDeviceIndex;
DWORD dwFlags;
HWND hwnd;
HWND hwndFocus;
DWORD numColorBits;
DWORD numAlphaBits;
DWORD numDepthBits;
DWORD numStencilBits;
DWORD numBackBuffers;
DWORD dwWidth;
DWORD dwHeight;
DWORD refreshRate;
// Error if context is NULL.
if (ctx == NULL)
return FALSE;
if (ctx->glPriv) {
lpCtx = ctx->glPriv;
// Release any existing interfaces (in reverse order)
SAFE_RELEASE(lpCtx->pDev);
SAFE_RELEASE(lpCtx->pD3D);
lpCtx->pD3DXContext->lpVtbl->Release(lpCtx->pD3DXContext);
lpCtx->pD3DXContext = NULL;
} else {
lpCtx = (GLD_driver_dx7*)malloc(sizeof(GLD_driver_dx7));
ZeroMemory(lpCtx, sizeof(lpCtx));
}
// d3dDevType = (glb.dwDriver == GLDS_DRIVER_HAL) ? D3DDEVTYPE_HAL : D3DDEVTYPE_REF;
// Use REF device if requested. Otherwise D3DX_DEFAULT will choose highest level
// of HW acceleration.
dwDeviceIndex = (glb.dwDriver == GLDS_DRIVER_REF) ? D3DX_HWLEVEL_REFERENCE : D3DX_DEFAULT;
// TODO: Check this
// if (bDefaultDriver)
// d3dDevType = D3DDEVTYPE_REF;
#ifdef _GLD_PERSISTANT
// Use persistant interface if needed
if (bDirectDrawPersistant && dx7Globals.bDirect3D) {
lpCtx->pD3D = dx7Globals.pD3D;
IDirect3D7_AddRef(lpCtx->pD3D);
goto SkipDirectDrawCreate;
}
#endif
/*
// Create Direct3D7 object
lpCtx->pD3D = dx7Globals.fnDirect3DCreate8(D3D_SDK_VERSION_DX8_SUPPORT_WIN95);
if (lpCtx->pD3D == NULL) {
MessageBox(NULL, "Unable to initialize Direct3D8", "GLDirect", MB_OK);
ddlogMessage(DDLOG_CRITICAL_OR_WARN, "Unable to create Direct3D8 interface");
nContextError = GLDERR_D3D;
goto return_with_error;
}
*/
#ifdef _GLD_PERSISTANT
// Cache Direct3D interface for subsequent GLRCs
if (bDirectDrawPersistant && !dx8Globals.bDirect3D) {
dx7Globals.pD3D = lpCtx->pD3D;
IDirect3D7_AddRef(dx7Globals.pD3D);
dx7Globals.bDirect3D = TRUE;
}
SkipDirectDrawCreate:
#endif
/*
// Get the display mode so we can make a compatible backbuffer
hResult = IDirect3D8_GetAdapterDisplayMode(lpCtx->pD3D, glb.dwAdapter, &d3ddm);
if (FAILED(hResult)) {
nContextError = GLDERR_D3D;
goto return_with_error;
}
*/
#if 0
// Get device caps
hResult = IDirect3D8_GetDeviceCaps(lpCtx->pD3D, glb.dwAdapter, d3dDevType, &lpCtx->d3dCaps8);
if (FAILED(hResult)) {
ddlogError(DDLOG_CRITICAL_OR_WARN, "IDirect3D8_GetDeviceCaps failed", hResult);
nContextError = GLDERR_D3D;
goto return_with_error;
}
// Check for hardware transform & lighting
lpCtx->bHasHWTnL = lpCtx->d3dCaps8.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT ? TRUE : FALSE;
// If this flag is present then we can't default to Mesa
// SW rendering between BeginScene() and EndScene().
if (lpCtx->d3dCaps8.Caps2 & D3DCAPS2_NO2DDURING3DSCENE) {
ddlogMessage(DDLOG_WARN,
"Warning : No 2D allowed during 3D scene.\n");
}
#endif
//
// Create the Direct3D context
//
#ifdef _GLD_PERSISTANT
// Re-use original IDirect3DDevice if persistant buffers exist.
// Note that we test for persistant IDirect3D8 as well
// bDirectDrawPersistant == persistant IDirect3D8 (DirectDraw8 does not exist)
if (bDirectDrawPersistant && bPersistantBuffers && dx7Globals.pD3D && dx7Globals.pDev) {
lpCtx->pDev = dx7Globals.pDev;
IDirect3DDevice7_AddRef(dx7Globals.pDev);
goto skip_direct3ddevice_create;
}
#endif
/*
// Clear the presentation parameters (sets all members to zero)
ZeroMemory(&d3dpp, sizeof(d3dpp));
// Recommended by MS; needed for MultiSample.
// Be careful if altering this for FullScreenBlit
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = d3ddm.Format;
d3dpp.BackBufferCount = 1;
d3dpp.MultiSampleType = _gldGetDeviceMultiSampleType(lpCtx->pD3D, d3ddm.Format, d3dDevType, !ctx->bFullscreen);
d3dpp.AutoDepthStencilFormat = ctx->lpPF->dwDriverData;
d3dpp.EnableAutoDepthStencil = (d3dpp.AutoDepthStencilFormat == D3DFMT_UNKNOWN) ? FALSE : TRUE;
if (ctx->bFullscreen) {
ddlogWarnOption(FALSE); // Don't popup any messages in fullscreen
d3dpp.Windowed = FALSE;
d3dpp.BackBufferWidth = d3ddm.Width;
d3dpp.BackBufferHeight = d3ddm.Height;
d3dpp.hDeviceWindow = ctx->hWnd;
d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
// Support for vertical retrace synchronisation.
// Set default presentation interval in case caps bits are missing
d3dpp.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
if (glb.bWaitForRetrace) {
if (lpCtx->d3dCaps8.PresentationIntervals & D3DPRESENT_INTERVAL_ONE)
d3dpp.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_ONE;
} else {
if (lpCtx->d3dCaps8.PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE)
d3dpp.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
}
} else {
ddlogWarnOption(glb.bMessageBoxWarnings); // OK to popup messages
d3dpp.Windowed = TRUE;
d3dpp.BackBufferWidth = ctx->dwWidth;
d3dpp.BackBufferHeight = ctx->dwHeight;
d3dpp.hDeviceWindow = ctx->hWnd;
d3dpp.FullScreen_RefreshRateInHz = 0;
// FullScreen_PresentationInterval must be default for Windowed mode
d3dpp.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
}
// Decide if we can use hardware TnL
dwBehaviourFlags = (lpCtx->bHasHWTnL) ?
D3DCREATE_MIXED_VERTEXPROCESSING : D3DCREATE_SOFTWARE_VERTEXPROCESSING;
// Add flag to tell D3D to be thread-safe
if (glb.bMultiThreaded)
dwBehaviourFlags |= D3DCREATE_MULTITHREADED;
hResult = IDirect3D8_CreateDevice(lpCtx->pD3D,
glb.dwAdapter,
d3dDevType,
ctx->hWnd,
dwBehaviourFlags,
&d3dpp,
&lpCtx->pDev);
if (FAILED(hResult)) {
ddlogError(DDLOG_CRITICAL_OR_WARN, "IDirect3D8_CreateDevice failed", hResult);
nContextError = GLDERR_D3D;
goto return_with_error;
}
*/
// Create D3DX context
if (ctx->bFullscreen) {
//
// FULLSCREEN
//
// Get display mode
D3DXGetCurrentVideoMode(D3DX_DEFAULT, &d3ddm);
// Fullscreen Parameters
dwFlags = D3DX_CONTEXT_FULLSCREEN;
hwnd = ctx->hWnd;
hwndFocus = ctx->hWnd;
numColorBits = ctx->lpPF->pfd.cColorBits;
numAlphaBits = ctx->lpPF->pfd.cAlphaBits;
numDepthBits = ctx->lpPF->pfd.cDepthBits + ctx->lpPF->pfd.cStencilBits;
numStencilBits = ctx->lpPF->pfd.cStencilBits;
numBackBuffers = D3DX_DEFAULT; // Default is 1 backbuffer
dwWidth = d3ddm.width;
dwHeight = d3ddm.height;
refreshRate = d3ddm.refreshRate; // D3DX_DEFAULT;
} else {
//
// WINDOWED
//
// Windowed Parameters
dwFlags = 0; // No flags means "windowed"
hwnd = ctx->hWnd;
hwndFocus = (HWND)D3DX_DEFAULT;
numColorBits = D3DX_DEFAULT; // Use Desktop depth
numAlphaBits = ctx->lpPF->pfd.cAlphaBits;
numDepthBits = ctx->lpPF->pfd.cDepthBits + ctx->lpPF->pfd.cStencilBits;
numStencilBits = ctx->lpPF->pfd.cStencilBits;
numBackBuffers = D3DX_DEFAULT; // Default is 1 backbuffer
dwWidth = ctx->dwWidth;
dwHeight = ctx->dwHeight;
refreshRate = D3DX_DEFAULT;
}
hr = D3DXCreateContextEx(dwDeviceIndex, dwFlags, hwnd, hwndFocus,
numColorBits, numAlphaBits, numDepthBits, numStencilBits,
numBackBuffers,
dwWidth, dwHeight, refreshRate,
&lpCtx->pD3DXContext);
if (FAILED(hr)) {
ddlogError(DDLOG_CRITICAL_OR_WARN, "D3DXCreateContextEx failed", hr);
nContextError = GLDERR_D3D;
goto return_with_error;
}
// Obtain D3D7 interfaces from ID3DXContext
// lpCtx->pDD = ID3DXContext_GetDD(lpCtx->pD3DXContext);
lpCtx->pDD = lpCtx->pD3DXContext->lpVtbl->GetDD(lpCtx->pD3DXContext);
if (lpCtx->pDD == NULL)
goto return_with_error;
lpCtx->pD3D = lpCtx->pD3DXContext->lpVtbl->GetD3D(lpCtx->pD3DXContext);
if (lpCtx->pD3D == NULL)
goto return_with_error;
lpCtx->pDev = lpCtx->pD3DXContext->lpVtbl->GetD3DDevice(lpCtx->pD3DXContext);
if (lpCtx->pDev == NULL)
goto return_with_error;
// Need to manage clipper manually for multiple windows
// since DX7 D3DX utility lib does not appear to do that. (DaveM)
if (!ctx->bFullscreen) {
// Get primary surface too
lpDDSPrimary = lpCtx->pD3DXContext->lpVtbl->GetPrimary(lpCtx->pD3DXContext);
if (lpDDSPrimary == NULL) {
ddlogPrintf(DDLOG_WARN, "GetPrimary");
goto return_with_error;
}
// Create clipper for correct window updates
if (IDirectDraw7_CreateClipper(lpCtx->pDD, 0, &lpDDClipper, NULL) != DD_OK) {
ddlogPrintf(DDLOG_WARN, "CreateClipper");
goto return_with_error;
}
// Set the window that the clipper belongs to
if (IDirectDrawClipper_SetHWnd(lpDDClipper, 0, hwnd) != DD_OK) {
ddlogPrintf(DDLOG_WARN, "SetHWnd");
goto return_with_error;
}
// Attach the clipper to the primary surface
if (IDirectDrawSurface7_SetClipper(lpDDSPrimary, lpDDClipper) != DD_OK) {
ddlogPrintf(DDLOG_WARN, "SetClipper");
goto return_with_error;
}
}
// Get device caps
IDirect3DDevice7_GetCaps(lpCtx->pDev, &lpCtx->d3dCaps);
// Determine HW TnL
lpCtx->bHasHWTnL = lpCtx->d3dCaps.dwDevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT ? TRUE : FALSE;
#ifdef _GLD_PERSISTANT
if (bDirectDrawPersistant && bPersistantBuffers && dx7Globals.pD3D) {
dx7Globals.pDev = lpCtx->pDev;
dx7Globals.bDirect3DDevice = TRUE;
}
#endif
#if 0
// Dump some useful stats
hResult = IDirect3D8_GetAdapterIdentifier(
lpCtx->pD3D,
glb.dwAdapter,
D3DENUM_NO_WHQL_LEVEL, // Avoids 1 to 2 second delay
&d3dIdent);
if (SUCCEEDED(hResult)) {
ddlogPrintf(DDLOG_INFO, "[Driver Description: %s]", &d3dIdent.Description);
ddlogPrintf(DDLOG_INFO, "[Driver file: %s %d.%d.%02d.%d]",
d3dIdent.Driver,
HIWORD(d3dIdent.DriverVersion.HighPart),
LOWORD(d3dIdent.DriverVersion.HighPart),
HIWORD(d3dIdent.DriverVersion.LowPart),
LOWORD(d3dIdent.DriverVersion.LowPart));
ddlogPrintf(DDLOG_INFO, "[VendorId: 0x%X, DeviceId: 0x%X, SubSysId: 0x%X, Revision: 0x%X]",
d3dIdent.VendorId, d3dIdent.DeviceId, d3dIdent.SubSysId, d3dIdent.Revision);
}
#endif
// Init projection matrix for D3D TnL
D3DXMatrixIdentity((D3DXMATRIX*)&lpCtx->matProjection);
lpCtx->matModelView = lpCtx->matProjection;
// gld->bUseMesaProjection = TRUE;
skip_direct3ddevice_create:
// Create buffers to hold primitives
lpCtx->PB2d.dwFVF = GLD_FVF_2D_VERTEX;
// lpCtx->PB2d.dwPool = D3DPOOL_SYSTEMMEM;
lpCtx->PB2d.dwStride = sizeof(GLD_2D_VERTEX);
lpCtx->PB2d.dwCreateFlags = D3DVBCAPS_DONOTCLIP |
D3DVBCAPS_SYSTEMMEMORY |
D3DVBCAPS_WRITEONLY;
hr = _gldCreatePrimitiveBuffer(ctx->glCtx, lpCtx, &lpCtx->PB2d);
if (FAILED(hr))
goto return_with_error;
lpCtx->PB3d.dwFVF = GLD_FVF_3D_VERTEX;
// lpCtx->PB3d.dwPool = D3DPOOL_DEFAULT;
lpCtx->PB3d.dwStride = sizeof(GLD_3D_VERTEX);
lpCtx->PB3d.dwCreateFlags = D3DVBCAPS_WRITEONLY;
hr = _gldCreatePrimitiveBuffer(ctx->glCtx, lpCtx, &lpCtx->PB3d);
if (FAILED(hr))
goto return_with_error;
// Zero the pipeline usage counters
lpCtx->PipelineUsage.qwMesa.QuadPart =
// lpCtx->PipelineUsage.dwD3D2SVS.QuadPart =
lpCtx->PipelineUsage.qwD3DFVF.QuadPart = 0;
// Assign drawable to GL private
ctx->glPriv = lpCtx;
return TRUE;
return_with_error:
// Clean up and bail
_gldDestroyPrimitiveBuffer(&lpCtx->PB3d);
_gldDestroyPrimitiveBuffer(&lpCtx->PB2d);
SAFE_RELEASE(lpCtx->pDev);
SAFE_RELEASE(lpCtx->pD3D);
//SAFE_RELEASE(lpCtx->pD3DXContext);
lpCtx->pD3DXContext->lpVtbl->Release(lpCtx->pD3DXContext);
return FALSE;
}
static int
_directdraw_init (HWND window,
LPDIRECTDRAW *object,
LPDIRECTDRAWSURFACE *surface_primary,
LPDIRECTDRAWSURFACE *surface_back,
int *depth,
int width,
int height)
{
DDSURFACEDESC2 surface_desc;
DDPIXELFORMAT pixel_format;
LPDIRECTDRAWCLIPPER clipper;
LPDIRECTDRAW o;
DDSURFACEDESC2 *sd;
HRESULT res;
res = DirectDrawCreateEx (NULL, (void **)&o, &IID_IDirectDraw7, NULL);
if (FAILED(res))
return 0;
res = IDirectDraw7_SetCooperativeLevel (o, window, DDSCL_NORMAL);
if (FAILED(res))
{
IDirectDraw7_Release (o);
return 0;
}
res = IDirectDraw7_CreateClipper (o, 0, &clipper, NULL);
if (FAILED(res))
{
IDirectDraw7_Release (o);
return 0;
}
res = IDirectDrawClipper_SetHWnd (clipper, 0, window);
if (FAILED(res))
{
IDirectDrawClipper_Release (clipper);
IDirectDraw7_Release (o);
return 0;
}
memset(&surface_desc, 0, sizeof(surface_desc));
surface_desc.dwSize = sizeof(surface_desc);
surface_desc.dwFlags = DDSD_CAPS;
surface_desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
sd=&surface_desc;
res = IDirectDraw7_CreateSurface (o, &surface_desc,
surface_primary, NULL);
if (FAILED(res))
{
IDirectDrawClipper_Release (clipper);
IDirectDraw7_Release (o);
return 0;
}
res = IDirectDrawSurface7_SetClipper (*surface_primary, clipper);
if (FAILED(res))
{
IDirectDrawClipper_Release (clipper);
IDirectDrawSurface7_Release (*surface_primary);
IDirectDraw7_Release (o);
return 0;
}
memset (&surface_desc, 0, sizeof(surface_desc));
surface_desc.dwSize = sizeof(surface_desc);
surface_desc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
surface_desc.dwWidth = width;
surface_desc.dwHeight = height;
sd=&surface_desc;
res = IDirectDraw7_CreateSurface (o, (DDSURFACEDESC *)sd,
surface_back, NULL);
if (FAILED(res))
{
IDirectDrawClipper_Release (clipper);
IDirectDrawSurface7_Release (*surface_primary);
IDirectDraw7_Release (o);
return 0;
}
ZeroMemory(&pixel_format, sizeof(pixel_format));
pixel_format.dwSize = sizeof(pixel_format);
IDirectDrawSurface7_GetPixelFormat(*surface_primary, &pixel_format);
*object = o;
*depth = pixel_format.dwRGBBitCount;
return 1;
}
// 创建 DirectDraw屏幕
// 如果 bpp为0的话则创建窗口模式，w,h失效，否则全屏幕
CSURFACE *DDrawCreateScreen(HWND hWnd, int w, int h, int bpp, HRESULT *HR)
{
DDSURFACEDESC2 ddsd;
CSURFACE *surface;
HRESULT hr;
if (lpDirectDraw7 == NULL) {
if (DDrawInit() != 0) return NULL;
}
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
// 创建窗口模式
if (bpp == 0) {
hr = IDirectDraw7_SetCooperativeLevel(lpDirectDraw7, hWnd,
DDSCL_NORMAL);
if (hr != DD_OK) {
fprintf(stderr, "DirectDraw: SetCooperativeLevel failed\n");
fflush(stderr);
if (HR) *HR = hr;
return NULL;
}
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
surface = DDrawCreateFromDesc(&ddsd, &hr);
if (surface == NULL) {
fprintf(stderr, "DirectDraw: Create Primary Surface failed\n");
fflush(stderr);
if (HR) *HR = hr;
return NULL;
}
hr = IDirectDraw7_CreateClipper(lpDirectDraw7, 0, &surface->clip, 0);
if (hr != DD_OK) {
fprintf(stderr, "DirectDraw: Create Clipper failed\n");
fflush(stderr);
if (HR) *HR = hr;
surface->clip = NULL;
DDrawSurfaceRelease(surface);
return NULL;
}
hr = IDirectDrawClipper_SetHWnd(surface->clip, 0, hWnd);
if (hr != DD_OK) {
fprintf(stderr, "DirectDraw: SetHWnd failed\n");
fflush(stderr);
if (HR) *HR = hr;
DDrawSurfaceRelease(surface);
return NULL;
}
hr = IDirectDrawSurface7_SetClipper(surface->lpDDS, surface->clip);
if (hr != DD_OK) {
fprintf(stderr, "DirectDraw: SetClipper failed\n");
fflush(stderr);
if (HR) *HR = hr;
DDrawSurfaceRelease(surface);
return NULL;
}
}
else { // 创建全屏模式
DWORD dwFlags;
if (hFullScreenMode) {
fprintf(stderr, "DirectDraw: Already in Full Screen Mode\n");
fflush(stderr);
return NULL;
}
dwFlags = DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT |
DDSCL_ALLOWMODEX;
hr = IDirectDraw7_SetCooperativeLevel(lpDirectDraw7, hWnd, dwFlags);
if (hr != DD_OK) {
fprintf(stderr, "DirectDraw: SetCooperativeLevel failed\n");
fflush(stderr);
if (HR) *HR = hr;
return NULL;
}
hr = IDirectDraw7_SetDisplayMode(lpDirectDraw7, w, h, bpp, 0,
DDSDM_STANDARDVGAMODE);
if (hr != DD_OK) {
fprintf(stderr, "DirectDraw: SetDisplayMode failed\n");
fflush(stderr);
if (HR) *HR = hr;
return NULL;
}
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP |
DDSCAPS_COMPLEX;
ddsd.dwBackBufferCount = 1;
surface = DDrawCreateFromDesc(&ddsd, &hr);
if (surface == NULL) {
fprintf(stderr, "DirectDraw: Create Primary Surface failed\n");
fflush(stderr);
IDirectDraw7_RestoreDisplayMode(lpDirectDraw7);
if (HR) *HR = hr;
return NULL;
}
hFullScreenMode = 1;
}
IDirectDraw7_GetDisplayMode(lpDirectDraw7, &ddsd);
surface->primary = 1;
surface->hWnd = hWnd;
return surface;
}
