/* * Copyright 2011-2012 Henri Verbeet for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #define COBJMACROS #include "wine/test.h" #include "d3d.h" struct create_window_thread_param { HWND window; HANDLE window_created; HANDLE destroy_window; HANDLE thread; }; static BOOL compare_color(D3DCOLOR c1, D3DCOLOR c2, BYTE max_diff) { if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE; c1 >>= 8; c2 >>= 8; if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE; c1 >>= 8; c2 >>= 8; if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE; c1 >>= 8; c2 >>= 8; if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE; return TRUE; } static DWORD WINAPI create_window_thread_proc(void *param) { struct create_window_thread_param *p = param; DWORD res; BOOL ret; p->window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, 0, 0); ret = SetEvent(p->window_created); ok(ret, "SetEvent failed, last error %#x.\n", GetLastError()); for (;;) { MSG msg; while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessage(&msg); res = WaitForSingleObject(p->destroy_window, 100); if (res == WAIT_OBJECT_0) break; if (res != WAIT_TIMEOUT) { ok(0, "Wait failed (%#x), last error %#x.\n", res, GetLastError()); break; } } DestroyWindow(p->window); return 0; } static void create_window_thread(struct create_window_thread_param *p) { DWORD res, tid; p->window_created = CreateEvent(NULL, FALSE, FALSE, NULL); ok(!!p->window_created, "CreateEvent failed, last error %#x.\n", GetLastError()); p->destroy_window = CreateEvent(NULL, FALSE, FALSE, NULL); ok(!!p->destroy_window, "CreateEvent failed, last error %#x.\n", GetLastError()); p->thread = CreateThread(NULL, 0, create_window_thread_proc, p, 0, &tid); ok(!!p->thread, "Failed to create thread, last error %#x.\n", GetLastError()); res = WaitForSingleObject(p->window_created, INFINITE); ok(res == WAIT_OBJECT_0, "Wait failed (%#x), last error %#x.\n", res, GetLastError()); } static void destroy_window_thread(struct create_window_thread_param *p) { SetEvent(p->destroy_window); WaitForSingleObject(p->thread, INFINITE); CloseHandle(p->destroy_window); CloseHandle(p->window_created); CloseHandle(p->thread); } static IDirectDrawSurface *get_depth_stencil(IDirect3DDevice2 *device) { IDirectDrawSurface *rt, *ret; DDSCAPS caps = {DDSCAPS_ZBUFFER}; HRESULT hr; hr = IDirect3DDevice2_GetRenderTarget(device, &rt); ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr); hr = IDirectDrawSurface_GetAttachedSurface(rt, &caps, &ret); ok(SUCCEEDED(hr) || hr == DDERR_NOTFOUND, "Failed to get the z buffer, hr %#x.\n", hr); IDirectDrawSurface_Release(rt); return ret; } static D3DCOLOR get_surface_color(IDirectDrawSurface *surface, UINT x, UINT y) { RECT rect = {x, y, x + 1, y + 1}; DDSURFACEDESC surface_desc; D3DCOLOR color; HRESULT hr; memset(&surface_desc, 0, sizeof(surface_desc)); surface_desc.dwSize = sizeof(surface_desc); hr = IDirectDrawSurface_Lock(surface, &rect, &surface_desc, DDLOCK_READONLY | DDLOCK_WAIT, NULL); ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr); if (FAILED(hr)) return 0xdeadbeef; color = *((DWORD *)surface_desc.lpSurface) & 0x00ffffff; hr = IDirectDrawSurface_Unlock(surface, NULL); ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr); return color; } static HRESULT CALLBACK enum_z_fmt(GUID *guid, char *description, char *name, D3DDEVICEDESC *hal_desc, D3DDEVICEDESC *hel_desc, void *ctx) { DWORD *z_depth = ctx; if (!IsEqualGUID(&IID_IDirect3DHALDevice, guid)) return D3DENUMRET_OK; if (hal_desc->dwDeviceZBufferBitDepth & DDBD_32) *z_depth = 32; else if (hal_desc->dwDeviceZBufferBitDepth & DDBD_24) *z_depth = 24; else if (hal_desc->dwDeviceZBufferBitDepth & DDBD_16) *z_depth = 16; return DDENUMRET_OK; } static IDirectDraw2 *create_ddraw(void) { IDirectDraw2 *ddraw2; IDirectDraw *ddraw1; HRESULT hr; if (FAILED(DirectDrawCreate(NULL, &ddraw1, NULL))) return NULL; hr = IDirectDraw_QueryInterface(ddraw1, &IID_IDirectDraw2, (void **)&ddraw2); IDirectDraw_Release(ddraw1); if (FAILED(hr)) return NULL; return ddraw2; } static IDirect3DDevice2 *create_device(IDirectDraw2 *ddraw, HWND window, DWORD coop_level) { IDirectDrawSurface *surface, *ds; IDirect3DDevice2 *device = NULL; DDSURFACEDESC surface_desc; DWORD z_depth = 0; IDirect3D2 *d3d; HRESULT hr; hr = IDirectDraw2_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 = IDirectDraw2_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 = IDirectDraw2_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 = IDirectDrawSurface_SetClipper(surface, clipper); ok(SUCCEEDED(hr), "Failed to set surface clipper, hr %#x.\n", hr); IDirectDrawClipper_Release(clipper); } hr = IDirectDraw2_QueryInterface(ddraw, &IID_IDirect3D2, (void **)&d3d); if (FAILED(hr)) { IDirectDrawSurface_Release(surface); return NULL; } hr = IDirect3D2_EnumDevices(d3d, enum_z_fmt, &z_depth); ok(SUCCEEDED(hr), "Failed to enumerate z-formats, hr %#x.\n", hr); if (FAILED(hr) || !z_depth) { IDirect3D2_Release(d3d); IDirectDrawSurface_Release(surface); return NULL; } memset(&surface_desc, 0, sizeof(surface_desc)); surface_desc.dwSize = sizeof(surface_desc); surface_desc.dwFlags = DDSD_CAPS | DDSD_ZBUFFERBITDEPTH | DDSD_WIDTH | DDSD_HEIGHT; surface_desc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER; U2(surface_desc).dwZBufferBitDepth = z_depth; surface_desc.dwWidth = 640; surface_desc.dwHeight = 480; hr = IDirectDraw2_CreateSurface(ddraw, &surface_desc, &ds, NULL); ok(SUCCEEDED(hr), "Failed to create depth buffer, hr %#x.\n", hr); if (FAILED(hr)) { IDirect3D2_Release(d3d); IDirectDrawSurface_Release(surface); return NULL; } hr = IDirectDrawSurface_AddAttachedSurface(surface, ds); ok(SUCCEEDED(hr), "Failed to attach depth buffer, hr %#x.\n", hr); IDirectDrawSurface_Release(ds); if (FAILED(hr)) { IDirect3D2_Release(d3d); IDirectDrawSurface_Release(surface); return NULL; } hr = IDirect3D2_CreateDevice(d3d, &IID_IDirect3DHALDevice, surface, &device); IDirect3D2_Release(d3d); IDirectDrawSurface_Release(surface); if (FAILED(hr)) return NULL; return device; } static IDirect3DViewport2 *create_viewport(IDirect3DDevice2 *device, UINT x, UINT y, UINT w, UINT h) { IDirect3DViewport2 *viewport; D3DVIEWPORT2 vp; IDirect3D2 *d3d; HRESULT hr; hr = IDirect3DDevice2_GetDirect3D(device, &d3d); ok(SUCCEEDED(hr), "Failed to get d3d interface, hr %#x.\n", hr); hr = IDirect3D2_CreateViewport(d3d, &viewport, NULL); ok(SUCCEEDED(hr), "Failed to create viewport, hr %#x.\n", hr); hr = IDirect3DDevice2_AddViewport(device, viewport); ok(SUCCEEDED(hr), "Failed to add viewport, hr %#x.\n", hr); memset(&vp, 0, sizeof(vp)); vp.dwSize = sizeof(vp); vp.dwX = x; vp.dwY = y; vp.dwWidth = w; vp.dwHeight = h; vp.dvClipX = -1.0f; vp.dvClipY = 1.0f; vp.dvClipWidth = 2.0f; vp.dvClipHeight = 2.0f; vp.dvMinZ = 0.0f; vp.dvMaxZ = 1.0f; hr = IDirect3DViewport2_SetViewport2(viewport, &vp); ok(SUCCEEDED(hr), "Failed to set viewport data, hr %#x.\n", hr); IDirect3D2_Release(d3d); return viewport; } static void viewport_set_background(IDirect3DDevice2 *device, IDirect3DViewport2 *viewport, IDirect3DMaterial2 *material) { D3DMATERIALHANDLE material_handle; HRESULT hr; hr = IDirect3DMaterial2_GetHandle(material, device, &material_handle); ok(SUCCEEDED(hr), "Failed to get material handle, hr %#x.\n", hr); hr = IDirect3DViewport2_SetBackground(viewport, material_handle); ok(SUCCEEDED(hr), "Failed to set viewport background, hr %#x.\n", hr); } static void destroy_viewport(IDirect3DDevice2 *device, IDirect3DViewport2 *viewport) { HRESULT hr; hr = IDirect3DDevice2_DeleteViewport(device, viewport); ok(SUCCEEDED(hr), "Failed to delete viewport, hr %#x.\n", hr); IDirect3DViewport2_Release(viewport); } static IDirect3DMaterial2 *create_diffuse_material(IDirect3DDevice2 *device, float r, float g, float b, float a) { IDirect3DMaterial2 *material; D3DMATERIAL mat; IDirect3D2 *d3d; HRESULT hr; hr = IDirect3DDevice2_GetDirect3D(device, &d3d); ok(SUCCEEDED(hr), "Failed to get d3d interface, hr %#x.\n", hr); hr = IDirect3D2_CreateMaterial(d3d, &material, NULL); ok(SUCCEEDED(hr), "Failed to create material, hr %#x.\n", hr); memset(&mat, 0, sizeof(mat)); mat.dwSize = sizeof(mat); U1(U(mat).diffuse).r = r; U2(U(mat).diffuse).g = g; U3(U(mat).diffuse).b = b; U4(U(mat).diffuse).a = a; hr = IDirect3DMaterial2_SetMaterial(material, &mat); ok(SUCCEEDED(hr), "Failed to set material data, hr %#x.\n", hr); IDirect3D2_Release(d3d); return material; } static void destroy_material(IDirect3DMaterial2 *material) { IDirect3DMaterial2_Release(material); } static const UINT *expect_messages; static LRESULT CALLBACK test_proc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) { if (expect_messages && message == *expect_messages) ++expect_messages; return DefWindowProcA(hwnd, message, wparam, lparam); } /* Set the wndproc back to what ddraw expects it to be, and release the ddraw * interface. This prevents subsequent SetCooperativeLevel() calls on a * different window from failing with DDERR_HWNDALREADYSET. */ static void fix_wndproc(HWND window, LONG_PTR proc) { IDirectDraw2 *ddraw; HRESULT hr; if (!(ddraw = create_ddraw())) return; SetWindowLongPtrA(window, GWLP_WNDPROC, proc); hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); IDirectDraw2_Release(ddraw); } static HRESULT CALLBACK restore_callback(IDirectDrawSurface *surface, DDSURFACEDESC *desc, void *context) { HRESULT hr = IDirectDrawSurface_Restore(surface); ok(SUCCEEDED(hr), "Failed to restore surface, hr %#x.\n", hr); IDirectDrawSurface_Release(surface); return DDENUMRET_OK; } static HRESULT restore_surfaces(IDirectDraw2 *ddraw) { return IDirectDraw2_EnumSurfaces(ddraw, DDENUMSURFACES_ALL | DDENUMSURFACES_DOESEXIST, NULL, NULL, restore_callback); } static void test_coop_level_create_device_window(void) { HWND focus_window, device_window; IDirectDraw2 *ddraw; HRESULT hr; focus_window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, 0, 0); if (!(ddraw = create_ddraw())) { skip("Failed to create a ddraw object, skipping test.\n"); DestroyWindow(focus_window); return; } hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL); ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!device_window, "Unexpected device window found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW); ok(hr == DDERR_INVALIDPARAMS, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!device_window, "Unexpected device window found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_NORMAL); ok(hr == DDERR_INVALIDPARAMS, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!device_window, "Unexpected device window found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_NORMAL | DDSCL_FULLSCREEN); ok(hr == DDERR_INVALIDPARAMS, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!device_window, "Unexpected device window found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(hr == DDERR_NOFOCUSWINDOW || broken(hr == DDERR_INVALIDPARAMS), "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!device_window, "Unexpected device window found.\n"); /* Windows versions before 98 / NT5 don't support DDSCL_CREATEDEVICEWINDOW. */ if (broken(hr == DDERR_INVALIDPARAMS)) { win_skip("DDSCL_CREATEDEVICEWINDOW not supported, skipping test.\n"); IDirectDraw2_Release(ddraw); DestroyWindow(focus_window); return; } hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL); ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!device_window, "Unexpected device window found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, focus_window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!device_window, "Unexpected device window found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL); ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!device_window, "Unexpected device window found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_SETFOCUSWINDOW | DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(hr == DDERR_NOHWND, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!!device_window, "Device window not found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL); ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!device_window, "Unexpected device window found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, focus_window, DDSCL_SETFOCUSWINDOW | DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!!device_window, "Device window not found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL); ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!device_window, "Unexpected device window found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(hr == DDERR_NOFOCUSWINDOW, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!device_window, "Unexpected device window found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, focus_window, DDSCL_SETFOCUSWINDOW); ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!device_window, "Unexpected device window found.\n"); hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd"); ok(!!device_window, "Device window not found.\n"); IDirectDraw2_Release(ddraw); DestroyWindow(focus_window); } static void test_clipper_blt(void) { IDirectDrawSurface *src_surface, *dst_surface; RECT client_rect, src_rect, *rect; IDirectDrawClipper *clipper; DDSURFACEDESC surface_desc; unsigned int i, j, x, y; IDirectDraw2 *ddraw; RGNDATA *rgn_data; D3DCOLOR color; HRGN r1, r2; HWND window; DDBLTFX fx; HRESULT hr; DWORD *ptr; DWORD ret; static const DWORD src_data[] = { 0xff0000ff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffffffff, 0xffffffff, 0xff0000ff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffffffff, 0xffffffff, 0xff0000ff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffffffff, 0xffffffff, }; 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 = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL); ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr); hr = IDirectDraw2_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 || broken(rgn_data->rdh.nRgnSize == 168 /* NT4 */), "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; surface_desc.ddpfPixelFormat.dwSize = sizeof(surface_desc.ddpfPixelFormat); surface_desc.ddpfPixelFormat.dwFlags = DDPF_RGB; U1(surface_desc.ddpfPixelFormat).dwRGBBitCount = 32; U2(surface_desc.ddpfPixelFormat).dwRBitMask = 0x00ff0000; U3(surface_desc.ddpfPixelFormat).dwGBitMask = 0x0000ff00; U4(surface_desc.ddpfPixelFormat).dwBBitMask = 0x000000ff; hr = IDirectDraw2_CreateSurface(ddraw, &surface_desc, &src_surface, NULL); ok(SUCCEEDED(hr), "Failed to create source surface, hr %#x.\n", hr); hr = IDirectDraw2_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 = IDirectDrawSurface_Blt(src_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx); ok(SUCCEEDED(hr), "Failed to clear source surface, hr %#x.\n", hr); hr = IDirectDrawSurface_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx); ok(SUCCEEDED(hr), "Failed to clear destination surface, hr %#x.\n", hr); hr = IDirectDrawSurface_Lock(src_surface, NULL, &surface_desc, DDLOCK_WAIT, NULL); ok(SUCCEEDED(hr), "Failed to lock source surface, hr %#x.\n", hr); ok(U1(surface_desc).lPitch == 2560, "Got unexpected surface pitch %u.\n", U1(surface_desc).lPitch); ptr = surface_desc.lpSurface; memcpy(&ptr[ 0], &src_data[ 0], 6 * sizeof(DWORD)); memcpy(&ptr[ 640], &src_data[ 6], 6 * sizeof(DWORD)); memcpy(&ptr[1280], &src_data[12], 6 * sizeof(DWORD)); hr = IDirectDrawSurface_Unlock(src_surface, NULL); ok(SUCCEEDED(hr), "Failed to unlock source surface, hr %#x.\n", hr); hr = IDirectDrawSurface_SetClipper(dst_surface, clipper); ok(SUCCEEDED(hr), "Failed to set clipper, hr %#x.\n", hr); SetRect(&src_rect, 1, 1, 5, 2); hr = IDirectDrawSurface_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 = IDirectDrawSurface_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 = IDirectDrawSurface_BltFast(dst_surface, 0, 0, src_surface, NULL, DDBLTFAST_WAIT); ok(hr == DDERR_BLTFASTCANTCLIP || broken(hr == E_NOTIMPL /* NT4 */), "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 = IDirectDrawSurface_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx); ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr); IDirectDrawSurface_Release(dst_surface); IDirectDrawSurface_Release(src_surface); IDirectDrawClipper_Release(clipper); IDirectDraw2_Release(ddraw); } static void test_coop_level_d3d_state(void) { D3DRECT clear_rect = {{0}, {0}, {640}, {480}}; IDirectDrawSurface *rt, *surface; IDirect3DMaterial2 *background; IDirect3DViewport2 *viewport; IDirect3DDevice2 *device; D3DMATERIAL material; IDirectDraw2 *ddraw; D3DCOLOR color; DWORD value; HWND window; HRESULT hr; window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, 0, 0); if (!(ddraw = create_ddraw())) { skip("Failed to create ddraw object, skipping test.\n"); DestroyWindow(window); return; } if (!(device = create_device(ddraw, window, DDSCL_NORMAL))) { skip("Failed to create D3D device, skipping test.\n"); IDirectDraw2_Release(ddraw); DestroyWindow(window); return; } background = create_diffuse_material(device, 1.0f, 0.0f, 0.0f, 1.0f); viewport = create_viewport(device, 0, 0, 640, 480); viewport_set_background(device, viewport, background); hr = IDirect3DDevice2_GetRenderTarget(device, &rt); ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr); hr = IDirect3DDevice2_GetRenderState(device, D3DRENDERSTATE_ZENABLE, &value); ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr); ok(!!value, "Got unexpected z-enable state %#x.\n", value); hr = IDirect3DDevice2_GetRenderState(device, D3DRENDERSTATE_ALPHABLENDENABLE, &value); ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr); ok(!value, "Got unexpected alpha blend enable state %#x.\n", value); hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_ALPHABLENDENABLE, TRUE); ok(SUCCEEDED(hr), "Failed to set render state, hr %#x.\n", hr); hr = IDirect3DViewport2_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET); ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr); color = get_surface_color(rt, 320, 240); ok(compare_color(color, 0x00ff0000, 1), "Got unexpected color 0x%08x.\n", color); hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr); hr = IDirectDrawSurface_IsLost(rt); ok(hr == DDERR_SURFACELOST, "Got unexpected hr %#x.\n", hr); hr = restore_surfaces(ddraw); ok(SUCCEEDED(hr), "Failed to restore surfaces, hr %#x.\n", hr); memset(&material, 0, sizeof(material)); material.dwSize = sizeof(material); U1(U(material).diffuse).r = 0.0f; U2(U(material).diffuse).g = 1.0f; U3(U(material).diffuse).b = 0.0f; U4(U(material).diffuse).a = 1.0f; hr = IDirect3DMaterial2_SetMaterial(background, &material); ok(SUCCEEDED(hr), "Failed to set material data, hr %#x.\n", hr); hr = IDirect3DDevice2_GetRenderTarget(device, &surface); ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr); ok(surface == rt, "Got unexpected surface %p.\n", surface); hr = IDirect3DDevice2_GetRenderState(device, D3DRENDERSTATE_ZENABLE, &value); ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr); ok(!!value, "Got unexpected z-enable state %#x.\n", value); hr = IDirect3DDevice2_GetRenderState(device, D3DRENDERSTATE_ALPHABLENDENABLE, &value); ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr); ok(!!value, "Got unexpected alpha blend enable state %#x.\n", value); hr = IDirect3DViewport2_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET); ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr); color = get_surface_color(rt, 320, 240); ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x.\n", color); destroy_viewport(device, viewport); destroy_material(background); IDirectDrawSurface_Release(surface); IDirectDrawSurface_Release(rt); IDirect3DDevice2_Release(device); IDirectDraw2_Release(ddraw); DestroyWindow(window); } static void test_surface_interface_mismatch(void) { IDirectDraw2 *ddraw = NULL; IDirect3D2 *d3d = NULL; IDirectDrawSurface *surface = NULL, *ds; IDirectDrawSurface3 *surface3 = NULL; IDirect3DDevice2 *device = NULL; IDirect3DViewport2 *viewport = NULL; IDirect3DMaterial2 *background = NULL; DDSURFACEDESC surface_desc; DWORD z_depth = 0; ULONG refcount; HRESULT hr; D3DCOLOR color; HWND window; D3DRECT clear_rect = {{0}, {0}, {640}, {480}}; window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, 0, 0); if (!(ddraw = create_ddraw())) { skip("Failed to create a ddraw object, skipping test.\n"); goto cleanup; } hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL); 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 = IDirectDraw2_CreateSurface(ddraw, &surface_desc, &surface, NULL); ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr); hr = IDirectDrawSurface2_QueryInterface(surface, &IID_IDirectDrawSurface3, (void **)&surface3); if (FAILED(hr)) { skip("Failed to get the IDirectDrawSurface3 interface, skipping test.\n"); goto cleanup; } hr = IDirectDraw2_QueryInterface(ddraw, &IID_IDirect3D2, (void **)&d3d); if (FAILED(hr)) { skip("Failed to get the IDirect3D2 interface, skipping test.\n"); goto cleanup; } hr = IDirect3D2_EnumDevices(d3d, enum_z_fmt, &z_depth); if (FAILED(hr) || !z_depth) { skip("No depth buffer formats available, skipping test.\n"); goto cleanup; } memset(&surface_desc, 0, sizeof(surface_desc)); surface_desc.dwSize = sizeof(surface_desc); surface_desc.dwFlags = DDSD_CAPS | DDSD_ZBUFFERBITDEPTH | DDSD_WIDTH | DDSD_HEIGHT; surface_desc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER; U2(surface_desc).dwZBufferBitDepth = z_depth; surface_desc.dwWidth = 640; surface_desc.dwHeight = 480; hr = IDirectDraw2_CreateSurface(ddraw, &surface_desc, &ds, NULL); ok(SUCCEEDED(hr), "Failed to create depth buffer, hr %#x.\n", hr); if (FAILED(hr)) goto cleanup; /* Using a different surface interface version still works */ hr = IDirectDrawSurface3_AddAttachedSurface(surface3, (IDirectDrawSurface3 *)ds); ok(SUCCEEDED(hr), "Failed to attach depth buffer, hr %#x.\n", hr); refcount = IDirectDrawSurface_Release(ds); ok(refcount == 1, "Got unexpected refcount %u.\n", refcount); if (FAILED(hr)) goto cleanup; /* Here too */ hr = IDirect3D2_CreateDevice(d3d, &IID_IDirect3DHALDevice, (IDirectDrawSurface *)surface3, &device); ok(SUCCEEDED(hr), "Failed to create d3d device.\n"); if (FAILED(hr)) goto cleanup; background = create_diffuse_material(device, 1.0f, 0.0f, 0.0f, 1.0f); viewport = create_viewport(device, 0, 0, 640, 480); viewport_set_background(device, viewport, background); hr = IDirect3DViewport2_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET); ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr); color = get_surface_color(surface, 320, 240); ok(compare_color(color, 0x00ff0000, 1), "Got unexpected color 0x%08x.\n", color); cleanup: if (viewport) destroy_viewport(device, viewport); if (background) destroy_material(background); if (surface3) IDirectDrawSurface3_Release(surface3); if (surface) IDirectDrawSurface_Release(surface); if (device) IDirect3DDevice2_Release(device); if (d3d) IDirect3D2_Release(d3d); if (ddraw) IDirectDraw2_Release(ddraw); DestroyWindow(window); } static void test_coop_level_threaded(void) { struct create_window_thread_param p; IDirectDraw2 *ddraw; HRESULT hr; if (!(ddraw = create_ddraw())) { skip("Failed to create a ddraw object, skipping test.\n"); return; } create_window_thread(&p); hr = IDirectDraw2_SetCooperativeLevel(ddraw, p.window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr); IDirectDraw2_Release(ddraw); destroy_window_thread(&p); } static void test_depth_blit(void) { static D3DLVERTEX quad1[] = { {{-1.0}, { 1.0}, {0.50f}, 0, {0xff00ff00}}, {{ 1.0}, { 1.0}, {0.50f}, 0, {0xff00ff00}}, {{-1.0}, {-1.0}, {0.50f}, 0, {0xff00ff00}}, {{ 1.0}, {-1.0}, {0.50f}, 0, {0xff00ff00}}, }; static const D3DCOLOR expected_colors[4][4] = { {0x00ff0000, 0x00ff0000, 0x0000ff00, 0x0000ff00}, {0x00ff0000, 0x00ff0000, 0x0000ff00, 0x0000ff00}, {0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00}, {0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00}, }; static const BOOL todo[4][4] = { {FALSE, FALSE, TRUE, TRUE}, {FALSE, FALSE, TRUE, TRUE}, {TRUE, TRUE, TRUE, TRUE}, {TRUE, TRUE, TRUE, TRUE}, }; DDSURFACEDESC ddsd_new, ddsd_existing; IDirect3DDevice2 *device; IDirectDrawSurface *ds1, *ds2, *ds3, *rt; IDirect3DViewport2 *viewport; RECT src_rect, dst_rect; unsigned int i, j; D3DCOLOR color; HRESULT hr; IDirectDraw2 *ddraw; DDBLTFX fx; HWND window; D3DRECT d3drect; IDirect3DMaterial2 *background; window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, 0, 0); if (!(ddraw = create_ddraw())) { skip("Failed to create ddraw object, skipping test.\n"); DestroyWindow(window); return; } if (!(device = create_device(ddraw, window, DDSCL_NORMAL))) { skip("Failed to create D3D device, skipping test.\n"); IDirectDraw2_Release(ddraw); DestroyWindow(window); return; } ds1 = get_depth_stencil(device); memset(&ddsd_new, 0, sizeof(ddsd_new)); ddsd_new.dwSize = sizeof(ddsd_new); memset(&ddsd_existing, 0, sizeof(ddsd_existing)); ddsd_existing.dwSize = sizeof(ddsd_existing); hr = IDirectDrawSurface_GetSurfaceDesc(ds1, &ddsd_existing); ddsd_new.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; ddsd_new.ddsCaps.dwCaps = DDSCAPS_ZBUFFER; ddsd_new.dwWidth = ddsd_existing.dwWidth; ddsd_new.dwHeight = ddsd_existing.dwHeight; ddsd_new.ddpfPixelFormat = ddsd_existing.ddpfPixelFormat; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd_new, &ds2, NULL); ok(SUCCEEDED(hr), "Failed to create a surface, hr %#x.\n", hr); hr = IDirectDraw2_CreateSurface(ddraw, &ddsd_new, &ds3, NULL); ok(SUCCEEDED(hr), "Failed to create a surface, hr %#x.\n", hr); background = create_diffuse_material(device, 1.0f, 0.0f, 0.0f, 1.0f); viewport = create_viewport(device, 0, 0, ddsd_existing.dwWidth, ddsd_existing.dwHeight); viewport_set_background(device, viewport, background); hr = IDirect3DDevice2_SetCurrentViewport(device, viewport); ok(SUCCEEDED(hr), "Failed to activate the viewport, hr %#x.\n", hr); hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_ZENABLE, D3DZB_TRUE); ok(SUCCEEDED(hr), "Failed to enable z testing, hr %#x.\n", hr); hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_ZFUNC, D3DCMP_LESSEQUAL); ok(SUCCEEDED(hr), "Failed to set the z function, hr %#x.\n", hr); U1(d3drect).x1 = U2(d3drect).y1 = 0; U3(d3drect).x2 = ddsd_existing.dwWidth; U4(d3drect).y2 = ddsd_existing.dwHeight; hr = IDirect3DViewport2_Clear(viewport, 1, &d3drect, D3DCLEAR_ZBUFFER); ok(SUCCEEDED(hr), "Failed to clear the z buffer, hr %#x.\n", hr); /* Partial blit. */ SetRect(&src_rect, 0, 0, 320, 240); SetRect(&dst_rect, 0, 0, 320, 240); hr = IDirectDrawSurface_Blt(ds2, &dst_rect, ds1, &src_rect, DDBLT_WAIT, NULL); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); /* Different locations. */ SetRect(&src_rect, 0, 0, 320, 240); SetRect(&dst_rect, 320, 240, 640, 480); hr = IDirectDrawSurface_Blt(ds2, &dst_rect, ds1, &src_rect, DDBLT_WAIT, NULL); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); /* Streched. */ SetRect(&src_rect, 0, 0, 320, 240); SetRect(&dst_rect, 0, 0, 640, 480); hr = IDirectDrawSurface_Blt(ds2, &dst_rect, ds1, &src_rect, DDBLT_WAIT, NULL); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); /* Flipped. */ SetRect(&src_rect, 0, 480, 640, 0); SetRect(&dst_rect, 0, 0, 640, 480); hr = IDirectDrawSurface_Blt(ds2, &dst_rect, ds1, &src_rect, DDBLT_WAIT, NULL); ok(hr == DDERR_INVALIDRECT, "Got unexpected hr %#x.\n", hr); SetRect(&src_rect, 0, 0, 640, 480); SetRect(&dst_rect, 0, 480, 640, 0); hr = IDirectDrawSurface_Blt(ds2, &dst_rect, ds1, &src_rect, DDBLT_WAIT, NULL); ok(hr == DDERR_INVALIDRECT, "Got unexpected hr %#x.\n", hr); /* Full, explicit. */ SetRect(&src_rect, 0, 0, 640, 480); SetRect(&dst_rect, 0, 0, 640, 480); hr = IDirectDrawSurface_Blt(ds2, &dst_rect, ds1, &src_rect, DDBLT_WAIT, NULL); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); /* Depth -> color blit: Succeeds on Win7 + Radeon HD 5700, fails on WinXP + Radeon X1600 */ /* Depth blit inside a BeginScene / EndScene pair */ hr = IDirect3DDevice2_BeginScene(device); ok(SUCCEEDED(hr), "Failed to start a scene, hr %#x.\n", hr); /* From the current depth stencil */ hr = IDirectDrawSurface_Blt(ds2, NULL, ds1, NULL, DDBLT_WAIT, NULL); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); /* To the current depth stencil */ hr = IDirectDrawSurface_Blt(ds1, NULL, ds2, NULL, DDBLT_WAIT, NULL); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); /* Between unbound surfaces */ hr = IDirectDrawSurface_Blt(ds3, NULL, ds2, NULL, DDBLT_WAIT, NULL); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); hr = IDirect3DDevice2_EndScene(device); ok(SUCCEEDED(hr), "Failed to end a scene, hr %#x.\n", hr); /* Avoid changing the depth stencil, it doesn't work properly on Windows. * Instead use DDBLT_DEPTHFILL to clear the depth stencil. Unfortunately * drivers disagree on the meaning of dwFillDepth. Only 0 seems to produce * a reliable result(z = 0.0) */ memset(&fx, 0, sizeof(fx)); fx.dwSize = sizeof(fx); U5(fx).dwFillDepth = 0; hr = IDirectDrawSurface_Blt(ds2, NULL, NULL, NULL, DDBLT_DEPTHFILL | DDBLT_WAIT, &fx); ok(SUCCEEDED(hr), "Failed to clear the source z buffer, hr %#x.\n", hr); /* This clears the Z buffer with 1.0 */ hr = IDirect3DViewport2_Clear(viewport, 1, &d3drect, D3DCLEAR_ZBUFFER | D3DCLEAR_TARGET); ok(SUCCEEDED(hr), "Failed to clear the color and z buffers, hr %#x.\n", hr); SetRect(&dst_rect, 0, 0, 320, 240); hr = IDirectDrawSurface_Blt(ds1, &dst_rect, ds2, NULL, DDBLT_WAIT, NULL); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); IDirectDrawSurface_Release(ds3); IDirectDrawSurface_Release(ds2); IDirectDrawSurface_Release(ds1); hr = IDirect3DDevice2_BeginScene(device); ok(SUCCEEDED(hr), "Failed to start a scene, hr %#x.\n", hr); hr = IDirect3DDevice2_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DVT_LVERTEX, quad1, 4, 0); ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr); hr = IDirect3DDevice2_EndScene(device); ok(SUCCEEDED(hr), "Failed to end a scene, hr %#x.\n", hr); hr = IDirect3DDevice2_GetRenderTarget(device, &rt); ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr); for (i = 0; i < 4; ++i) { for (j = 0; j < 4; ++j) { unsigned int x = 80 * ((2 * j) + 1); unsigned int y = 60 * ((2 * i) + 1); color = get_surface_color(rt, x, y); if (todo[i][j]) todo_wine ok(compare_color(color, expected_colors[i][j], 1), "Expected color 0x%08x at %u,%u, got 0x%08x.\n", expected_colors[i][j], x, y, color); else ok(compare_color(color, expected_colors[i][j], 1), "Expected color 0x%08x at %u,%u, got 0x%08x.\n", expected_colors[i][j], x, y, color); } } IDirectDrawSurface_Release(rt); destroy_viewport(device, viewport); destroy_material(background); IDirect3DDevice2_Release(device); IDirectDraw2_Release(ddraw); DestroyWindow(window); } static void test_texture_load_ckey(void) { IDirectDraw2 *ddraw = NULL; IDirectDrawSurface *src = NULL; IDirectDrawSurface *dst = NULL; IDirect3DTexture *src_tex = NULL; IDirect3DTexture *dst_tex = NULL; DDSURFACEDESC ddsd; HRESULT hr; DDCOLORKEY ckey; if (!(ddraw = create_ddraw())) { skip("Failed to create ddraw object, skipping test.\n"); return; } hr = IDirectDraw2_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL); ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; ddsd.dwHeight = 128; ddsd.dwWidth = 128; ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd, &src, NULL); ok(SUCCEEDED(hr), "Failed to create source texture, hr %#x.\n", hr); ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd, &dst, NULL); ok(SUCCEEDED(hr), "Failed to create destination texture, hr %#x.\n", hr); hr = IDirectDrawSurface_QueryInterface(src, &IID_IDirect3DTexture, (void **)&src_tex); ok(SUCCEEDED(hr) || hr == E_NOINTERFACE, "Failed to get Direct3DTexture interface, hr %#x.\n", hr); if (FAILED(hr)) { /* 64 bit ddraw does not support d3d */ skip("Could not get Direct3DTexture interface, skipping texture::Load color keying tests.\n"); goto done; } hr = IDirectDrawSurface_QueryInterface(dst, &IID_IDirect3DTexture, (void **)&dst_tex); ok(SUCCEEDED(hr), "Failed to get Direct3DTexture interface, hr %#x.\n", hr); /* No surface has a color key */ hr = IDirect3DTexture_Load(dst_tex, src_tex); ok(SUCCEEDED(hr) || broken(hr == DDERR_INVALIDCAPS), "Got unexpected hr %#x.\n", hr); if (FAILED(hr)) { /* Testbot Windows NT VMs */ skip("IDirect3DTexture::Load does not work, skipping color keying tests.\n"); goto done; } ckey.dwColorSpaceLowValue = ckey.dwColorSpaceHighValue = 0xdeadbeef; hr = IDirectDrawSurface_GetColorKey(dst, DDCKEY_SRCBLT, &ckey); ok(hr == DDERR_NOCOLORKEY, "Got unexpected hr %#x.\n", hr); ok(ckey.dwColorSpaceLowValue == 0xdeadbeef, "dwColorSpaceLowValue is %#x.\n", ckey.dwColorSpaceLowValue); ok(ckey.dwColorSpaceHighValue == 0xdeadbeef, "dwColorSpaceHighValue is %#x.\n", ckey.dwColorSpaceHighValue); /* Source surface has a color key */ ckey.dwColorSpaceLowValue = ckey.dwColorSpaceHighValue = 0x0000ff00; hr = IDirectDrawSurface_SetColorKey(src, DDCKEY_SRCBLT, &ckey); ok(SUCCEEDED(hr), "Failed to set color key, hr %#x.\n", hr); hr = IDirect3DTexture_Load(dst_tex, src_tex); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); hr = IDirectDrawSurface_GetColorKey(dst, DDCKEY_SRCBLT, &ckey); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); ok(ckey.dwColorSpaceLowValue == 0x0000ff00, "dwColorSpaceLowValue is %#x.\n", ckey.dwColorSpaceLowValue); ok(ckey.dwColorSpaceHighValue == 0x0000ff00, "dwColorSpaceHighValue is %#x.\n", ckey.dwColorSpaceHighValue); /* Both surfaces have a color key: Dest ckey is overwritten */ ckey.dwColorSpaceLowValue = ckey.dwColorSpaceHighValue = 0x000000ff; hr = IDirectDrawSurface_SetColorKey(dst, DDCKEY_SRCBLT, &ckey); ok(SUCCEEDED(hr), "Failed to set color key, hr %#x.\n", hr); hr = IDirect3DTexture_Load(dst_tex, src_tex); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); hr = IDirectDrawSurface_GetColorKey(dst, DDCKEY_SRCBLT, &ckey); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); ok(ckey.dwColorSpaceLowValue == 0x0000ff00, "dwColorSpaceLowValue is %#x.\n", ckey.dwColorSpaceLowValue); ok(ckey.dwColorSpaceHighValue == 0x0000ff00, "dwColorSpaceHighValue is %#x.\n", ckey.dwColorSpaceHighValue); /* Only the destination has a color key: It is not deleted */ hr = IDirectDrawSurface_SetColorKey(src, DDCKEY_SRCBLT, NULL); ok(SUCCEEDED(hr), "Failed to set color key, hr %#x.\n", hr); hr = IDirectDrawSurface_GetColorKey(src, DDCKEY_SRCBLT, &ckey); ok(hr == DDERR_NOCOLORKEY, "Got unexpected hr %#x.\n", hr); hr = IDirect3DTexture_Load(dst_tex, src_tex); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); hr = IDirectDrawSurface_GetColorKey(dst, DDCKEY_SRCBLT, &ckey); ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr); ok(ckey.dwColorSpaceLowValue == 0x0000ff00, "dwColorSpaceLowValue is %#x.\n", ckey.dwColorSpaceLowValue); ok(ckey.dwColorSpaceHighValue == 0x0000ff00, "dwColorSpaceHighValue is %#x.\n", ckey.dwColorSpaceHighValue); done: if (dst_tex) IDirect3DTexture_Release(dst_tex); if (src_tex) IDirect3DTexture_Release(src_tex); if (dst) IDirectDrawSurface_Release(dst); if (src) IDirectDrawSurface_Release(src); if (ddraw) IDirectDraw2_Release(ddraw); } static ULONG get_refcount(IUnknown *test_iface) { IUnknown_AddRef(test_iface); return IUnknown_Release(test_iface); } static void test_viewport_interfaces(void) { IDirectDraw2 *ddraw; IDirect3D2 *d3d; HRESULT hr; ULONG ref, old_d3d_ref; IDirect3DViewport *viewport; IDirect3DViewport2 *viewport2; IDirect3DViewport3 *viewport3; IDirectDrawGammaControl *gamma; IUnknown *unknown; if (!(ddraw = create_ddraw())) { skip("Failed to create ddraw object, skipping test.\n"); return; } hr = IDirectDraw2_QueryInterface(ddraw, &IID_IDirect3D2, (void **)&d3d); ok(SUCCEEDED(hr) || hr == E_NOINTERFACE, "Failed to get d3d interface, hr %#x.\n", hr); if (FAILED(hr)) { skip("Direct3D not available, skipping tests\n"); IDirectDraw2_Release(ddraw); return; } old_d3d_ref = get_refcount((IUnknown *)d3d); hr = IDirect3D2_CreateViewport(d3d, &viewport2, NULL); ok(SUCCEEDED(hr), "Failed to create viewport, hr %#x.\n", hr); ref = get_refcount((IUnknown *)viewport2); ok(ref == 1, "Initial IDirect3DViewport2 refcount is %u\n", ref); ref = get_refcount((IUnknown *)d3d); ok(ref == old_d3d_ref, "IDirect3D2 refcount is %u\n", ref); gamma = (IDirectDrawGammaControl *)0xdeadbeef; hr = IDirect3DViewport2_QueryInterface(viewport2, &IID_IDirectDrawGammaControl, (void **)&gamma); ok(hr == E_NOINTERFACE, "Got unexpected hr %#x.\n", hr); ok(gamma == NULL, "Interface not set to NULL by failed QI call: %p\n", gamma); if (SUCCEEDED(hr)) IDirectDrawGammaControl_Release(gamma); /* NULL iid: Segfaults */ hr = IDirect3DViewport2_QueryInterface(viewport2, &IID_IDirect3DViewport, (void **)&viewport); ok(SUCCEEDED(hr), "Failed to QI IDirect3DViewport, hr %#x.\n", hr); if (viewport) { ref = get_refcount((IUnknown *)viewport); ok(ref == 2, "IDirect3DViewport refcount is %u\n", ref); ref = get_refcount((IUnknown *)viewport2); ok(ref == 2, "IDirect3DViewport2 refcount is %u\n", ref); IDirect3DViewport_Release(viewport); viewport = NULL; } hr = IDirect3DViewport2_QueryInterface(viewport2, &IID_IDirect3DViewport3, (void **)&viewport3); ok(SUCCEEDED(hr) || hr == E_NOINTERFACE, "Failed to QI IDirect3DViewport3, hr %#x.\n", hr); if (viewport3) { ref = get_refcount((IUnknown *)viewport2); ok(ref == 2, "IDirect3DViewport2 refcount is %u\n", ref); ref = get_refcount((IUnknown *)viewport3); ok(ref == 2, "IDirect3DViewport3 refcount is %u\n", ref); IDirect3DViewport3_Release(viewport3); } hr = IDirect3DViewport2_QueryInterface(viewport2, &IID_IUnknown, (void **)&unknown); ok(SUCCEEDED(hr), "Failed to QI IUnknown, hr %#x.\n", hr); if (unknown) { ref = get_refcount((IUnknown *)viewport2); ok(ref == 2, "IDirect3DViewport2 refcount is %u\n", ref); ref = get_refcount(unknown); ok(ref == 2, "IUnknown refcount is %u\n", ref); IUnknown_Release(unknown); } IDirect3DViewport2_Release(viewport2); IDirect3D2_Release(d3d); IDirectDraw2_Release(ddraw); } static void test_zenable(void) { static D3DRECT clear_rect = {{0}, {0}, {640}, {480}}; static D3DTLVERTEX tquad[] = { {{ 0.0f}, {480.0f}, {-0.5f}, {1.0f}, {0xff00ff00}, {0x00000000}, {0.0f}, {0.0f}}, {{ 0.0f}, { 0.0f}, {-0.5f}, {1.0f}, {0xff00ff00}, {0x00000000}, {0.0f}, {0.0f}}, {{640.0f}, {480.0f}, { 1.5f}, {1.0f}, {0xff00ff00}, {0x00000000}, {0.0f}, {0.0f}}, {{640.0f}, { 0.0f}, { 1.5f}, {1.0f}, {0xff00ff00}, {0x00000000}, {0.0f}, {0.0f}}, }; IDirect3DMaterial2 *background; IDirect3DViewport2 *viewport; IDirect3DDevice2 *device; IDirectDrawSurface *rt; IDirectDraw2 *ddraw; D3DCOLOR color; HWND window; HRESULT hr; UINT x, y; UINT i, j; window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, 0, 0); if (!(ddraw = create_ddraw())) { skip("Failed to create ddraw object, skipping test.\n"); DestroyWindow(window); return; } if (!(device = create_device(ddraw, window, DDSCL_NORMAL))) { skip("Failed to create D3D device, skipping test.\n"); IDirectDraw2_Release(ddraw); DestroyWindow(window); return; } background = create_diffuse_material(device, 1.0f, 0.0f, 0.0f, 1.0f); viewport = create_viewport(device, 0, 0, 640, 480); viewport_set_background(device, viewport, background); hr = IDirect3DDevice2_SetCurrentViewport(device, viewport); ok(SUCCEEDED(hr), "Failed to set current viewport, hr %#x.\n", hr); hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_ZENABLE, D3DZB_FALSE); ok(SUCCEEDED(hr), "Failed to disable z-buffering, hr %#x.\n", hr); hr = IDirect3DViewport2_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET); ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr); hr = IDirect3DDevice2_BeginScene(device); ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr); hr = IDirect3DDevice2_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DVT_TLVERTEX, tquad, 4, 0); ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr); hr = IDirect3DDevice2_EndScene(device); ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr); hr = IDirect3DDevice2_GetRenderTarget(device, &rt); ok(SUCCEEDED(hr), "Failed to get render target, 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(rt, x, y); ok(compare_color(color, 0x0000ff00, 1), "Expected color 0x0000ff00 at %u, %u, got 0x%08x.\n", x, y, color); } } IDirectDrawSurface_Release(rt); destroy_viewport(device, viewport); destroy_material(background); IDirect3DDevice2_Release(device); IDirectDraw2_Release(ddraw); DestroyWindow(window); } static void test_ck_rgba(void) { static D3DRECT clear_rect = {{0}, {0}, {640}, {480}}; static D3DTLVERTEX tquad[] = { {{ 0.0f}, {480.0f}, {0.25f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {0.0f}}, {{ 0.0f}, { 0.0f}, {0.25f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {1.0f}}, {{640.0f}, {480.0f}, {0.25f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {0.0f}}, {{640.0f}, { 0.0f}, {0.25f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {1.0f}}, {{ 0.0f}, {480.0f}, {0.75f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {0.0f}}, {{ 0.0f}, { 0.0f}, {0.75f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {1.0f}}, {{640.0f}, {480.0f}, {0.75f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {0.0f}}, {{640.0f}, { 0.0f}, {0.75f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {1.0f}}, }; static const struct { D3DCOLOR fill_color; BOOL color_key; BOOL blend; D3DCOLOR result1; D3DCOLOR result2; } tests[] = { {0xff00ff00, TRUE, TRUE, 0x00ff0000, 0x000000ff}, {0xff00ff00, TRUE, FALSE, 0x00ff0000, 0x000000ff}, {0xff00ff00, FALSE, TRUE, 0x0000ff00, 0x0000ff00}, {0xff00ff00, FALSE, FALSE, 0x0000ff00, 0x0000ff00}, {0x7f00ff00, TRUE, TRUE, 0x00807f00, 0x00807f00}, {0x7f00ff00, TRUE, FALSE, 0x0000ff00, 0x0000ff00}, {0x7f00ff00, FALSE, TRUE, 0x00807f00, 0x00807f00}, {0x7f00ff00, FALSE, FALSE, 0x0000ff00, 0x0000ff00}, }; D3DTEXTUREHANDLE texture_handle; IDirect3DMaterial2 *background; IDirectDrawSurface *surface; IDirect3DViewport2 *viewport; IDirect3DTexture2 *texture; DDSURFACEDESC surface_desc; IDirect3DDevice2 *device; IDirectDrawSurface *rt; IDirectDraw2 *ddraw; D3DCOLOR color; HWND window; DDBLTFX fx; HRESULT hr; UINT i; window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, 0, 0); if (!(ddraw = create_ddraw())) { skip("Failed to create ddraw object, skipping test.\n"); DestroyWindow(window); return; } if (!(device = create_device(ddraw, window, DDSCL_NORMAL))) { skip("Failed to create D3D device, skipping test.\n"); IDirectDraw2_Release(ddraw); DestroyWindow(window); return; } background = create_diffuse_material(device, 1.0f, 0.0f, 0.0f, 1.0f); viewport = create_viewport(device, 0, 0, 640, 480); viewport_set_background(device, viewport, background); hr = IDirect3DDevice2_SetCurrentViewport(device, viewport); ok(SUCCEEDED(hr), "Failed to set current viewport, 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 | DDSD_PIXELFORMAT | DDSD_CKSRCBLT; surface_desc.ddsCaps.dwCaps = DDSCAPS_TEXTURE; surface_desc.dwWidth = 256; surface_desc.dwHeight = 256; surface_desc.ddpfPixelFormat.dwSize = sizeof(surface_desc.ddpfPixelFormat); surface_desc.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS; U1(surface_desc.ddpfPixelFormat).dwRGBBitCount = 32; U2(surface_desc.ddpfPixelFormat).dwRBitMask = 0x00ff0000; U3(surface_desc.ddpfPixelFormat).dwGBitMask = 0x0000ff00; U4(surface_desc.ddpfPixelFormat).dwBBitMask = 0x000000ff; U5(surface_desc.ddpfPixelFormat).dwRGBAlphaBitMask = 0xff000000; surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue = 0xff00ff00; surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue = 0xff00ff00; hr = IDirectDraw2_CreateSurface(ddraw, &surface_desc, &surface, NULL); ok(SUCCEEDED(hr), "Failed to create destination surface, hr %#x.\n", hr); hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirect3DTexture2, (void **)&texture); ok(SUCCEEDED(hr), "Failed to get texture interface, hr %#x.\n", hr); hr = IDirect3DTexture2_GetHandle(texture, device, &texture_handle); ok(SUCCEEDED(hr), "Failed to get texture handle, hr %#x.\n", hr); IDirect3DTexture2_Release(texture); hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_TEXTUREHANDLE, texture_handle); ok(SUCCEEDED(hr), "Failed to set texture, hr %#x.\n", hr); hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_SRCBLEND, D3DBLEND_SRCALPHA); ok(SUCCEEDED(hr), "Failed to enable alpha blending, hr %#x.\n", hr); hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA); ok(SUCCEEDED(hr), "Failed to enable alpha blending, hr %#x.\n", hr); hr = IDirect3DDevice2_GetRenderTarget(device, &rt); ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr); for (i = 0; i < sizeof(tests) / sizeof(*tests); ++i) { hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, tests[i].color_key); ok(SUCCEEDED(hr), "Failed to enable color keying, hr %#x.\n", hr); hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_ALPHABLENDENABLE, tests[i].blend); ok(SUCCEEDED(hr), "Failed to enable alpha blending, hr %#x.\n", hr); memset(&fx, 0, sizeof(fx)); fx.dwSize = sizeof(fx); U5(fx).dwFillColor = tests[i].fill_color; hr = IDirectDrawSurface_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx); ok(SUCCEEDED(hr), "Failed to fill texture, hr %#x.\n", hr); hr = IDirect3DViewport2_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER); ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr); hr = IDirect3DDevice2_BeginScene(device); ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr); hr = IDirect3DDevice2_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DVT_TLVERTEX, &tquad[0], 4, 0); ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr); hr = IDirect3DDevice2_EndScene(device); ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr); color = get_surface_color(rt, 320, 240); if (i == 2) todo_wine ok(compare_color(color, tests[i].result1, 1), "Expected color 0x%08x for test %u, got 0x%08x.\n", tests[i].result1, i, color); else ok(compare_color(color, tests[i].result1, 1), "Expected color 0x%08x for test %u, got 0x%08x.\n", tests[i].result1, i, color); U5(fx).dwFillColor = 0xff0000ff; hr = IDirectDrawSurface_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx); ok(SUCCEEDED(hr), "Failed to fill texture, hr %#x.\n", hr); hr = IDirect3DDevice2_BeginScene(device); ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr); hr = IDirect3DDevice2_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DVT_TLVERTEX, &tquad[4], 4, 0); ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr); hr = IDirect3DDevice2_EndScene(device); ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr); /* This tests that fragments that are masked out by the color key are * discarded, instead of just fully transparent. */ color = get_surface_color(rt, 320, 240); if (i == 2) todo_wine ok(compare_color(color, tests[i].result2, 1), "Expected color 0x%08x for test %u, got 0x%08x.\n", tests[i].result2, i, color); else ok(compare_color(color, tests[i].result2, 1), "Expected color 0x%08x for test %u, got 0x%08x.\n", tests[i].result2, i, color); } IDirectDrawSurface_Release(rt); hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_TEXTUREHANDLE, 0); ok(SUCCEEDED(hr), "Failed to unset texture, hr %#x.\n", hr); IDirectDrawSurface_Release(surface); destroy_viewport(device, viewport); destroy_material(background); IDirect3DDevice2_Release(device); IDirectDraw2_Release(ddraw); DestroyWindow(window); } static void test_ck_default(void) { static D3DRECT clear_rect = {{0}, {0}, {640}, {480}}; static D3DTLVERTEX tquad[] = { {{ 0.0f}, {480.0f}, {0.0f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {0.0f}}, {{ 0.0f}, { 0.0f}, {0.0f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {1.0f}}, {{640.0f}, {480.0f}, {0.0f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {0.0f}}, {{640.0f}, { 0.0f}, {0.0f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {1.0f}}, }; IDirectDrawSurface *surface, *rt; D3DTEXTUREHANDLE texture_handle; IDirect3DMaterial2 *background; IDirect3DViewport2 *viewport; DDSURFACEDESC surface_desc; IDirect3DTexture2 *texture; IDirect3DDevice2 *device; IDirectDraw2 *ddraw; D3DCOLOR color; DWORD value; HWND window; DDBLTFX fx; HRESULT hr; window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, 0, 0); if (!(ddraw = create_ddraw())) { skip("Failed to create ddraw object, skipping test.\n"); DestroyWindow(window); return; } if (!(device = create_device(ddraw, window, DDSCL_NORMAL))) { skip("Failed to create D3D device, skipping test.\n"); IDirectDraw2_Release(ddraw); DestroyWindow(window); return; } hr = IDirect3DDevice2_GetRenderTarget(device, &rt); ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr); background = create_diffuse_material(device, 0.0, 1.0f, 0.0f, 1.0f); viewport = create_viewport(device, 0, 0, 640, 480); viewport_set_background(device, viewport, background); hr = IDirect3DDevice2_SetCurrentViewport(device, viewport); ok(SUCCEEDED(hr), "Failed to set current viewport, 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 | DDSD_PIXELFORMAT | DDSD_CKSRCBLT; surface_desc.ddsCaps.dwCaps = DDSCAPS_TEXTURE; surface_desc.dwWidth = 256; surface_desc.dwHeight = 256; surface_desc.ddpfPixelFormat.dwSize = sizeof(surface_desc.ddpfPixelFormat); surface_desc.ddpfPixelFormat.dwFlags = DDPF_RGB; U1(surface_desc.ddpfPixelFormat).dwRGBBitCount = 32; U2(surface_desc.ddpfPixelFormat).dwRBitMask = 0x00ff0000; U3(surface_desc.ddpfPixelFormat).dwGBitMask = 0x0000ff00; U4(surface_desc.ddpfPixelFormat).dwBBitMask = 0x000000ff; surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue = 0x000000ff; surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue = 0x000000ff; hr = IDirectDraw2_CreateSurface(ddraw, &surface_desc, &surface, NULL); ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr); hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirect3DTexture2, (void **)&texture); ok(SUCCEEDED(hr), "Failed to get texture interface, hr %#x.\n", hr); hr = IDirect3DTexture2_GetHandle(texture, device, &texture_handle); ok(SUCCEEDED(hr), "Failed to get texture handle, hr %#x.\n", hr); IDirect3DTexture_Release(texture); memset(&fx, 0, sizeof(fx)); fx.dwSize = sizeof(fx); U5(fx).dwFillColor = 0x000000ff; hr = IDirectDrawSurface_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx); ok(SUCCEEDED(hr), "Failed to fill surface, hr %#x.\n", hr); hr = IDirect3DViewport2_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET); ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr); hr = IDirect3DDevice2_BeginScene(device); ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr); hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_TEXTUREHANDLE, texture_handle); ok(SUCCEEDED(hr), "Failed to set texture handle, hr %#x.\n", hr); hr = IDirect3DDevice2_GetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, &value); ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr); ok(!value, "Got unexpected color keying state %#x.\n", value); hr = IDirect3DDevice2_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DVT_TLVERTEX, &tquad[0], 4, 0); ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr); hr = IDirect3DDevice2_EndScene(device); ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr); color = get_surface_color(rt, 320, 240); ok(compare_color(color, 0x000000ff, 1), "Got unexpected color 0x%08x.\n", color); hr = IDirect3DViewport2_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET); ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr); hr = IDirect3DDevice2_BeginScene(device); ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr); hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, TRUE); ok(SUCCEEDED(hr), "Failed to enable color keying, hr %#x.\n", hr); hr = IDirect3DDevice2_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DVT_TLVERTEX, &tquad[0], 4, 0); ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr); hr = IDirect3DDevice2_GetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, &value); ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr); ok(!!value, "Got unexpected color keying state %#x.\n", value); hr = IDirect3DDevice2_SetRenderState(device, D3DRENDERSTATE_TEXTUREHANDLE, 0); ok(SUCCEEDED(hr), "Failed to set texture handle, hr %#x.\n", hr); hr = IDirect3DDevice2_EndScene(device); ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr); color = get_surface_color(rt, 320, 240); ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x.\n", color); IDirectDrawSurface_Release(surface); destroy_viewport(device, viewport); destroy_material(background); IDirectDrawSurface_Release(rt); IDirect3DDevice2_Release(device); IDirectDraw2_Release(ddraw); DestroyWindow(window); } struct qi_test { REFIID iid; REFIID refcount_iid; HRESULT hr; }; static void test_qi(const char *test_name, IUnknown *base_iface, REFIID refcount_iid, const struct qi_test *tests, UINT entry_count) { ULONG refcount, expected_refcount; IUnknown *iface1, *iface2; HRESULT hr; UINT i, j; for (i = 0; i < entry_count; ++i) { hr = IUnknown_QueryInterface(base_iface, tests[i].iid, (void **)&iface1); ok(hr == tests[i].hr, "Got hr %#x for test \"%s\" %u.\n", hr, test_name, i); if (SUCCEEDED(hr)) { for (j = 0; j < entry_count; ++j) { hr = IUnknown_QueryInterface(iface1, tests[j].iid, (void **)&iface2); ok(hr == tests[j].hr, "Got hr %#x for test \"%s\" %u, %u.\n", hr, test_name, i, j); if (SUCCEEDED(hr)) { expected_refcount = 0; if (IsEqualGUID(refcount_iid, tests[j].refcount_iid)) ++expected_refcount; if (IsEqualGUID(tests[i].refcount_iid, tests[j].refcount_iid)) ++expected_refcount; refcount = IUnknown_Release(iface2); ok(refcount == expected_refcount, "Got refcount %u for test \"%s\" %u, %u, expected %u.\n", refcount, test_name, i, j, expected_refcount); } } expected_refcount = 0; if (IsEqualGUID(refcount_iid, tests[i].refcount_iid)) ++expected_refcount; refcount = IUnknown_Release(iface1); ok(refcount == expected_refcount, "Got refcount %u for test \"%s\" %u, expected %u.\n", refcount, test_name, i, expected_refcount); } } } static void test_surface_qi(void) { static const struct qi_test tests[] = { {&IID_IDirect3DTexture2, &IID_IDirectDrawSurface, S_OK }, {&IID_IDirect3DTexture, &IID_IDirectDrawSurface, S_OK }, {&IID_IDirectDrawGammaControl, &IID_IDirectDrawGammaControl, S_OK }, {&IID_IDirectDrawColorControl, NULL, E_NOINTERFACE}, {&IID_IDirectDrawSurface7, &IID_IDirectDrawSurface7, S_OK }, {&IID_IDirectDrawSurface4, &IID_IDirectDrawSurface4, S_OK }, {&IID_IDirectDrawSurface3, &IID_IDirectDrawSurface3, S_OK }, {&IID_IDirectDrawSurface2, &IID_IDirectDrawSurface2, S_OK }, {&IID_IDirectDrawSurface, &IID_IDirectDrawSurface, S_OK }, {&IID_IDirect3DDevice7, NULL, E_INVALIDARG }, {&IID_IDirect3DDevice3, NULL, E_INVALIDARG }, {&IID_IDirect3DDevice2, NULL, E_INVALIDARG }, {&IID_IDirect3DDevice, NULL, E_INVALIDARG }, {&IID_IDirect3D7, NULL, E_INVALIDARG }, {&IID_IDirect3D3, NULL, E_INVALIDARG }, {&IID_IDirect3D2, NULL, E_INVALIDARG }, {&IID_IDirect3D, NULL, E_INVALIDARG }, {&IID_IDirectDraw7, NULL, E_INVALIDARG }, {&IID_IDirectDraw4, NULL, E_INVALIDARG }, {&IID_IDirectDraw3, NULL, E_INVALIDARG }, {&IID_IDirectDraw2, NULL, E_INVALIDARG }, {&IID_IDirectDraw, NULL, E_INVALIDARG }, {&IID_IDirect3DLight, NULL, E_INVALIDARG }, {&IID_IDirect3DMaterial, NULL, E_INVALIDARG }, {&IID_IDirect3DMaterial2, NULL, E_INVALIDARG }, {&IID_IDirect3DMaterial3, NULL, E_INVALIDARG }, {&IID_IDirect3DExecuteBuffer, NULL, E_INVALIDARG }, {&IID_IDirect3DViewport, NULL, E_INVALIDARG }, {&IID_IDirect3DViewport2, NULL, E_INVALIDARG }, {&IID_IDirect3DViewport3, NULL, E_INVALIDARG }, {&IID_IDirect3DVertexBuffer, NULL, E_INVALIDARG }, {&IID_IDirect3DVertexBuffer7, NULL, E_INVALIDARG }, {&IID_IDirectDrawPalette, NULL, E_INVALIDARG }, {&IID_IDirectDrawClipper, NULL, E_INVALIDARG }, {&IID_IUnknown, &IID_IDirectDrawSurface, S_OK }, }; IDirectDrawSurface *surface; DDSURFACEDESC surface_desc; IDirect3DDevice2 *device; IDirectDraw2 *ddraw; HWND window; HRESULT hr; if (!GetProcAddress(GetModuleHandleA("ddraw.dll"), "DirectDrawCreateEx")) { win_skip("DirectDrawCreateEx not available, skipping test.\n"); return; } window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, 0, 0); if (!(ddraw = create_ddraw())) { skip("Failed to create a ddraw object, skipping test.\n"); DestroyWindow(window); return; } /* Try to create a D3D device to see if the ddraw implementation supports * D3D. 64-bit ddraw in particular doesn't seem to support D3D, and * doesn't support e.g. the IDirect3DTexture interfaces. */ if (!(device = create_device(ddraw, window, DDSCL_NORMAL))) { skip("Failed to create D3D device, skipping test.\n"); IDirectDraw2_Release(ddraw); DestroyWindow(window); return; } IDirect3DDevice_Release(device); 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_TEXTURE; surface_desc.dwWidth = 512; surface_desc.dwHeight = 512; hr = IDirectDraw2_CreateSurface(ddraw, &surface_desc, &surface, NULL); ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr); test_qi("surface_qi", (IUnknown *)surface, &IID_IDirectDrawSurface, tests, sizeof(tests) / sizeof(*tests)); IDirectDrawSurface_Release(surface); IDirectDraw2_Release(ddraw); DestroyWindow(window); } static void test_device_qi(void) { static const struct qi_test tests[] = { {&IID_IDirect3DTexture2, NULL, E_NOINTERFACE}, {&IID_IDirect3DTexture, NULL, E_NOINTERFACE}, {&IID_IDirectDrawGammaControl, NULL, E_NOINTERFACE}, {&IID_IDirectDrawColorControl, NULL, E_NOINTERFACE}, {&IID_IDirectDrawSurface7, NULL, E_NOINTERFACE}, {&IID_IDirectDrawSurface4, NULL, E_NOINTERFACE}, {&IID_IDirectDrawSurface3, NULL, E_NOINTERFACE}, {&IID_IDirectDrawSurface2, NULL, E_NOINTERFACE}, {&IID_IDirectDrawSurface, NULL, E_NOINTERFACE}, {&IID_IDirect3DDevice7, NULL, E_NOINTERFACE}, {&IID_IDirect3DDevice3, NULL, E_NOINTERFACE}, {&IID_IDirect3DDevice2, &IID_IDirect3DDevice2, S_OK }, {&IID_IDirect3DDevice, &IID_IDirect3DDevice2, S_OK }, {&IID_IDirect3DRampDevice, NULL, E_NOINTERFACE}, {&IID_IDirect3DRGBDevice, NULL, E_NOINTERFACE}, {&IID_IDirect3DHALDevice, NULL, E_NOINTERFACE}, {&IID_IDirect3DMMXDevice, NULL, E_NOINTERFACE}, {&IID_IDirect3DRefDevice, NULL, E_NOINTERFACE}, {&IID_IDirect3DTnLHalDevice, NULL, E_NOINTERFACE}, {&IID_IDirect3DNullDevice, NULL, E_NOINTERFACE}, {&IID_IDirect3D7, NULL, E_NOINTERFACE}, {&IID_IDirect3D3, NULL, E_NOINTERFACE}, {&IID_IDirect3D2, NULL, E_NOINTERFACE}, {&IID_IDirect3D, NULL, E_NOINTERFACE}, {&IID_IDirectDraw7, NULL, E_NOINTERFACE}, {&IID_IDirectDraw4, NULL, E_NOINTERFACE}, {&IID_IDirectDraw3, NULL, E_NOINTERFACE}, {&IID_IDirectDraw2, NULL, E_NOINTERFACE}, {&IID_IDirectDraw, NULL, E_NOINTERFACE}, {&IID_IDirect3DLight, NULL, E_NOINTERFACE}, {&IID_IDirect3DMaterial, NULL, E_NOINTERFACE}, {&IID_IDirect3DMaterial2, NULL, E_NOINTERFACE}, {&IID_IDirect3DMaterial3, NULL, E_NOINTERFACE}, {&IID_IDirect3DExecuteBuffer, NULL, E_NOINTERFACE}, {&IID_IDirect3DViewport, NULL, E_NOINTERFACE}, {&IID_IDirect3DViewport2, NULL, E_NOINTERFACE}, {&IID_IDirect3DViewport3, NULL, E_NOINTERFACE}, {&IID_IDirect3DVertexBuffer, NULL, E_NOINTERFACE}, {&IID_IDirect3DVertexBuffer7, NULL, E_NOINTERFACE}, {&IID_IDirectDrawPalette, NULL, E_NOINTERFACE}, {&IID_IDirectDrawClipper, NULL, E_NOINTERFACE}, {&IID_IUnknown, &IID_IDirect3DDevice2, S_OK }, }; IDirect3DDevice2 *device; IDirectDraw2 *ddraw; HWND window; window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, 0, 0); if (!(ddraw = create_ddraw())) { skip("Failed to create ddraw object, skipping test.\n"); DestroyWindow(window); return; } if (!(device = create_device(ddraw, window, DDSCL_NORMAL))) { skip("Failed to create D3D device, skipping test.\n"); IDirectDraw2_Release(ddraw); DestroyWindow(window); return; } test_qi("device_qi", (IUnknown *)device, &IID_IDirect3DDevice2, tests, sizeof(tests) / sizeof(*tests)); IDirect3DDevice2_Release(device); IDirectDraw2_Release(ddraw); DestroyWindow(window); } static void test_wndproc(void) { LONG_PTR proc, ddraw_proc; IDirectDraw2 *ddraw; WNDCLASSA wc = {0}; HWND window; HRESULT hr; ULONG ref; static const UINT messages[] = { WM_WINDOWPOSCHANGING, WM_MOVE, WM_SIZE, WM_WINDOWPOSCHANGING, WM_ACTIVATE, WM_SETFOCUS, 0, }; /* DDSCL_EXCLUSIVE replaces the window's window proc. */ if (!(ddraw = create_ddraw())) { skip("Failed to create IDirectDraw2 object, skipping tests.\n"); return; } wc.lpfnWndProc = test_proc; wc.lpszClassName = "ddraw_test_wndproc_wc"; ok(RegisterClassA(&wc), "Failed to register window class.\n"); window = CreateWindowA("ddraw_test_wndproc_wc", "ddraw_test", WS_MAXIMIZE | WS_CAPTION , 0, 0, 640, 480, 0, 0, 0, 0); proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); expect_messages = messages; hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages); expect_messages = NULL; proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc != (LONG_PTR)test_proc, "Expected wndproc != %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); ref = IDirectDraw2_Release(ddraw); ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref); proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); /* DDSCL_NORMAL doesn't. */ ddraw = create_ddraw(); proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); ref = IDirectDraw2_Release(ddraw); ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref); proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); /* The original window proc is only restored by ddraw if the current * window proc matches the one ddraw set. This also affects switching * from DDSCL_NORMAL to DDSCL_EXCLUSIVE. */ ddraw = create_ddraw(); proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc != (LONG_PTR)test_proc, "Expected wndproc != %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); ddraw_proc = proc; hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); proc = SetWindowLongPtrA(window, GWLP_WNDPROC, (LONG_PTR)DefWindowProcA); ok(proc != (LONG_PTR)test_proc, "Expected wndproc != %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc == (LONG_PTR)DefWindowProcA, "Expected wndproc %#lx, got %#lx.\n", (LONG_PTR)DefWindowProcA, proc); hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); proc = SetWindowLongPtrA(window, GWLP_WNDPROC, (LONG_PTR)ddraw_proc); ok(proc == (LONG_PTR)DefWindowProcA, "Expected wndproc %#lx, got %#lx.\n", (LONG_PTR)DefWindowProcA, proc); ref = IDirectDraw2_Release(ddraw); ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref); proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); ddraw = create_ddraw(); proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); proc = SetWindowLongPtrA(window, GWLP_WNDPROC, (LONG_PTR)DefWindowProcA); ok(proc != (LONG_PTR)test_proc, "Expected wndproc != %#lx, got %#lx.\n", (LONG_PTR)test_proc, proc); ref = IDirectDraw2_Release(ddraw); ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref); proc = GetWindowLongPtrA(window, GWLP_WNDPROC); ok(proc == (LONG_PTR)DefWindowProcA, "Expected wndproc %#lx, got %#lx.\n", (LONG_PTR)DefWindowProcA, proc); fix_wndproc(window, (LONG_PTR)test_proc); expect_messages = NULL; DestroyWindow(window); UnregisterClassA("ddraw_test_wndproc_wc", GetModuleHandleA(NULL)); } static void test_window_style(void) { LONG style, exstyle, tmp; RECT fullscreen_rect, r; IDirectDraw2 *ddraw; HWND window; HRESULT hr; ULONG ref; window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, 0, 0); if (!(ddraw = create_ddraw())) { skip("Failed to create a ddraw object, skipping test.\n"); DestroyWindow(window); return; } style = GetWindowLongA(window, GWL_STYLE); exstyle = GetWindowLongA(window, GWL_EXSTYLE); SetRect(&fullscreen_rect, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN)); hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); tmp = GetWindowLongA(window, GWL_STYLE); todo_wine ok(tmp == style, "Expected window style %#x, got %#x.\n", style, tmp); tmp = GetWindowLongA(window, GWL_EXSTYLE); todo_wine ok(tmp == exstyle, "Expected window extended style %#x, got %#x.\n", exstyle, tmp); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); GetClientRect(window, &r); todo_wine ok(!EqualRect(&r, &fullscreen_rect), "Client rect and window rect are equal.\n"); ref = IDirectDraw2_Release(ddraw); ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref); DestroyWindow(window); } static void test_redundant_mode_set(void) { DDSURFACEDESC surface_desc = {0}; IDirectDraw2 *ddraw; HWND window; HRESULT hr; RECT r, s; ULONG ref; window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, 0, 0); if (!(ddraw = create_ddraw())) { skip("Failed to create a ddraw object, skipping test.\n"); DestroyWindow(window); return; } hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); surface_desc.dwSize = sizeof(surface_desc); hr = IDirectDraw2_GetDisplayMode(ddraw, &surface_desc); ok(SUCCEEDED(hr), "GetDipslayMode failed, hr %#x.\n", hr); hr = IDirectDraw2_SetDisplayMode(ddraw, surface_desc.dwWidth, surface_desc.dwHeight, U1(surface_desc.ddpfPixelFormat).dwRGBBitCount, 0, 0); ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr); GetWindowRect(window, &r); r.right /= 2; r.bottom /= 2; SetWindowPos(window, HWND_TOP, r.left, r.top, r.right, r.bottom, 0); GetWindowRect(window, &s); ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", r.left, r.top, r.right, r.bottom, s.left, s.top, s.right, s.bottom); hr = IDirectDraw2_SetDisplayMode(ddraw, surface_desc.dwWidth, surface_desc.dwHeight, U1(surface_desc.ddpfPixelFormat).dwRGBBitCount, 0, 0); ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr); GetWindowRect(window, &s); ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", r.left, r.top, r.right, r.bottom, s.left, s.top, s.right, s.bottom); ref = IDirectDraw2_Release(ddraw); ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref); DestroyWindow(window); } static SIZE screen_size; static LRESULT CALLBACK mode_set_proc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) { if (message == WM_SIZE) { screen_size.cx = GetSystemMetrics(SM_CXSCREEN); screen_size.cy = GetSystemMetrics(SM_CYSCREEN); } return test_proc(hwnd, message, wparam, lparam); } static void test_coop_level_mode_set(void) { IDirectDrawSurface *primary; RECT fullscreen_rect, r, s; IDirectDraw2 *ddraw; DDSURFACEDESC ddsd; WNDCLASSA wc = {0}; HWND window; HRESULT hr; ULONG ref; static const UINT exclusive_messages[] = { WM_WINDOWPOSCHANGING, WM_WINDOWPOSCHANGED, WM_SIZE, WM_DISPLAYCHANGE, 0, }; static const UINT normal_messages[] = { WM_DISPLAYCHANGE, 0, }; if (!(ddraw = create_ddraw())) { skip("Failed to create a ddraw object, skipping test.\n"); return; } wc.lpfnWndProc = mode_set_proc; wc.lpszClassName = "ddraw_test_wndproc_wc"; ok(RegisterClassA(&wc), "Failed to register window class.\n"); window = CreateWindowA("ddraw_test_wndproc_wc", "ddraw_test", WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, 0, 0, 0, 0); SetRect(&fullscreen_rect, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN)); SetRect(&s, 0, 0, 640, 480); hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd, &primary, NULL); ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n", fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth); ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n", fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); expect_messages = exclusive_messages; screen_size.cx = 0; screen_size.cy = 0; hr = IDirectDraw2_SetDisplayMode(ddraw, 640, 480, 32, 0, 0); ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr); ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages); expect_messages = NULL; ok(screen_size.cx == s.right && screen_size.cy == s.bottom, "Expected screen size %ux%u, got %ux%u.\n", s.right, s.bottom, screen_size.cx, screen_size.cy); GetWindowRect(window, &r); ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", s.left, s.top, s.right, s.bottom, r.left, r.top, r.right, r.bottom); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n", fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth); ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n", fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight); IDirectDrawSurface_Release(primary); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd, &primary, NULL); ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n", s.right - s.left, ddsd.dwWidth); ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n", s.bottom - s.top, ddsd.dwHeight); GetWindowRect(window, &r); ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", s.left, s.top, s.right, s.bottom, r.left, r.top, r.right, r.bottom); expect_messages = exclusive_messages; screen_size.cx = 0; screen_size.cy = 0; hr = IDirectDraw_RestoreDisplayMode(ddraw); ok(SUCCEEDED(hr), "RestoreDisplayMode failed, hr %#x.\n", hr); ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages); expect_messages = NULL; ok(screen_size.cx == fullscreen_rect.right && screen_size.cy == fullscreen_rect.bottom, "Expected screen size %ux%u, got %ux%u.\n", fullscreen_rect.right, fullscreen_rect.bottom, screen_size.cx, screen_size.cy); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n", s.right - s.left, ddsd.dwWidth); ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n", s.bottom - s.top, ddsd.dwHeight); IDirectDrawSurface_Release(primary); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd, &primary, NULL); ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n", fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth); ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n", fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n", fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth); ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n", fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight); IDirectDrawSurface_Release(primary); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd, &primary, NULL); ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n", fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth); ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n", fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); expect_messages = normal_messages; screen_size.cx = 0; screen_size.cy = 0; hr = IDirectDraw2_SetDisplayMode(ddraw, 640, 480, 32, 0, 0); ok(SUCCEEDED(hr) || broken(hr == DDERR_NOEXCLUSIVEMODE) /* NT4 testbot */, "SetDipslayMode failed, hr %#x.\n", hr); if (hr == DDERR_NOEXCLUSIVEMODE) { win_skip("Broken SetDisplayMode(), skipping remaining tests.\n"); IDirectDrawSurface_Release(primary); IDirectDraw2_Release(ddraw); goto done; } ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages); expect_messages = NULL; ok(!screen_size.cx && !screen_size.cy, "Got unxpected screen size %ux%u.\n", screen_size.cx, screen_size.cy); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n", fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth); ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n", fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight); IDirectDrawSurface_Release(primary); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd, &primary, NULL); ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n", s.right - s.left, ddsd.dwWidth); ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n", s.bottom - s.top, ddsd.dwHeight); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); expect_messages = normal_messages; screen_size.cx = 0; screen_size.cy = 0; hr = IDirectDraw_RestoreDisplayMode(ddraw); ok(SUCCEEDED(hr), "RestoreDisplayMode failed, hr %#x.\n", hr); ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages); expect_messages = NULL; ok(!screen_size.cx && !screen_size.cy, "Got unxpected screen size %ux%u.\n", screen_size.cx, screen_size.cy); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n", s.right - s.left, ddsd.dwWidth); ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n", s.bottom - s.top, ddsd.dwHeight); IDirectDrawSurface_Release(primary); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd, &primary, NULL); ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n", fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth); ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n", fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); /* DDSCL_NORMAL | DDSCL_FULLSCREEN behaves the same as just DDSCL_NORMAL. * Resizing the window on mode changes is a property of DDSCL_EXCLUSIVE, * not DDSCL_FULLSCREEN. */ hr = IDirectDraw2_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL | DDSCL_FULLSCREEN); ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n", fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth); ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n", fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight); IDirectDrawSurface_Release(primary); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd, &primary, NULL); ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n", fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth); ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n", fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); expect_messages = normal_messages; screen_size.cx = 0; screen_size.cy = 0; hr = IDirectDraw2_SetDisplayMode(ddraw, 640, 480, 32, 0, 0); ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr); ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages); expect_messages = NULL; ok(!screen_size.cx && !screen_size.cy, "Got unxpected screen size %ux%u.\n", screen_size.cx, screen_size.cy); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n", fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth); ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n", fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight); IDirectDrawSurface_Release(primary); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd, &primary, NULL); ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n", s.right - s.left, ddsd.dwWidth); ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n", s.bottom - s.top, ddsd.dwHeight); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); expect_messages = normal_messages; screen_size.cx = 0; screen_size.cy = 0; hr = IDirectDraw_RestoreDisplayMode(ddraw); ok(SUCCEEDED(hr), "RestoreDisplayMode failed, hr %#x.\n", hr); ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages); expect_messages = NULL; ok(!screen_size.cx && !screen_size.cy, "Got unxpected screen size %ux%u.\n", screen_size.cx, screen_size.cy); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n", s.right - s.left, ddsd.dwWidth); ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n", s.bottom - s.top, ddsd.dwHeight); IDirectDrawSurface_Release(primary); memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd, &primary, NULL); ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr); hr = IDirectDrawSurface_GetSurfaceDesc(primary, &ddsd); ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr); ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n", fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth); ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n", fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight); IDirectDrawSurface_Release(primary); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); ref = IDirectDraw2_Release(ddraw); ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref); GetWindowRect(window, &r); ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n", fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom, r.left, r.top, r.right, r.bottom); done: expect_messages = NULL; DestroyWindow(window); UnregisterClassA("ddraw_test_wndproc_wc", GetModuleHandleA(NULL)); } static void test_initialize(void) { IDirectDraw2 *ddraw; HRESULT hr; if (!(ddraw = create_ddraw())) { skip("Failed to create a ddraw object, skipping test.\n"); return; } hr = IDirectDraw2_Initialize(ddraw, NULL); ok(hr == DDERR_ALREADYINITIALIZED, "Initialize returned hr %#x.\n", hr); IDirectDraw2_Release(ddraw); CoInitialize(NULL); hr = CoCreateInstance(&CLSID_DirectDraw, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectDraw2, (void **)&ddraw); ok(SUCCEEDED(hr), "Failed to create IDirectDraw2 instance, hr %#x.\n", hr); hr = IDirectDraw2_Initialize(ddraw, NULL); ok(hr == DD_OK, "Initialize returned hr %#x, expected DD_OK.\n", hr); hr = IDirectDraw2_Initialize(ddraw, NULL); ok(hr == DDERR_ALREADYINITIALIZED, "Initialize returned hr %#x, expected DDERR_ALREADYINITIALIZED.\n", hr); IDirectDraw2_Release(ddraw); CoUninitialize(); } static void test_coop_level_surf_create(void) { IDirectDrawSurface *surface; IDirectDraw2 *ddraw; DDSURFACEDESC ddsd; HRESULT hr; if (!(ddraw = create_ddraw())) { skip("Failed to create a ddraw object, skipping test.\n"); return; } memset(&ddsd, 0, sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; hr = IDirectDraw2_CreateSurface(ddraw, &ddsd, &surface, NULL); ok(hr == DDERR_NOCOOPERATIVELEVELSET, "Surface creation returned hr %#x.\n", hr); IDirectDraw2_Release(ddraw); } START_TEST(ddraw2) { test_coop_level_create_device_window(); test_clipper_blt(); test_coop_level_d3d_state(); test_surface_interface_mismatch(); test_coop_level_threaded(); test_depth_blit(); test_texture_load_ckey(); test_viewport_interfaces(); test_zenable(); test_ck_rgba(); test_ck_default(); test_surface_qi(); test_device_qi(); test_wndproc(); test_window_style(); test_redundant_mode_set(); test_coop_level_mode_set(); test_initialize(); test_coop_level_surf_create(); }