?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winemac: Consolidate mouse move handling into -[WineApplicationController handleMouse...
[wine.git] / dlls / ddraw / tests / ddraw7.c
blob3d8c70d2fce300b42e807cdebae7b208baed23ae
1 /*
2 * Copyright 2006, 2012-2013 Stefan Dösinger for CodeWeavers
3 * Copyright 2011 Henri Verbeet for CodeWeavers
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19 #define COBJMACROS
20
21 #include "wine/test.h"
22 #include <limits.h>
23 #include "d3d.h"
24
25 static HRESULT (WINAPI *pDirectDrawCreateEx)(GUID *guid, void **ddraw, REFIID iid, IUnknown *outer_unknown);
26
27 struct vec2
28 {
29 float x, y;
30 };
31
32 struct vec3
33 {
34 float x, y, z;
35 };
36
37 struct vec4
38 {
39 float x, y, z, w;
40 };
41
42 struct create_window_thread_param
43 {
44 HWND window;
45 HANDLE window_created;
46 HANDLE destroy_window;
47 HANDLE thread;
48 };
49
50 static BOOL compare_float(float f, float g, unsigned int ulps)
51 {
52 int x = *(int *)&f;
53 int y = *(int *)&g;
54
55 if (x < 0)
56 x = INT_MIN - x;
57 if (y < 0)
58 y = INT_MIN - y;
59
60 if (abs(x - y) > ulps)
61 return FALSE;
62
63 return TRUE;
64 }
65
66 static BOOL compare_vec3(struct vec3 *vec, float x, float y, float z, unsigned int ulps)
67 {
68 return compare_float(vec->x, x, ulps)
69 && compare_float(vec->y, y, ulps)
70 && compare_float(vec->z, z, ulps);
71 }
72
73 static BOOL compare_vec4(struct vec4 *vec, float x, float y, float z, float w, unsigned int ulps)
74 {
75 return compare_float(vec->x, x, ulps)
76 && compare_float(vec->y, y, ulps)
77 && compare_float(vec->z, z, ulps)
78 && compare_float(vec->w, w, ulps);
79 }
80
81 static BOOL compare_color(D3DCOLOR c1, D3DCOLOR c2, BYTE max_diff)
82 {
83 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
84 c1 >>= 8; c2 >>= 8;
85 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
86 c1 >>= 8; c2 >>= 8;
87 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
88 c1 >>= 8; c2 >>= 8;
89 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
90 return TRUE;
91 }
92
93 static DWORD WINAPI create_window_thread_proc(void *param)
94 {
95 struct create_window_thread_param *p = param;
96 DWORD res;
97 BOOL ret;
98
99 p->window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
100 0, 0, 640, 480, 0, 0, 0, 0);
101 ret = SetEvent(p->window_created);
102 ok(ret, "SetEvent failed, last error %#x.\n", GetLastError());
103
104 for (;;)
105 {
106 MSG msg;
107
108 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
109 DispatchMessage(&msg);
110 res = WaitForSingleObject(p->destroy_window, 100);
111 if (res == WAIT_OBJECT_0)
112 break;
113 if (res != WAIT_TIMEOUT)
114 {
115 ok(0, "Wait failed (%#x), last error %#x.\n", res, GetLastError());
116 break;
117 }
118 }
119
120 DestroyWindow(p->window);
121
122 return 0;
123 }
124
125 static void create_window_thread(struct create_window_thread_param *p)
126 {
127 DWORD res, tid;
128
129 p->window_created = CreateEvent(NULL, FALSE, FALSE, NULL);
130 ok(!!p->window_created, "CreateEvent failed, last error %#x.\n", GetLastError());
131 p->destroy_window = CreateEvent(NULL, FALSE, FALSE, NULL);
132 ok(!!p->destroy_window, "CreateEvent failed, last error %#x.\n", GetLastError());
133 p->thread = CreateThread(NULL, 0, create_window_thread_proc, p, 0, &tid);
134 ok(!!p->thread, "Failed to create thread, last error %#x.\n", GetLastError());
135 res = WaitForSingleObject(p->window_created, INFINITE);
136 ok(res == WAIT_OBJECT_0, "Wait failed (%#x), last error %#x.\n", res, GetLastError());
137 }
138
139 static void destroy_window_thread(struct create_window_thread_param *p)
140 {
141 SetEvent(p->destroy_window);
142 WaitForSingleObject(p->thread, INFINITE);
143 CloseHandle(p->destroy_window);
144 CloseHandle(p->window_created);
145 CloseHandle(p->thread);
146 }
147
148 static IDirectDrawSurface7 *get_depth_stencil(IDirect3DDevice7 *device)
149 {
150 IDirectDrawSurface7 *rt, *ret;
151 DDSCAPS2 caps = {DDSCAPS_ZBUFFER, 0, 0, 0};
152 HRESULT hr;
153
154 hr = IDirect3DDevice7_GetRenderTarget(device, &rt);
155 ok(SUCCEEDED(hr), "Failed to get the render target, hr %#x.\n", hr);
156 hr = IDirectDrawSurface7_GetAttachedSurface(rt, &caps, &ret);
157 ok(SUCCEEDED(hr) || hr == DDERR_NOTFOUND, "Failed to get the z buffer, hr %#x.\n", hr);
158 IDirectDrawSurface7_Release(rt);
159 return ret;
160 }
161
162 static D3DCOLOR get_surface_color(IDirectDrawSurface7 *surface, UINT x, UINT y)
163 {
164 RECT rect = {x, y, x + 1, y + 1};
165 DDSURFACEDESC2 surface_desc;
166 D3DCOLOR color;
167 HRESULT hr;
168
169 memset(&surface_desc, 0, sizeof(surface_desc));
170 surface_desc.dwSize = sizeof(surface_desc);
171
172 hr = IDirectDrawSurface7_Lock(surface, &rect, &surface_desc, DDLOCK_READONLY, NULL);
173 ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr);
174 if (FAILED(hr))
175 return 0xdeadbeef;
176
177 color = *((DWORD *)surface_desc.lpSurface) & 0x00ffffff;
178
179 hr = IDirectDrawSurface7_Unlock(surface, &rect);
180 ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr);
181
182 return color;
183 }
184
185 static HRESULT CALLBACK enum_z_fmt(DDPIXELFORMAT *format, void *ctx)
186 {
187 DDPIXELFORMAT *z_fmt = ctx;
188
189 if (U1(*format).dwZBufferBitDepth > U1(*z_fmt).dwZBufferBitDepth)
190 *z_fmt = *format;
191
192 return DDENUMRET_OK;
193 }
194
195 static IDirectDraw7 *create_ddraw(void)
196 {
197 IDirectDraw7 *ddraw;
198
199 if (FAILED(pDirectDrawCreateEx(NULL, (void **)&ddraw, &IID_IDirectDraw7, NULL)))
200 return NULL;
201
202 return ddraw;
203 }
204
205 static HRESULT WINAPI enum_devtype_cb(char *desc_str, char *name, D3DDEVICEDESC7 *desc, void *ctx)
206 {
207 BOOL *hal_ok = ctx;
208 if (IsEqualGUID(&desc->deviceGUID, &IID_IDirect3DTnLHalDevice))
209 {
210 *hal_ok = TRUE;
211 return DDENUMRET_CANCEL;
212 }
213 return DDENUMRET_OK;
214 }
215
216 static IDirect3DDevice7 *create_device(HWND window, DWORD coop_level)
217 {
218 IDirectDrawSurface7 *surface, *ds;
219 IDirect3DDevice7 *device = NULL;
220 DDSURFACEDESC2 surface_desc;
221 DDPIXELFORMAT z_fmt;
222 IDirectDraw7 *ddraw;
223 IDirect3D7 *d3d7;
224 HRESULT hr;
225 BOOL hal_ok = FALSE;
226 const GUID *devtype = &IID_IDirect3DHALDevice;
227
228 if (!(ddraw = create_ddraw()))
229 return NULL;
230
231 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, coop_level);
232 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
233
234 memset(&surface_desc, 0, sizeof(surface_desc));
235 surface_desc.dwSize = sizeof(surface_desc);
236 surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
237 surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
238 surface_desc.dwWidth = 640;
239 surface_desc.dwHeight = 480;
240
241 hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &surface, NULL);
242 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
243
244 if (coop_level & DDSCL_NORMAL)
245 {
246 IDirectDrawClipper *clipper;
247
248 hr = IDirectDraw7_CreateClipper(ddraw, 0, &clipper, NULL);
249 ok(SUCCEEDED(hr), "Failed to create clipper, hr %#x.\n", hr);
250 hr = IDirectDrawClipper_SetHWnd(clipper, 0, window);
251 ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
252 hr = IDirectDrawSurface7_SetClipper(surface, clipper);
253 ok(SUCCEEDED(hr), "Failed to set surface clipper, hr %#x.\n", hr);
254 IDirectDrawClipper_Release(clipper);
255 }
256
257 hr = IDirectDraw7_QueryInterface(ddraw, &IID_IDirect3D7, (void **)&d3d7);
258 IDirectDraw7_Release(ddraw);
259 if (FAILED(hr))
260 {
261 IDirectDrawSurface7_Release(surface);
262 return NULL;
263 }
264
265 hr = IDirect3D7_EnumDevices(d3d7, enum_devtype_cb, &hal_ok);
266 ok(SUCCEEDED(hr), "Failed to enumerate devices, hr %#x.\n", hr);
267 if (hal_ok) devtype = &IID_IDirect3DTnLHalDevice;
268
269 memset(&z_fmt, 0, sizeof(z_fmt));
270 hr = IDirect3D7_EnumZBufferFormats(d3d7, devtype, enum_z_fmt, &z_fmt);
271 if (FAILED(hr) || !z_fmt.dwSize)
272 {
273 IDirect3D7_Release(d3d7);
274 IDirectDrawSurface7_Release(surface);
275 return NULL;
276 }
277
278 memset(&surface_desc, 0, sizeof(surface_desc));
279 surface_desc.dwSize = sizeof(surface_desc);
280 surface_desc.dwFlags = DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT;
281 surface_desc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
282 U4(surface_desc).ddpfPixelFormat = z_fmt;
283 surface_desc.dwWidth = 640;
284 surface_desc.dwHeight = 480;
285 hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &ds, NULL);
286 ok(SUCCEEDED(hr), "Failed to create depth buffer, hr %#x.\n", hr);
287 if (FAILED(hr))
288 {
289 IDirect3D7_Release(d3d7);
290 IDirectDrawSurface7_Release(surface);
291 return NULL;
292 }
293
294 hr = IDirectDrawSurface_AddAttachedSurface(surface, ds);
295 ok(SUCCEEDED(hr), "Failed to attach depth buffer, hr %#x.\n", hr);
296 IDirectDrawSurface7_Release(ds);
297 if (FAILED(hr))
298 {
299 IDirect3D7_Release(d3d7);
300 IDirectDrawSurface7_Release(surface);
301 return NULL;
302 }
303
304 hr = IDirect3D7_CreateDevice(d3d7, devtype, surface, &device);
305 IDirect3D7_Release(d3d7);
306 IDirectDrawSurface7_Release(surface);
307 if (FAILED(hr))
308 return NULL;
309
310 return device;
311 }
312
313 static const UINT *expect_messages;
314
315 static LRESULT CALLBACK test_proc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
316 {
317 if (expect_messages && message == *expect_messages)
318 ++expect_messages;
319
320 return DefWindowProcA(hwnd, message, wparam, lparam);
321 }
322
323 /* Set the wndproc back to what ddraw expects it to be, and release the ddraw
324 * interface. This prevents subsequent SetCooperativeLevel() calls on a
325 * different window from failing with DDERR_HWNDALREADYSET. */
326 static void fix_wndproc(HWND window, LONG_PTR proc)
327 {
328 IDirectDraw7 *ddraw;
329 HRESULT hr;
330
331 if (!(ddraw = create_ddraw()))
332 return;
333
334 SetWindowLongPtrA(window, GWLP_WNDPROC, proc);
335 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
336 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
337 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
338 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
339
340 IDirectDraw7_Release(ddraw);
341 }
342
343 static void test_process_vertices(void)
344 {
345 IDirect3DVertexBuffer7 *src_vb, *dst_vb1, *dst_vb2;
346 D3DVERTEXBUFFERDESC vb_desc;
347 IDirect3DDevice7 *device;
348 struct vec4 *dst_data;
349 struct vec3 *dst_data2;
350 struct vec3 *src_data;
351 IDirect3D7 *d3d7;
352 D3DVIEWPORT7 vp;
353 HWND window;
354 HRESULT hr;
355
356 static D3DMATRIX world =
357 {
358 0.0f, 1.0f, 0.0f, 0.0f,
359 1.0f, 0.0f, 0.0f, 0.0f,
360 0.0f, 0.0f, 0.0f, 1.0f,
361 0.0f, 1.0f, 1.0f, 1.0f,
362 };
363 static D3DMATRIX view =
364 {
365 2.0f, 0.0f, 0.0f, 0.0f,
366 0.0f, -1.0f, 0.0f, 0.0f,
367 0.0f, 0.0f, 1.0f, 0.0f,
368 0.0f, 0.0f, 0.0f, 3.0f,
369 };
370 static D3DMATRIX proj =
371 {
372 1.0f, 0.0f, 0.0f, 1.0f,
373 0.0f, 1.0f, 1.0f, 0.0f,
374 0.0f, 1.0f, 1.0f, 0.0f,
375 1.0f, 0.0f, 0.0f, 1.0f,
376 };
377
378 window = CreateWindowA("static", "d3d7_test", WS_OVERLAPPEDWINDOW,
379 0, 0, 640, 480, 0, 0, 0, 0);
380 if (!(device = create_device(window, DDSCL_NORMAL)))
381 {
382 skip("Failed to create a ddraw object, skipping test.\n");
383 DestroyWindow(window);
384 return;
385 }
386
387 hr = IDirect3DDevice7_GetDirect3D(device, &d3d7);
388 ok(SUCCEEDED(hr), "Failed to get Direct3D7 interface, hr %#x.\n", hr);
389
390 memset(&vb_desc, 0, sizeof(vb_desc));
391 vb_desc.dwSize = sizeof(vb_desc);
392 vb_desc.dwFVF = D3DFVF_XYZ;
393 vb_desc.dwNumVertices = 4;
394 hr = IDirect3D7_CreateVertexBuffer(d3d7, &vb_desc, &src_vb, 0);
395 ok(SUCCEEDED(hr), "Failed to create source vertex buffer, hr %#x.\n", hr);
396
397 hr = IDirect3DVertexBuffer7_Lock(src_vb, 0, (void **)&src_data, NULL);
398 ok(SUCCEEDED(hr), "Failed to lock source vertex buffer, hr %#x.\n", hr);
399 src_data[0].x = 0.0f;
400 src_data[0].y = 0.0f;
401 src_data[0].z = 0.0f;
402 src_data[1].x = 1.0f;
403 src_data[1].y = 1.0f;
404 src_data[1].z = 1.0f;
405 src_data[2].x = -1.0f;
406 src_data[2].y = -1.0f;
407 src_data[2].z = 0.5f;
408 src_data[3].x = 0.5f;
409 src_data[3].y = -0.5f;
410 src_data[3].z = 0.25f;
411 hr = IDirect3DVertexBuffer7_Unlock(src_vb);
412 ok(SUCCEEDED(hr), "Failed to unlock source vertex buffer, hr %#x.\n", hr);
413
414 memset(&vb_desc, 0, sizeof(vb_desc));
415 vb_desc.dwSize = sizeof(vb_desc);
416 vb_desc.dwFVF = D3DFVF_XYZRHW;
417 vb_desc.dwNumVertices = 4;
418 /* MSDN says that the last parameter must be 0 - check that. */
419 hr = IDirect3D7_CreateVertexBuffer(d3d7, &vb_desc, &dst_vb1, 4);
420 ok(SUCCEEDED(hr), "Failed to create vertex buffer, hr %#x.\n", hr);
421
422 memset(&vb_desc, 0, sizeof(vb_desc));
423 vb_desc.dwSize = sizeof(vb_desc);
424 vb_desc.dwFVF = D3DFVF_XYZ;
425 vb_desc.dwNumVertices = 5;
426 /* MSDN says that the last parameter must be 0 - check that. */
427 hr = IDirect3D7_CreateVertexBuffer(d3d7, &vb_desc, &dst_vb2, 12345678);
428 ok(SUCCEEDED(hr), "Failed to create vertex buffer, hr %#x.\n", hr);
429
430 memset(&vp, 0, sizeof(vp));
431 vp.dwX = 64;
432 vp.dwY = 64;
433 vp.dwWidth = 128;
434 vp.dwHeight = 128;
435 vp.dvMinZ = 0.0f;
436 vp.dvMaxZ = 1.0f;
437 hr = IDirect3DDevice7_SetViewport(device, &vp);
438 ok(SUCCEEDED(hr), "Failed to set viewport, hr %#x.\n", hr);
439
440 hr = IDirect3DVertexBuffer7_ProcessVertices(dst_vb1, D3DVOP_TRANSFORM, 0, 4, src_vb, 0, device, 0);
441 ok(SUCCEEDED(hr), "Failed to process vertices, hr %#x.\n", hr);
442 hr = IDirect3DVertexBuffer7_ProcessVertices(dst_vb2, D3DVOP_TRANSFORM, 0, 4, src_vb, 0, device, 0);
443 ok(SUCCEEDED(hr), "Failed to process vertices, hr %#x.\n", hr);
444
445 hr = IDirect3DVertexBuffer7_Lock(dst_vb1, 0, (void **)&dst_data, NULL);
446 ok(SUCCEEDED(hr), "Failed to lock destination vertex buffer, hr %#x.\n", hr);
447 ok(compare_vec4(&dst_data[0], +1.280e+2f, +1.280e+2f, +0.000e+0f, +1.000e+0f, 4096),
448 "Got unexpected vertex 0 {%.8e, %.8e, %.8e, %.8e}.\n",
449 dst_data[0].x, dst_data[0].y, dst_data[0].z, dst_data[0].w);
450 ok(compare_vec4(&dst_data[1], +1.920e+2f, +6.400e+1f, +1.000e+0f, +1.000e+0f, 4096),
451 "Got unexpected vertex 1 {%.8e, %.8e, %.8e, %.8e}.\n",
452 dst_data[1].x, dst_data[1].y, dst_data[1].z, dst_data[1].w);
453 ok(compare_vec4(&dst_data[2], +6.400e+1f, +1.920e+2f, +5.000e-1f, +1.000e+0f, 4096),
454 "Got unexpected vertex 2 {%.8e, %.8e, %.8e, %.8e}.\n",
455 dst_data[2].x, dst_data[2].y, dst_data[2].z, dst_data[2].w);
456 ok(compare_vec4(&dst_data[3], +1.600e+2f, +1.600e+2f, +2.500e-1f, +1.000e+0f, 4096),
457 "Got unexpected vertex 3 {%.8e, %.8e, %.8e, %.8e}.\n",
458 dst_data[3].x, dst_data[3].y, dst_data[3].z, dst_data[3].w);
459 hr = IDirect3DVertexBuffer7_Unlock(dst_vb1);
460 ok(SUCCEEDED(hr), "Failed to unlock destination vertex buffer, hr %#x.\n", hr);
461
462 hr = IDirect3DVertexBuffer7_Lock(dst_vb2, 0, (void **)&dst_data2, NULL);
463 ok(SUCCEEDED(hr), "Failed to lock destination vertex buffer, hr %#x.\n", hr);
464 /* Small thing without much practical meaning, but I stumbled upon it,
465 * so let's check for it: If the output vertex buffer has no RHW value,
466 * the RHW value of the last vertex is written into the next vertex. */
467 ok(compare_vec3(&dst_data2[4], +1.000e+0f, +0.000e+0f, +0.000e+0f, 4096),
468 "Got unexpected vertex 4 {%.8e, %.8e, %.8e}.\n",
469 dst_data2[4].x, dst_data2[4].y, dst_data2[4].z);
470 hr = IDirect3DVertexBuffer7_Unlock(dst_vb2);
471 ok(SUCCEEDED(hr), "Failed to unlock destination vertex buffer, hr %#x.\n", hr);
472
473 /* Try a more complicated viewport, same vertices. */
474 memset(&vp, 0, sizeof(vp));
475 vp.dwX = 10;
476 vp.dwY = 5;
477 vp.dwWidth = 246;
478 vp.dwHeight = 130;
479 vp.dvMinZ = -2.0f;
480 vp.dvMaxZ = 4.0f;
481 hr = IDirect3DDevice7_SetViewport(device, &vp);
482 ok(SUCCEEDED(hr), "Failed to set viewport, hr %#x.\n", hr);
483
484 hr = IDirect3DVertexBuffer7_ProcessVertices(dst_vb1, D3DVOP_TRANSFORM, 0, 4, src_vb, 0, device, 0);
485 ok(SUCCEEDED(hr), "Failed to process vertices, hr %#x.\n", hr);
486
487 hr = IDirect3DVertexBuffer7_Lock(dst_vb1, 0, (void **)&dst_data, NULL);
488 ok(SUCCEEDED(hr), "Failed to lock destination vertex buffer, hr %#x.\n", hr);
489 ok(compare_vec4(&dst_data[0], +1.330e+2f, +7.000e+1f, -2.000e+0f, +1.000e+0f, 4096),
490 "Got unexpected vertex 0 {%.8e, %.8e, %.8e, %.8e}.\n",
491 dst_data[0].x, dst_data[0].y, dst_data[0].z, dst_data[0].w);
492 ok(compare_vec4(&dst_data[1], +2.560e+2f, +5.000e+0f, +4.000e+0f, +1.000e+0f, 4096),
493 "Got unexpected vertex 1 {%.8e, %.8e, %.8e, %.8e}.\n",
494 dst_data[1].x, dst_data[1].y, dst_data[1].z, dst_data[1].w);
495 ok(compare_vec4(&dst_data[2], +1.000e+1f, +1.350e+2f, +1.000e+0f, +1.000e+0f, 4096),
496 "Got unexpected vertex 2 {%.8e, %.8e, %.8e, %.8e}.\n",
497 dst_data[2].x, dst_data[2].y, dst_data[2].z, dst_data[2].w);
498 ok(compare_vec4(&dst_data[3], +1.945e+2f, +1.025e+2f, -5.000e-1f, +1.000e+0f, 4096),
499 "Got unexpected vertex 3 {%.8e, %.8e, %.8e, %.8e}.\n",
500 dst_data[3].x, dst_data[3].y, dst_data[3].z, dst_data[3].w);
501 hr = IDirect3DVertexBuffer7_Unlock(dst_vb1);
502 ok(SUCCEEDED(hr), "Failed to unlock destination vertex buffer, hr %#x.\n", hr);
503
504 hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_WORLD, &world);
505 ok(SUCCEEDED(hr), "Failed to set world transform, hr %#x.\n", hr);
506 hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_VIEW, &view);
507 ok(SUCCEEDED(hr), "Failed to set view transform, hr %#x.\n", hr);
508 hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_PROJECTION, &proj);
509 ok(SUCCEEDED(hr), "Failed to set projection transform, hr %#x.\n", hr);
510
511 hr = IDirect3DVertexBuffer7_ProcessVertices(dst_vb1, D3DVOP_TRANSFORM, 0, 4, src_vb, 0, device, 0);
512 ok(SUCCEEDED(hr), "Failed to process vertices, hr %#x.\n", hr);
513
514 hr = IDirect3DVertexBuffer7_Lock(dst_vb1, 0, (void **)&dst_data, NULL);
515 ok(SUCCEEDED(hr), "Failed to lock destination vertex buffer, hr %#x.\n", hr);
516 ok(compare_vec4(&dst_data[0], +2.560e+2f, +7.000e+1f, -2.000e+0f, +3.333e-1f, 4096),
517 "Got unexpected vertex 0 {%.8e, %.8e, %.8e, %.8e}.\n",
518 dst_data[0].x, dst_data[0].y, dst_data[0].z, dst_data[0].w);
519 ok(compare_vec4(&dst_data[1], +2.560e+2f, +7.813e+1f, -2.750e+0f, +1.250e-1f, 4096),
520 "Got unexpected vertex 1 {%.8e, %.8e, %.8e, %.8e}.\n",
521 dst_data[1].x, dst_data[1].y, dst_data[1].z, dst_data[1].w);
522 ok(compare_vec4(&dst_data[2], +2.560e+2f, +4.400e+1f, +4.000e-1f, +4.000e-1f, 4096),
523 "Got unexpected vertex 2 {%.8e, %.8e, %.8e, %.8e}.\n",
524 dst_data[2].x, dst_data[2].y, dst_data[2].z, dst_data[2].w);
525 ok(compare_vec4(&dst_data[3], +2.560e+2f, +8.182e+1f, -3.091e+0f, +3.636e-1f, 4096),
526 "Got unexpected vertex 3 {%.8e, %.8e, %.8e, %.8e}.\n",
527 dst_data[3].x, dst_data[3].y, dst_data[3].z, dst_data[3].w);
528 hr = IDirect3DVertexBuffer7_Unlock(dst_vb1);
529 ok(SUCCEEDED(hr), "Failed to unlock destination vertex buffer, hr %#x.\n", hr);
530
531 IDirect3DVertexBuffer7_Release(dst_vb2);
532 IDirect3DVertexBuffer7_Release(dst_vb1);
533 IDirect3DVertexBuffer7_Release(src_vb);
534 IDirect3D7_Release(d3d7);
535 IDirect3DDevice7_Release(device);
536 DestroyWindow(window);
537 }
538
539 static void test_coop_level_create_device_window(void)
540 {
541 HWND focus_window, device_window;
542 IDirectDraw7 *ddraw;
543 HRESULT hr;
544
545 focus_window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
546 0, 0, 640, 480, 0, 0, 0, 0);
547 if (!(ddraw = create_ddraw()))
548 {
549 skip("Failed to create a 3D device, skipping test.\n");
550 DestroyWindow(focus_window);
551 return;
552 }
553
554 hr = IDirectDraw7_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL);
555 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
556 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
557 ok(!device_window, "Unexpected device window found.\n");
558 hr = IDirectDraw7_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW);
559 ok(hr == DDERR_INVALIDPARAMS, "Got unexpected hr %#x.\n", hr);
560 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
561 ok(!device_window, "Unexpected device window found.\n");
562 hr = IDirectDraw7_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_NORMAL);
563 ok(hr == DDERR_INVALIDPARAMS, "Got unexpected hr %#x.\n", hr);
564 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
565 ok(!device_window, "Unexpected device window found.\n");
566 hr = IDirectDraw7_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_NORMAL | DDSCL_FULLSCREEN);
567 ok(hr == DDERR_INVALIDPARAMS, "Got unexpected hr %#x.\n", hr);
568 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
569 ok(!device_window, "Unexpected device window found.\n");
570 hr = IDirectDraw7_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
571 ok(hr == DDERR_NOFOCUSWINDOW || broken(hr == DDERR_INVALIDPARAMS), "Got unexpected hr %#x.\n", hr);
572 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
573 ok(!device_window, "Unexpected device window found.\n");
574
575 /* Windows versions before 98 / NT5 don't support DDSCL_CREATEDEVICEWINDOW. */
576 if (broken(hr == DDERR_INVALIDPARAMS))
577 {
578 win_skip("DDSCL_CREATEDEVICEWINDOW not supported, skipping test.\n");
579 IDirectDraw7_Release(ddraw);
580 DestroyWindow(focus_window);
581 return;
582 }
583
584 hr = IDirectDraw7_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL);
585 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
586 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
587 ok(!device_window, "Unexpected device window found.\n");
588 hr = IDirectDraw7_SetCooperativeLevel(ddraw, focus_window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
589 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
590 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
591 ok(!device_window, "Unexpected device window found.\n");
592
593 hr = IDirectDraw7_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL);
594 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
595 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
596 ok(!device_window, "Unexpected device window found.\n");
597 hr = IDirectDraw7_SetCooperativeLevel(ddraw, NULL, DDSCL_SETFOCUSWINDOW
598 | DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
599 ok(hr == DDERR_NOHWND, "Got unexpected hr %#x.\n", hr);
600 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
601 ok(!!device_window, "Device window not found.\n");
602
603 hr = IDirectDraw7_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL);
604 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
605 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
606 ok(!device_window, "Unexpected device window found.\n");
607 hr = IDirectDraw7_SetCooperativeLevel(ddraw, focus_window, DDSCL_SETFOCUSWINDOW
608 | DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
609 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
610 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
611 ok(!!device_window, "Device window not found.\n");
612
613 hr = IDirectDraw7_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL);
614 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
615 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
616 ok(!device_window, "Unexpected device window found.\n");
617 hr = IDirectDraw7_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
618 ok(hr == DDERR_NOFOCUSWINDOW, "Got unexpected hr %#x.\n", hr);
619 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
620 ok(!device_window, "Unexpected device window found.\n");
621 hr = IDirectDraw7_SetCooperativeLevel(ddraw, focus_window, DDSCL_SETFOCUSWINDOW);
622 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
623 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
624 ok(!device_window, "Unexpected device window found.\n");
625 hr = IDirectDraw7_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
626 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
627 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
628 ok(!!device_window, "Device window not found.\n");
629
630 IDirectDraw7_Release(ddraw);
631 DestroyWindow(focus_window);
632 }
633
634 static void test_clipper_blt(void)
635 {
636 IDirectDrawSurface7 *src_surface, *dst_surface;
637 RECT client_rect, src_rect;
638 IDirectDrawClipper *clipper;
639 DDSURFACEDESC2 surface_desc;
640 unsigned int i, j, x, y;
641 IDirectDraw7 *ddraw;
642 RGNDATA *rgn_data;
643 D3DCOLOR color;
644 HRGN r1, r2;
645 HWND window;
646 DDBLTFX fx;
647 HRESULT hr;
648 DWORD *ptr;
649 DWORD ret;
650
651 static const DWORD src_data[] =
652 {
653 0xff0000ff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffffffff, 0xffffffff,
654 0xff0000ff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffffffff, 0xffffffff,
655 0xff0000ff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffffffff, 0xffffffff,
656 };
657 static const D3DCOLOR expected1[] =
658 {
659 0x000000ff, 0x0000ff00, 0x00000000, 0x00000000,
660 0x000000ff, 0x0000ff00, 0x00000000, 0x00000000,
661 0x00000000, 0x00000000, 0x00ff0000, 0x00ffffff,
662 0x00000000, 0x00000000, 0x00ff0000, 0x00ffffff,
663 };
664 static const D3DCOLOR expected2[] =
665 {
666 0x000000ff, 0x000000ff, 0x00000000, 0x00000000,
667 0x000000ff, 0x000000ff, 0x00000000, 0x00000000,
668 0x00000000, 0x00000000, 0x000000ff, 0x000000ff,
669 0x00000000, 0x00000000, 0x000000ff, 0x000000ff,
670 };
671
672 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
673 10, 10, 640, 480, 0, 0, 0, 0);
674 ShowWindow(window, SW_SHOW);
675 if (!(ddraw = create_ddraw()))
676 {
677 skip("Failed to create a ddraw object, skipping test.\n");
678 DestroyWindow(window);
679 return;
680 }
681
682 ret = GetClientRect(window, &client_rect);
683 ok(ret, "Failed to get client rect.\n");
684 ret = MapWindowPoints(window, NULL, (POINT *)&client_rect, 2);
685 ok(ret, "Failed to map client rect.\n");
686
687 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
688 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
689
690 hr = IDirectDraw7_CreateClipper(ddraw, 0, &clipper, NULL);
691 ok(SUCCEEDED(hr), "Failed to create clipper, hr %#x.\n", hr);
692 hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
693 ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr);
694 hr = IDirectDrawClipper_SetHWnd(clipper, 0, window);
695 ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
696 hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
697 ok(SUCCEEDED(hr), "Failed to get clip list size, hr %#x.\n", hr);
698 rgn_data = HeapAlloc(GetProcessHeap(), 0, ret);
699 hr = IDirectDrawClipper_GetClipList(clipper, NULL, rgn_data, &ret);
700 ok(SUCCEEDED(hr), "Failed to get clip list, hr %#x.\n", hr);
701 ok(rgn_data->rdh.dwSize == sizeof(rgn_data->rdh), "Got unexpected structure size %#x.\n", rgn_data->rdh.dwSize);
702 ok(rgn_data->rdh.iType == RDH_RECTANGLES, "Got unexpected type %#x.\n", rgn_data->rdh.iType);
703 ok(rgn_data->rdh.nCount >= 1, "Got unexpected count %u.\n", rgn_data->rdh.nCount);
704 ok(EqualRect(&rgn_data->rdh.rcBound, &client_rect),
705 "Got unexpected bounding rect {%d, %d, %d, %d}, expected {%d, %d, %d, %d}.\n",
706 rgn_data->rdh.rcBound.left, rgn_data->rdh.rcBound.top,
707 rgn_data->rdh.rcBound.right, rgn_data->rdh.rcBound.bottom,
708 client_rect.left, client_rect.top, client_rect.right, client_rect.bottom);
709 HeapFree(GetProcessHeap(), 0, rgn_data);
710
711 r1 = CreateRectRgn(0, 0, 320, 240);
712 ok(!!r1, "Failed to create region.\n");
713 r2 = CreateRectRgn(320, 240, 640, 480);
714 ok(!!r2, "Failed to create region.\n");
715 CombineRgn(r1, r1, r2, RGN_OR);
716 ret = GetRegionData(r1, 0, NULL);
717 rgn_data = HeapAlloc(GetProcessHeap(), 0, ret);
718 ret = GetRegionData(r1, ret, rgn_data);
719 ok(!!ret, "Failed to get region data.\n");
720
721 DeleteObject(r2);
722 DeleteObject(r1);
723
724 hr = IDirectDrawClipper_SetClipList(clipper, rgn_data, 0);
725 ok(hr == DDERR_CLIPPERISUSINGHWND, "Got unexpected hr %#x.\n", hr);
726 hr = IDirectDrawClipper_SetHWnd(clipper, 0, NULL);
727 ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
728 hr = IDirectDrawClipper_SetClipList(clipper, rgn_data, 0);
729 ok(SUCCEEDED(hr), "Failed to set clip list, hr %#x.\n", hr);
730
731 HeapFree(GetProcessHeap(), 0, rgn_data);
732
733 memset(&surface_desc, 0, sizeof(surface_desc));
734 surface_desc.dwSize = sizeof(surface_desc);
735 surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
736 surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
737 surface_desc.dwWidth = 640;
738 surface_desc.dwHeight = 480;
739 U4(surface_desc).ddpfPixelFormat.dwSize = sizeof(U4(surface_desc).ddpfPixelFormat);
740 U4(surface_desc).ddpfPixelFormat.dwFlags = DDPF_RGB;
741 U1(U4(surface_desc).ddpfPixelFormat).dwRGBBitCount = 32;
742 U2(U4(surface_desc).ddpfPixelFormat).dwRBitMask = 0x00ff0000;
743 U3(U4(surface_desc).ddpfPixelFormat).dwGBitMask = 0x0000ff00;
744 U4(U4(surface_desc).ddpfPixelFormat).dwBBitMask = 0x000000ff;
745
746 hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &src_surface, NULL);
747 ok(SUCCEEDED(hr), "Failed to create source surface, hr %#x.\n", hr);
748 hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &dst_surface, NULL);
749 ok(SUCCEEDED(hr), "Failed to create destination surface, hr %#x.\n", hr);
750
751 memset(&fx, 0, sizeof(fx));
752 fx.dwSize = sizeof(fx);
753 hr = IDirectDrawSurface7_Blt(src_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
754 ok(SUCCEEDED(hr), "Failed to clear source surface, hr %#x.\n", hr);
755 hr = IDirectDrawSurface7_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
756 ok(SUCCEEDED(hr), "Failed to clear destination surface, hr %#x.\n", hr);
757
758 hr = IDirectDrawSurface7_Lock(src_surface, NULL, &surface_desc, 0, NULL);
759 ok(SUCCEEDED(hr), "Failed to lock source surface, hr %#x.\n", hr);
760 ok(U1(surface_desc).lPitch == 2560, "Got unexpected surface pitch %u.\n", U1(surface_desc).lPitch);
761 ptr = surface_desc.lpSurface;
762 memcpy(&ptr[ 0], &src_data[ 0], 6 * sizeof(DWORD));
763 memcpy(&ptr[ 640], &src_data[ 6], 6 * sizeof(DWORD));
764 memcpy(&ptr[1280], &src_data[12], 6 * sizeof(DWORD));
765 hr = IDirectDrawSurface7_Unlock(src_surface, NULL);
766 ok(SUCCEEDED(hr), "Failed to unlock source surface, hr %#x.\n", hr);
767
768 hr = IDirectDrawSurface7_SetClipper(dst_surface, clipper);
769 ok(SUCCEEDED(hr), "Failed to set clipper, hr %#x.\n", hr);
770
771 SetRect(&src_rect, 1, 1, 5, 2);
772 hr = IDirectDrawSurface7_Blt(dst_surface, NULL, src_surface, &src_rect, DDBLT_WAIT, NULL);
773 ok(SUCCEEDED(hr), "Failed to blit, hr %#x.\n", hr);
774 for (i = 0; i < 4; ++i)
775 {
776 for (j = 0; j < 4; ++j)
777 {
778 x = 80 * ((2 * j) + 1);
779 y = 60 * ((2 * i) + 1);
780 color = get_surface_color(dst_surface, x, y);
781 ok(compare_color(color, expected1[i * 4 + j], 1),
782 "Expected color 0x%08x at %u,%u, got 0x%08x.\n", expected1[i * 4 + j], x, y, color);
783 }
784 }
785
786 U5(fx).dwFillColor = 0xff0000ff;
787 hr = IDirectDrawSurface7_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
788 ok(SUCCEEDED(hr), "Failed to clear destination surface, hr %#x.\n", hr);
789 for (i = 0; i < 4; ++i)
790 {
791 for (j = 0; j < 4; ++j)
792 {
793 x = 80 * ((2 * j) + 1);
794 y = 60 * ((2 * i) + 1);
795 color = get_surface_color(dst_surface, x, y);
796 ok(compare_color(color, expected2[i * 4 + j], 1),
797 "Expected color 0x%08x at %u,%u, got 0x%08x.\n", expected2[i * 4 + j], x, y, color);
798 }
799 }
800
801 hr = IDirectDrawSurface7_BltFast(dst_surface, 0, 0, src_surface, NULL, DDBLTFAST_WAIT);
802 ok(hr == DDERR_BLTFASTCANTCLIP, "Got unexpected hr %#x.\n", hr);
803
804 hr = IDirectDrawClipper_SetHWnd(clipper, 0, window);
805 ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
806 hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
807 ok(SUCCEEDED(hr), "Failed to get clip list size, hr %#x.\n", hr);
808 DestroyWindow(window);
809 hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
810 ok(hr == E_FAIL, "Got unexpected hr %#x.\n", hr);
811 hr = IDirectDrawClipper_SetHWnd(clipper, 0, NULL);
812 ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
813 hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
814 ok(SUCCEEDED(hr), "Failed to get clip list size, hr %#x.\n", hr);
815 hr = IDirectDrawClipper_SetClipList(clipper, NULL, 0);
816 ok(SUCCEEDED(hr), "Failed to set clip list, hr %#x.\n", hr);
817 hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
818 ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr);
819 hr = IDirectDrawSurface7_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
820 ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr);
821
822 IDirectDrawSurface7_Release(dst_surface);
823 IDirectDrawSurface7_Release(src_surface);
824 IDirectDrawClipper_Release(clipper);
825 IDirectDraw7_Release(ddraw);
826 }
827
828 static void test_coop_level_d3d_state(void)
829 {
830 IDirectDrawSurface7 *rt, *surface;
831 IDirect3DDevice7 *device;
832 IDirectDraw7 *ddraw;
833 IDirect3D7 *d3d;
834 D3DCOLOR color;
835 DWORD value;
836 HWND window;
837 HRESULT hr;
838
839 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
840 0, 0, 640, 480, 0, 0, 0, 0);
841 if (!(device = create_device(window, DDSCL_NORMAL)))
842 {
843 skip("Failed to create D3D device, skipping test.\n");
844 DestroyWindow(window);
845 return;
846 }
847
848 hr = IDirect3DDevice7_GetRenderTarget(device, &rt);
849 ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
850 hr = IDirect3DDevice7_GetRenderState(device, D3DRENDERSTATE_ZENABLE, &value);
851 ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr);
852 ok(!!value, "Got unexpected z-enable state %#x.\n", value);
853 hr = IDirect3DDevice7_GetRenderState(device, D3DRENDERSTATE_ALPHABLENDENABLE, &value);
854 ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr);
855 ok(!value, "Got unexpected alpha blend enable state %#x.\n", value);
856 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ALPHABLENDENABLE, TRUE);
857 ok(SUCCEEDED(hr), "Failed to set render state, hr %#x.\n", hr);
858 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0f, 0);
859 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
860 color = get_surface_color(rt, 320, 240);
861 ok(compare_color(color, 0x00ff0000, 1), "Got unexpected color 0x%08x.\n", color);
862
863 hr = IDirect3DDevice7_GetDirect3D(device, &d3d);
864 ok(SUCCEEDED(hr), "Failed to get d3d interface, hr %#x.\n", hr);
865 hr = IDirect3D7_QueryInterface(d3d, &IID_IDirectDraw7, (void **)&ddraw);
866 ok(SUCCEEDED(hr), "Failed to get ddraw interface, hr %#x.\n", hr);
867 IDirect3D7_Release(d3d);
868 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
869 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
870 hr = IDirectDrawSurface7_IsLost(rt);
871 ok(hr == DDERR_SURFACELOST, "Got unexpected hr %#x.\n", hr);
872 hr = IDirectDraw7_RestoreAllSurfaces(ddraw);
873 ok(SUCCEEDED(hr), "Failed to restore surfaces, hr %#x.\n", hr);
874 IDirectDraw7_Release(ddraw);
875
876 hr = IDirect3DDevice7_GetRenderTarget(device, &surface);
877 ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
878 ok(surface == rt, "Got unexpected surface %p.\n", surface);
879 hr = IDirect3DDevice7_GetRenderState(device, D3DRENDERSTATE_ZENABLE, &value);
880 ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr);
881 ok(!!value, "Got unexpected z-enable state %#x.\n", value);
882 hr = IDirect3DDevice7_GetRenderState(device, D3DRENDERSTATE_ALPHABLENDENABLE, &value);
883 ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr);
884 ok(!!value, "Got unexpected alpha blend enable state %#x.\n", value);
885 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0f, 0);
886 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
887 color = get_surface_color(rt, 320, 240);
888 ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x.\n", color);
889
890 IDirectDrawSurface7_Release(surface);
891 IDirectDrawSurface7_Release(rt);
892 IDirect3DDevice7_Release(device);
893 DestroyWindow(window);
894 }
895
896 static void test_surface_interface_mismatch(void)
897 {
898 IDirectDraw7 *ddraw = NULL;
899 IDirect3D7 *d3d = NULL;
900 IDirectDrawSurface7 *surface = NULL, *ds;
901 IDirectDrawSurface3 *surface3 = NULL;
902 IDirect3DDevice7 *device = NULL;
903 DDSURFACEDESC2 surface_desc;
904 DDPIXELFORMAT z_fmt;
905 ULONG refcount;
906 HRESULT hr;
907 D3DCOLOR color;
908 HWND window;
909
910 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
911 0, 0, 640, 480, 0, 0, 0, 0);
912
913 if (!(ddraw = create_ddraw()))
914 {
915 skip("Failed to create a ddraw object, skipping test.\n");
916 goto cleanup;
917 }
918
919 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
920 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
921
922 memset(&surface_desc, 0, sizeof(surface_desc));
923 surface_desc.dwSize = sizeof(surface_desc);
924 surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
925 surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
926 surface_desc.dwWidth = 640;
927 surface_desc.dwHeight = 480;
928
929 hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &surface, NULL);
930 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
931
932 hr = IDirectDrawSurface7_QueryInterface(surface, &IID_IDirectDrawSurface3, (void **)&surface3);
933 ok(SUCCEEDED(hr), "Failed to QI IDirectDrawSurface3, hr %#x.\n", hr);
934
935 hr = IDirectDraw7_QueryInterface(ddraw, &IID_IDirect3D7, (void **)&d3d);
936 if (FAILED(hr))
937 {
938 skip("Failed to get the IDirect3D7 interface, skipping test.\n");
939 goto cleanup;
940 }
941
942 memset(&z_fmt, 0, sizeof(z_fmt));
943 hr = IDirect3D7_EnumZBufferFormats(d3d, &IID_IDirect3DHALDevice, enum_z_fmt, &z_fmt);
944 if (FAILED(hr) || !z_fmt.dwSize)
945 {
946 skip("No depth buffer formats available, skipping test.\n");
947 goto cleanup;
948 }
949
950 memset(&surface_desc, 0, sizeof(surface_desc));
951 surface_desc.dwSize = sizeof(surface_desc);
952 surface_desc.dwFlags = DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT;
953 surface_desc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
954 U4(surface_desc).ddpfPixelFormat = z_fmt;
955 surface_desc.dwWidth = 640;
956 surface_desc.dwHeight = 480;
957 hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &ds, NULL);
958 ok(SUCCEEDED(hr), "Failed to create depth buffer, hr %#x.\n", hr);
959 if (FAILED(hr))
960 goto cleanup;
961
962 /* Using a different surface interface version still works */
963 hr = IDirectDrawSurface3_AddAttachedSurface(surface3, (IDirectDrawSurface3 *)ds);
964 ok(SUCCEEDED(hr), "Failed to attach depth buffer, hr %#x.\n", hr);
965 refcount = IDirectDrawSurface7_Release(ds);
966 ok(refcount == 1, "Got unexpected refcount %u.\n", refcount);
967 if (FAILED(hr))
968 goto cleanup;
969
970 /* Here too */
971 hr = IDirect3D7_CreateDevice(d3d, &IID_IDirect3DHALDevice, (IDirectDrawSurface7 *)surface3, &device);
972 ok(SUCCEEDED(hr), "Failed to create d3d device.\n");
973 if (FAILED(hr))
974 goto cleanup;
975
976 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0f, 0);
977 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
978 color = get_surface_color(surface, 320, 240);
979 ok(compare_color(color, 0x00ff0000, 1), "Got unexpected color 0x%08x.\n", color);
980
981 cleanup:
982 if (surface3) IDirectDrawSurface3_Release(surface3);
983 if (surface) IDirectDrawSurface7_Release(surface);
984 if (device) IDirect3DDevice7_Release(device);
985 if (d3d) IDirect3D7_Release(d3d);
986 if (ddraw) IDirectDraw7_Release(ddraw);
987 DestroyWindow(window);
988 }
989
990 static void test_coop_level_threaded(void)
991 {
992 struct create_window_thread_param p;
993 IDirectDraw7 *ddraw;
994 HRESULT hr;
995
996 if (!(ddraw = create_ddraw()))
997 {
998 skip("Failed to create a ddraw object, skipping test.\n");
999 return;
1000 }
1001 create_window_thread(&p);
1002
1003 hr = IDirectDraw7_SetCooperativeLevel(ddraw, p.window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
1004 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
1005
1006 IDirectDraw7_Release(ddraw);
1007 destroy_window_thread(&p);
1008 }
1009
1010 static void test_depth_blit(void)
1011 {
1012 IDirect3DDevice7 *device;
1013 static struct
1014 {
1015 float x, y, z;
1016 DWORD color;
1017 }
1018 quad1[] =
1019 {
1020 { -1.0, 1.0, 0.50f, 0xff00ff00},
1021 { 1.0, 1.0, 0.50f, 0xff00ff00},
1022 { -1.0, -1.0, 0.50f, 0xff00ff00},
1023 { 1.0, -1.0, 0.50f, 0xff00ff00},
1024 };
1025 static const D3DCOLOR expected_colors[4][4] =
1026 {
1027 {0x00ff0000, 0x00ff0000, 0x0000ff00, 0x0000ff00},
1028 {0x00ff0000, 0x00ff0000, 0x0000ff00, 0x0000ff00},
1029 {0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00},
1030 {0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00},
1031 };
1032 DDSURFACEDESC2 ddsd_new, ddsd_existing;
1033
1034 IDirectDrawSurface7 *ds1, *ds2, *ds3, *rt;
1035 RECT src_rect, dst_rect;
1036 unsigned int i, j;
1037 D3DCOLOR color;
1038 HRESULT hr;
1039 IDirect3D7 *d3d;
1040 IDirectDraw7 *ddraw;
1041 DDBLTFX fx;
1042 HWND window;
1043
1044 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1045 0, 0, 640, 480, 0, 0, 0, 0);
1046 if (!(device = create_device(window, DDSCL_NORMAL)))
1047 {
1048 skip("Failed to create D3D device, skipping test.\n");
1049 DestroyWindow(window);
1050 return;
1051 }
1052
1053 hr = IDirect3DDevice7_GetDirect3D(device, &d3d);
1054 ok(SUCCEEDED(hr), "Failed to get Direct3D7 interface, hr %#x.\n", hr);
1055 hr = IDirect3D7_QueryInterface(d3d, &IID_IDirectDraw7, (void **)&ddraw);
1056 ok(SUCCEEDED(hr), "Failed to get DirectDraw7 interface, hr %#x.\n", hr);
1057 IDirect3D7_Release(d3d);
1058
1059 ds1 = get_depth_stencil(device);
1060
1061 memset(&ddsd_new, 0, sizeof(ddsd_new));
1062 ddsd_new.dwSize = sizeof(ddsd_new);
1063 memset(&ddsd_existing, 0, sizeof(ddsd_existing));
1064 ddsd_existing.dwSize = sizeof(ddsd_existing);
1065 hr = IDirectDrawSurface7_GetSurfaceDesc(ds1, &ddsd_existing);
1066 ddsd_new.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
1067 ddsd_new.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
1068 ddsd_new.dwWidth = ddsd_existing.dwWidth;
1069 ddsd_new.dwHeight = ddsd_existing.dwHeight;
1070 U4(ddsd_new).ddpfPixelFormat = U4(ddsd_existing).ddpfPixelFormat;
1071 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd_new, &ds2, NULL);
1072 ok(SUCCEEDED(hr), "Failed to create a z buffer, hr %#x.\n", hr);
1073 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd_new, &ds3, NULL);
1074 ok(SUCCEEDED(hr), "Failed to create a z buffer, hr %#x.\n", hr);
1075 IDirectDraw7_Release(ddraw);
1076
1077 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ZENABLE, D3DZB_TRUE);
1078 ok(SUCCEEDED(hr), "Failed to enable z testing, hr %#x.\n", hr);
1079 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ZFUNC, D3DCMP_LESSEQUAL);
1080 ok(SUCCEEDED(hr), "Failed to set the z function, hr %#x.\n", hr);
1081 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE);
1082 ok(SUCCEEDED(hr), "Failed to disable lighting, hr %#x.\n", hr);
1083
1084 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_ZBUFFER, 0, 0.0f, 0);
1085 ok(SUCCEEDED(hr), "Failed to clear the z buffer, hr %#x.\n", hr);
1086
1087 /* Partial blit. */
1088 SetRect(&src_rect, 0, 0, 320, 240);
1089 SetRect(&dst_rect, 0, 0, 320, 240);
1090 hr = IDirectDrawSurface7_Blt(ds2, &dst_rect, ds1, &src_rect, DDBLT_WAIT, NULL);
1091 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1092 /* Different locations. */
1093 SetRect(&src_rect, 0, 0, 320, 240);
1094 SetRect(&dst_rect, 320, 240, 640, 480);
1095 hr = IDirectDrawSurface7_Blt(ds2, &dst_rect, ds1, &src_rect, DDBLT_WAIT, NULL);
1096 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1097 /* Streched. */
1098 SetRect(&src_rect, 0, 0, 320, 240);
1099 SetRect(&dst_rect, 0, 0, 640, 480);
1100 hr = IDirectDrawSurface7_Blt(ds2, &dst_rect, ds1, &src_rect, DDBLT_WAIT, NULL);
1101 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1102 /* Flipped. */
1103 SetRect(&src_rect, 0, 480, 640, 0);
1104 SetRect(&dst_rect, 0, 0, 640, 480);
1105 hr = IDirectDrawSurface7_Blt(ds2, &dst_rect, ds1, &src_rect, DDBLT_WAIT, NULL);
1106 ok(hr == DDERR_INVALIDRECT, "Got unexpected hr %#x.\n", hr);
1107 SetRect(&src_rect, 0, 0, 640, 480);
1108 SetRect(&dst_rect, 0, 480, 640, 0);
1109 hr = IDirectDrawSurface7_Blt(ds2, &dst_rect, ds1, &src_rect, DDBLT_WAIT, NULL);
1110 ok(hr == DDERR_INVALIDRECT, "Got unexpected hr %#x.\n", hr);
1111 /* Full, explicit. */
1112 SetRect(&src_rect, 0, 0, 640, 480);
1113 SetRect(&dst_rect, 0, 0, 640, 480);
1114 hr = IDirectDrawSurface7_Blt(ds2, &dst_rect, ds1, &src_rect, DDBLT_WAIT, NULL);
1115 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1116 /* Depth -> color blit: Succeeds on Win7 + Radeon HD 5700, fails on WinXP + Radeon X1600 */
1117
1118 /* Depth blit inside a BeginScene / EndScene pair */
1119 hr = IDirect3DDevice7_BeginScene(device);
1120 ok(SUCCEEDED(hr), "Failed to start scene, hr %#x.\n", hr);
1121 /* From the current depth stencil */
1122 hr = IDirectDrawSurface7_Blt(ds2, NULL, ds1, NULL, DDBLT_WAIT, NULL);
1123 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1124 /* To the current depth stencil */
1125 hr = IDirectDrawSurface7_Blt(ds1, NULL, ds2, NULL, DDBLT_WAIT, NULL);
1126 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1127 /* Between unbound surfaces */
1128 hr = IDirectDrawSurface7_Blt(ds3, NULL, ds2, NULL, DDBLT_WAIT, NULL);
1129 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1130 hr = IDirect3DDevice7_EndScene(device);
1131 ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
1132
1133 /* Avoid changing the depth stencil, it doesn't work properly on Windows.
1134 * Instead use DDBLT_DEPTHFILL to clear the depth stencil. Unfortunately
1135 * drivers disagree on the meaning of dwFillDepth. Only 0 seems to produce
1136 * a reliable result(z = 0.0) */
1137 memset(&fx, 0, sizeof(fx));
1138 fx.dwSize = sizeof(fx);
1139 hr = IDirectDrawSurface7_Blt(ds2, NULL, NULL, NULL, DDBLT_DEPTHFILL | DDBLT_WAIT, &fx);
1140 ok(SUCCEEDED(hr), "Failed to clear the source z buffer, hr %#x.\n", hr);
1141
1142 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_ZBUFFER | D3DCLEAR_TARGET, 0xffff0000, 1.0f, 0);
1143 ok(SUCCEEDED(hr), "Failed to clear the color and z buffers, hr %#x.\n", hr);
1144 SetRect(&dst_rect, 0, 0, 320, 240);
1145 hr = IDirectDrawSurface7_Blt(ds1, &dst_rect, ds2, NULL, DDBLT_WAIT, NULL);
1146 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1147 IDirectDrawSurface7_Release(ds3);
1148 IDirectDrawSurface7_Release(ds2);
1149 IDirectDrawSurface7_Release(ds1);
1150
1151 hr = IDirect3DDevice7_BeginScene(device);
1152 ok(SUCCEEDED(hr), "Failed to start scene, hr %#x.\n", hr);
1153 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_DIFFUSE,
1154 quad1, 4, 0);
1155 ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
1156 hr = IDirect3DDevice7_EndScene(device);
1157 ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
1158
1159 hr = IDirect3DDevice7_GetRenderTarget(device, &rt);
1160 ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
1161 for (i = 0; i < 4; ++i)
1162 {
1163 for (j = 0; j < 4; ++j)
1164 {
1165 unsigned int x = 80 * ((2 * j) + 1);
1166 unsigned int y = 60 * ((2 * i) + 1);
1167 color = get_surface_color(rt, x, y);
1168 ok(compare_color(color, expected_colors[i][j], 1),
1169 "Expected color 0x%08x at %u,%u, got 0x%08x.\n", expected_colors[i][j], x, y, color);
1170 }
1171 }
1172
1173 IDirectDrawSurface7_Release(rt);
1174 IDirect3DDevice7_Release(device);
1175 DestroyWindow(window);
1176 }
1177
1178 static void test_texture_load_ckey(void)
1179 {
1180 HWND window;
1181 IDirect3DDevice7 *device;
1182 IDirectDraw7 *ddraw;
1183 IDirectDrawSurface7 *src;
1184 IDirectDrawSurface7 *dst;
1185 DDSURFACEDESC2 ddsd;
1186 HRESULT hr;
1187 DDCOLORKEY ckey;
1188 IDirect3D7 *d3d;
1189
1190 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1191 0, 0, 640, 480, 0, 0, 0, 0);
1192 if (!(device = create_device(window, DDSCL_NORMAL)))
1193 {
1194 skip("Failed to create D3D device, skipping test.\n");
1195 DestroyWindow(window);
1196 return;
1197 }
1198
1199 hr = IDirect3DDevice7_GetDirect3D(device, &d3d);
1200 ok(SUCCEEDED(hr), "Failed to get Direct3D7 interface, hr %#x.\n", hr);
1201 hr = IDirect3D7_QueryInterface(d3d, &IID_IDirectDraw7, (void **)&ddraw);
1202 ok(SUCCEEDED(hr), "Failed to get DirectDraw7 interface, hr %#x.\n", hr);
1203 IDirect3D7_Release(d3d);
1204
1205 memset(&ddsd, 0, sizeof(ddsd));
1206 ddsd.dwSize = sizeof(ddsd);
1207 ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
1208 ddsd.dwHeight = 128;
1209 ddsd.dwWidth = 128;
1210 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_SYSTEMMEMORY;
1211 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &src, NULL);
1212 ok(SUCCEEDED(hr), "Failed to create source texture, hr %#x.\n", hr);
1213 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1214 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &dst, NULL);
1215 ok(SUCCEEDED(hr), "Failed to create destination texture, hr %#x.\n", hr);
1216
1217 /* No surface has a color key */
1218 hr = IDirect3DDevice7_Load(device, dst, NULL, src, NULL, 0);
1219 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1220 ckey.dwColorSpaceLowValue = ckey.dwColorSpaceHighValue = 0xdeadbeef;
1221 hr = IDirectDrawSurface7_GetColorKey(dst, DDCKEY_SRCBLT, &ckey);
1222 ok(hr == DDERR_NOCOLORKEY, "Got unexpected hr %#x.\n", hr);
1223 ok(ckey.dwColorSpaceLowValue == 0xdeadbeef, "dwColorSpaceLowValue is %#x.\n", ckey.dwColorSpaceLowValue);
1224 ok(ckey.dwColorSpaceHighValue == 0xdeadbeef, "dwColorSpaceHighValue is %#x.\n", ckey.dwColorSpaceHighValue);
1225
1226 /* Source surface has a color key */
1227 ckey.dwColorSpaceLowValue = ckey.dwColorSpaceHighValue = 0x0000ff00;
1228 hr = IDirectDrawSurface7_SetColorKey(src, DDCKEY_SRCBLT, &ckey);
1229 ok(SUCCEEDED(hr), "Failed to set color key, hr %#x.\n", hr);
1230 hr = IDirect3DDevice7_Load(device, dst, NULL, src, NULL, 0);
1231 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1232 hr = IDirectDrawSurface7_GetColorKey(dst, DDCKEY_SRCBLT, &ckey);
1233 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1234 ok(ckey.dwColorSpaceLowValue == 0x0000ff00, "dwColorSpaceLowValue is %#x.\n", ckey.dwColorSpaceLowValue);
1235 ok(ckey.dwColorSpaceHighValue == 0x0000ff00, "dwColorSpaceHighValue is %#x.\n", ckey.dwColorSpaceHighValue);
1236
1237 /* Both surfaces have a color key: Dest ckey is overwritten */
1238 ckey.dwColorSpaceLowValue = ckey.dwColorSpaceHighValue = 0x000000ff;
1239 hr = IDirectDrawSurface7_SetColorKey(dst, DDCKEY_SRCBLT, &ckey);
1240 ok(SUCCEEDED(hr), "Failed to set color key, hr %#x.\n", hr);
1241 hr = IDirect3DDevice7_Load(device, dst, NULL, src, NULL, 0);
1242 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1243 hr = IDirectDrawSurface7_GetColorKey(dst, DDCKEY_SRCBLT, &ckey);
1244 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1245 ok(ckey.dwColorSpaceLowValue == 0x0000ff00, "dwColorSpaceLowValue is %#x.\n", ckey.dwColorSpaceLowValue);
1246 ok(ckey.dwColorSpaceHighValue == 0x0000ff00, "dwColorSpaceHighValue is %#x.\n", ckey.dwColorSpaceHighValue);
1247
1248 /* Only the destination has a color key: It is deleted. This behavior differs from
1249 * IDirect3DTexture(2)::Load */
1250 hr = IDirectDrawSurface7_SetColorKey(src, DDCKEY_SRCBLT, NULL);
1251 ok(SUCCEEDED(hr), "Failed to set color key, hr %#x.\n", hr);
1252 hr = IDirectDrawSurface7_GetColorKey(src, DDCKEY_SRCBLT, &ckey);
1253 ok(hr == DDERR_NOCOLORKEY, "Got unexpected hr %#x.\n", hr);
1254 hr = IDirect3DDevice7_Load(device, dst, NULL, src, NULL, 0);
1255 ok(SUCCEEDED(hr), "Got unexpected hr %#x.\n", hr);
1256 hr = IDirectDrawSurface7_GetColorKey(dst, DDCKEY_SRCBLT, &ckey);
1257 todo_wine ok(hr == DDERR_NOCOLORKEY, "Got unexpected hr %#x.\n", hr);
1258
1259 IDirectDrawSurface7_Release(dst);
1260 IDirectDrawSurface7_Release(src);
1261 IDirectDraw7_Release(ddraw);
1262 IDirect3DDevice7_Release(device);
1263 }
1264
1265 static void test_zenable(void)
1266 {
1267 static struct
1268 {
1269 struct vec4 position;
1270 D3DCOLOR diffuse;
1271 }
1272 tquad[] =
1273 {
1274 {{ 0.0f, 480.0f, -0.5f, 1.0f}, 0xff00ff00},
1275 {{ 0.0f, 0.0f, -0.5f, 1.0f}, 0xff00ff00},
1276 {{640.0f, 480.0f, 1.5f, 1.0f}, 0xff00ff00},
1277 {{640.0f, 0.0f, 1.5f, 1.0f}, 0xff00ff00},
1278 };
1279 IDirect3DDevice7 *device;
1280 IDirectDrawSurface7 *rt;
1281 D3DCOLOR color;
1282 HWND window;
1283 HRESULT hr;
1284 UINT x, y;
1285 UINT i, j;
1286
1287 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1288 0, 0, 640, 480, 0, 0, 0, 0);
1289 if (!(device = create_device(window, DDSCL_NORMAL)))
1290 {
1291 skip("Failed to create D3D device, skipping test.\n");
1292 DestroyWindow(window);
1293 return;
1294 }
1295
1296 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ZENABLE, D3DZB_FALSE);
1297 ok(SUCCEEDED(hr), "Failed to disable z-buffering, hr %#x.\n", hr);
1298
1299 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffff0000, 0.0f, 0);
1300 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
1301 hr = IDirect3DDevice7_BeginScene(device);
1302 ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
1303 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_DIFFUSE, tquad, 4, 0);
1304 ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
1305 hr = IDirect3DDevice7_EndScene(device);
1306 ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
1307
1308 hr = IDirect3DDevice7_GetRenderTarget(device, &rt);
1309 ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
1310 for (i = 0; i < 4; ++i)
1311 {
1312 for (j = 0; j < 4; ++j)
1313 {
1314 x = 80 * ((2 * j) + 1);
1315 y = 60 * ((2 * i) + 1);
1316 color = get_surface_color(rt, x, y);
1317 ok(compare_color(color, 0x0000ff00, 1),
1318 "Expected color 0x0000ff00 at %u, %u, got 0x%08x.\n", x, y, color);
1319 }
1320 }
1321 IDirectDrawSurface7_Release(rt);
1322
1323 IDirect3DDevice7_Release(device);
1324 DestroyWindow(window);
1325 }
1326
1327 static void test_ck_rgba(void)
1328 {
1329 static struct
1330 {
1331 struct vec4 position;
1332 struct vec2 texcoord;
1333 }
1334 tquad[] =
1335 {
1336 {{ 0.0f, 480.0f, 0.25f, 1.0f}, {0.0f, 0.0f}},
1337 {{ 0.0f, 0.0f, 0.25f, 1.0f}, {0.0f, 1.0f}},
1338 {{640.0f, 480.0f, 0.25f, 1.0f}, {1.0f, 0.0f}},
1339 {{640.0f, 0.0f, 0.25f, 1.0f}, {1.0f, 1.0f}},
1340 {{ 0.0f, 480.0f, 0.75f, 1.0f}, {0.0f, 0.0f}},
1341 {{ 0.0f, 0.0f, 0.75f, 1.0f}, {0.0f, 1.0f}},
1342 {{640.0f, 480.0f, 0.75f, 1.0f}, {1.0f, 0.0f}},
1343 {{640.0f, 0.0f, 0.75f, 1.0f}, {1.0f, 1.0f}},
1344 };
1345 static const struct
1346 {
1347 D3DCOLOR fill_color;
1348 BOOL color_key;
1349 BOOL blend;
1350 D3DCOLOR result1;
1351 D3DCOLOR result2;
1352 }
1353 tests[] =
1354 {
1355 {0xff00ff00, TRUE, TRUE, 0x00ff0000, 0x000000ff},
1356 {0xff00ff00, TRUE, FALSE, 0x00ff0000, 0x000000ff},
1357 {0xff00ff00, FALSE, TRUE, 0x0000ff00, 0x0000ff00},
1358 {0xff00ff00, FALSE, FALSE, 0x0000ff00, 0x0000ff00},
1359 {0x7f00ff00, TRUE, TRUE, 0x00807f00, 0x00807f00},
1360 {0x7f00ff00, TRUE, FALSE, 0x0000ff00, 0x0000ff00},
1361 {0x7f00ff00, FALSE, TRUE, 0x00807f00, 0x00807f00},
1362 {0x7f00ff00, FALSE, FALSE, 0x0000ff00, 0x0000ff00},
1363 };
1364
1365 IDirectDrawSurface7 *texture;
1366 DDSURFACEDESC2 surface_desc;
1367 IDirect3DDevice7 *device;
1368 IDirectDrawSurface7 *rt;
1369 IDirectDraw7 *ddraw;
1370 IDirect3D7 *d3d;
1371 D3DCOLOR color;
1372 HWND window;
1373 DDBLTFX fx;
1374 HRESULT hr;
1375 UINT i;
1376
1377 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1378 0, 0, 640, 480, 0, 0, 0, 0);
1379 if (!(device = create_device(window, DDSCL_NORMAL)))
1380 {
1381 skip("Failed to create D3D device, skipping test.\n");
1382 DestroyWindow(window);
1383 return;
1384 }
1385
1386 hr = IDirect3DDevice7_GetDirect3D(device, &d3d);
1387 ok(SUCCEEDED(hr), "Failed to get d3d interface, hr %#x.\n", hr);
1388 hr = IDirect3D7_QueryInterface(d3d, &IID_IDirectDraw7, (void **)&ddraw);
1389 ok(SUCCEEDED(hr), "Failed to get ddraw interface, hr %#x.\n", hr);
1390 IDirect3D7_Release(d3d);
1391
1392 memset(&surface_desc, 0, sizeof(surface_desc));
1393 surface_desc.dwSize = sizeof(surface_desc);
1394 surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CKSRCBLT;
1395 surface_desc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1396 surface_desc.dwWidth = 256;
1397 surface_desc.dwHeight = 256;
1398 U4(surface_desc).ddpfPixelFormat.dwSize = sizeof(U4(surface_desc).ddpfPixelFormat);
1399 U4(surface_desc).ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
1400 U1(U4(surface_desc).ddpfPixelFormat).dwRGBBitCount = 32;
1401 U2(U4(surface_desc).ddpfPixelFormat).dwRBitMask = 0x00ff0000;
1402 U3(U4(surface_desc).ddpfPixelFormat).dwGBitMask = 0x0000ff00;
1403 U4(U4(surface_desc).ddpfPixelFormat).dwBBitMask = 0x000000ff;
1404 U5(U4(surface_desc).ddpfPixelFormat).dwRGBAlphaBitMask = 0xff000000;
1405 surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue = 0xff00ff00;
1406 surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue = 0xff00ff00;
1407 hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &texture, NULL);
1408 ok(SUCCEEDED(hr), "Failed to create destination surface, hr %#x.\n", hr);
1409
1410 hr = IDirect3DDevice7_SetTexture(device, 0, texture);
1411 ok(SUCCEEDED(hr), "Failed to set texture, hr %#x.\n", hr);
1412 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_SRCBLEND, D3DBLEND_SRCALPHA);
1413 ok(SUCCEEDED(hr), "Failed to enable alpha blending, hr %#x.\n", hr);
1414 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA);
1415 ok(SUCCEEDED(hr), "Failed to enable alpha blending, hr %#x.\n", hr);
1416
1417 hr = IDirect3DDevice7_GetRenderTarget(device, &rt);
1418 ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
1419
1420 for (i = 0; i < sizeof(tests) / sizeof(*tests); ++i)
1421 {
1422 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, tests[i].color_key);
1423 ok(SUCCEEDED(hr), "Failed to enable color keying, hr %#x.\n", hr);
1424 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ALPHABLENDENABLE, tests[i].blend);
1425 ok(SUCCEEDED(hr), "Failed to enable alpha blending, hr %#x.\n", hr);
1426
1427 memset(&fx, 0, sizeof(fx));
1428 fx.dwSize = sizeof(fx);
1429 U5(fx).dwFillColor = tests[i].fill_color;
1430 hr = IDirectDrawSurface7_Blt(texture, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
1431 ok(SUCCEEDED(hr), "Failed to fill texture, hr %#x.\n", hr);
1432
1433 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffff0000, 1.0f, 0);
1434 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
1435 hr = IDirect3DDevice7_BeginScene(device);
1436 ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
1437 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_TEX1, &tquad[0], 4, 0);
1438 ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
1439 hr = IDirect3DDevice7_EndScene(device);
1440 ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
1441
1442 color = get_surface_color(rt, 320, 240);
1443 if (i == 2)
1444 todo_wine ok(compare_color(color, tests[i].result1, 1), "Expected color 0x%08x for test %u, got 0x%08x.\n",
1445 tests[i].result1, i, color);
1446 else
1447 ok(compare_color(color, tests[i].result1, 1), "Expected color 0x%08x for test %u, got 0x%08x.\n",
1448 tests[i].result1, i, color);
1449
1450 U5(fx).dwFillColor = 0xff0000ff;
1451 hr = IDirectDrawSurface7_Blt(texture, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
1452 ok(SUCCEEDED(hr), "Failed to fill texture, hr %#x.\n", hr);
1453
1454 hr = IDirect3DDevice7_BeginScene(device);
1455 ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
1456 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_TEX1, &tquad[4], 4, 0);
1457 ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
1458 hr = IDirect3DDevice7_EndScene(device);
1459 ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
1460
1461 /* This tests that fragments that are masked out by the color key are
1462 * discarded, instead of just fully transparent. */
1463 color = get_surface_color(rt, 320, 240);
1464 if (i == 2)
1465 todo_wine ok(compare_color(color, tests[i].result2, 1), "Expected color 0x%08x for test %u, got 0x%08x.\n",
1466 tests[i].result2, i, color);
1467 else
1468 ok(compare_color(color, tests[i].result2, 1), "Expected color 0x%08x for test %u, got 0x%08x.\n",
1469 tests[i].result2, i, color);
1470 }
1471
1472 IDirectDrawSurface7_Release(rt);
1473 IDirectDrawSurface7_Release(texture);
1474 IDirectDraw7_Release(ddraw);
1475 IDirect3DDevice7_Release(device);
1476 DestroyWindow(window);
1477 }
1478
1479 static void test_ck_default(void)
1480 {
1481 static struct
1482 {
1483 struct vec4 position;
1484 struct vec2 texcoord;
1485 }
1486 tquad[] =
1487 {
1488 {{ 0.0f, 480.0f, 0.0f, 1.0f}, {0.0f, 0.0f}},
1489 {{ 0.0f, 0.0f, 0.0f, 1.0f}, {0.0f, 1.0f}},
1490 {{640.0f, 480.0f, 0.0f, 1.0f}, {1.0f, 0.0f}},
1491 {{640.0f, 0.0f, 0.0f, 1.0f}, {1.0f, 1.0f}},
1492 };
1493 IDirectDrawSurface7 *surface, *rt;
1494 DDSURFACEDESC2 surface_desc;
1495 IDirect3DDevice7 *device;
1496 IDirectDraw7 *ddraw;
1497 IDirect3D7 *d3d;
1498 D3DCOLOR color;
1499 DWORD value;
1500 HWND window;
1501 DDBLTFX fx;
1502 HRESULT hr;
1503
1504 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1505 0, 0, 640, 480, 0, 0, 0, 0);
1506
1507 if (!(device = create_device(window, DDSCL_NORMAL)))
1508 {
1509 skip("Failed to create D3D device, skipping test.\n");
1510 DestroyWindow(window);
1511 return;
1512 }
1513
1514 hr = IDirect3DDevice7_GetDirect3D(device, &d3d);
1515 ok(SUCCEEDED(hr), "Failed to get d3d interface, hr %#x.\n", hr);
1516 hr = IDirect3D7_QueryInterface(d3d, &IID_IDirectDraw7, (void **)&ddraw);
1517 ok(SUCCEEDED(hr), "Failed to get ddraw interface, hr %#x.\n", hr);
1518 IDirect3D7_Release(d3d);
1519
1520 hr = IDirect3DDevice7_GetRenderTarget(device, &rt);
1521 ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
1522
1523 memset(&surface_desc, 0, sizeof(surface_desc));
1524 surface_desc.dwSize = sizeof(surface_desc);
1525 surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CKSRCBLT;
1526 surface_desc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1527 surface_desc.dwWidth = 256;
1528 surface_desc.dwHeight = 256;
1529 U4(surface_desc).ddpfPixelFormat.dwSize = sizeof(U4(surface_desc).ddpfPixelFormat);
1530 U4(surface_desc).ddpfPixelFormat.dwFlags = DDPF_RGB;
1531 U1(U4(surface_desc).ddpfPixelFormat).dwRGBBitCount = 32;
1532 U2(U4(surface_desc).ddpfPixelFormat).dwRBitMask = 0x00ff0000;
1533 U3(U4(surface_desc).ddpfPixelFormat).dwGBitMask = 0x0000ff00;
1534 U4(U4(surface_desc).ddpfPixelFormat).dwBBitMask = 0x000000ff;
1535 surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue = 0x000000ff;
1536 surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue = 0x000000ff;
1537 hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &surface, NULL);
1538 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
1539 hr = IDirect3DDevice7_SetTexture(device, 0, surface);
1540 ok(SUCCEEDED(hr), "Failed to set texture, hr %#x.\n", hr);
1541
1542 memset(&fx, 0, sizeof(fx));
1543 fx.dwSize = sizeof(fx);
1544 U5(fx).dwFillColor = 0x000000ff;
1545 hr = IDirectDrawSurface7_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
1546 ok(SUCCEEDED(hr), "Failed to fill surface, hr %#x.\n", hr);
1547
1548 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 1.0f, 0);
1549 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
1550 hr = IDirect3DDevice7_BeginScene(device);
1551 ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
1552 hr = IDirect3DDevice7_GetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, &value);
1553 ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr);
1554 ok(!value, "Got unexpected color keying state %#x.\n", value);
1555 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_TEX1, &tquad[0], 4, 0);
1556 ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
1557 hr = IDirect3DDevice7_EndScene(device);
1558 ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
1559 color = get_surface_color(rt, 320, 240);
1560 ok(compare_color(color, 0x000000ff, 1), "Got unexpected color 0x%08x.\n", color);
1561
1562 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 1.0f, 0);
1563 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
1564 hr = IDirect3DDevice7_BeginScene(device);
1565 ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
1566 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, TRUE);
1567 ok(SUCCEEDED(hr), "Failed to enable color keying, hr %#x.\n", hr);
1568 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_TEX1, &tquad[0], 4, 0);
1569 ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
1570 hr = IDirect3DDevice7_GetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, &value);
1571 ok(SUCCEEDED(hr), "Failed to get render state, hr %#x.\n", hr);
1572 ok(!!value, "Got unexpected color keying state %#x.\n", value);
1573 hr = IDirect3DDevice7_EndScene(device);
1574 ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
1575 color = get_surface_color(rt, 320, 240);
1576 ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x.\n", color);
1577
1578 IDirectDrawSurface7_Release(surface);
1579 IDirectDrawSurface7_Release(rt);
1580 IDirect3DDevice7_Release(device);
1581 IDirectDraw7_Release(ddraw);
1582 DestroyWindow(window);
1583 }
1584
1585 struct qi_test
1586 {
1587 REFIID iid;
1588 REFIID refcount_iid;
1589 HRESULT hr;
1590 };
1591
1592 static void test_qi(const char *test_name, IUnknown *base_iface,
1593 REFIID refcount_iid, const struct qi_test *tests, UINT entry_count)
1594 {
1595 ULONG refcount, expected_refcount;
1596 IUnknown *iface1, *iface2;
1597 HRESULT hr;
1598 UINT i, j;
1599
1600 for (i = 0; i < entry_count; ++i)
1601 {
1602 hr = IUnknown_QueryInterface(base_iface, tests[i].iid, (void **)&iface1);
1603 ok(hr == tests[i].hr, "Got hr %#x for test \"%s\" %u.\n", hr, test_name, i);
1604 if (SUCCEEDED(hr))
1605 {
1606 for (j = 0; j < entry_count; ++j)
1607 {
1608 hr = IUnknown_QueryInterface(iface1, tests[j].iid, (void **)&iface2);
1609 ok(hr == tests[j].hr, "Got hr %#x for test \"%s\" %u, %u.\n", hr, test_name, i, j);
1610 if (SUCCEEDED(hr))
1611 {
1612 expected_refcount = 0;
1613 if (IsEqualGUID(refcount_iid, tests[j].refcount_iid))
1614 ++expected_refcount;
1615 if (IsEqualGUID(tests[i].refcount_iid, tests[j].refcount_iid))
1616 ++expected_refcount;
1617 refcount = IUnknown_Release(iface2);
1618 ok(refcount == expected_refcount, "Got refcount %u for test \"%s\" %u, %u, expected %u.\n",
1619 refcount, test_name, i, j, expected_refcount);
1620 }
1621 }
1622
1623 expected_refcount = 0;
1624 if (IsEqualGUID(refcount_iid, tests[i].refcount_iid))
1625 ++expected_refcount;
1626 refcount = IUnknown_Release(iface1);
1627 ok(refcount == expected_refcount, "Got refcount %u for test \"%s\" %u, expected %u.\n",
1628 refcount, test_name, i, expected_refcount);
1629 }
1630 }
1631 }
1632
1633 static void test_surface_qi(void)
1634 {
1635 static const struct qi_test tests[] =
1636 {
1637 {&IID_IDirect3DTexture2, NULL, E_NOINTERFACE},
1638 {&IID_IDirect3DTexture, NULL, E_NOINTERFACE},
1639 {&IID_IDirectDrawGammaControl, &IID_IDirectDrawGammaControl, S_OK },
1640 {&IID_IDirectDrawColorControl, NULL, E_NOINTERFACE},
1641 {&IID_IDirectDrawSurface7, &IID_IDirectDrawSurface7, S_OK },
1642 {&IID_IDirectDrawSurface4, &IID_IDirectDrawSurface4, S_OK },
1643 {&IID_IDirectDrawSurface3, &IID_IDirectDrawSurface3, S_OK },
1644 {&IID_IDirectDrawSurface2, &IID_IDirectDrawSurface2, S_OK },
1645 {&IID_IDirectDrawSurface, &IID_IDirectDrawSurface, S_OK },
1646 {&IID_IDirect3DDevice7, NULL, E_NOINTERFACE},
1647 {&IID_IDirect3DDevice3, NULL, E_NOINTERFACE},
1648 {&IID_IDirect3DDevice2, NULL, E_NOINTERFACE},
1649 {&IID_IDirect3DDevice, NULL, E_NOINTERFACE},
1650 {&IID_IDirect3DRampDevice, NULL, E_NOINTERFACE},
1651 {&IID_IDirect3DRGBDevice, NULL, E_NOINTERFACE},
1652 {&IID_IDirect3DHALDevice, NULL, E_NOINTERFACE},
1653 {&IID_IDirect3DMMXDevice, NULL, E_NOINTERFACE},
1654 {&IID_IDirect3DRefDevice, NULL, E_NOINTERFACE},
1655 {&IID_IDirect3DTnLHalDevice, NULL, E_NOINTERFACE},
1656 {&IID_IDirect3DNullDevice, NULL, E_NOINTERFACE},
1657 {&IID_IDirect3D7, NULL, E_NOINTERFACE},
1658 {&IID_IDirect3D3, NULL, E_NOINTERFACE},
1659 {&IID_IDirect3D2, NULL, E_NOINTERFACE},
1660 {&IID_IDirect3D, NULL, E_NOINTERFACE},
1661 {&IID_IDirectDraw7, NULL, E_NOINTERFACE},
1662 {&IID_IDirectDraw4, NULL, E_NOINTERFACE},
1663 {&IID_IDirectDraw3, NULL, E_NOINTERFACE},
1664 {&IID_IDirectDraw2, NULL, E_NOINTERFACE},
1665 {&IID_IDirectDraw, NULL, E_NOINTERFACE},
1666 {&IID_IDirect3DLight, NULL, E_NOINTERFACE},
1667 {&IID_IDirect3DMaterial, NULL, E_NOINTERFACE},
1668 {&IID_IDirect3DMaterial2, NULL, E_NOINTERFACE},
1669 {&IID_IDirect3DMaterial3, NULL, E_NOINTERFACE},
1670 {&IID_IDirect3DExecuteBuffer, NULL, E_NOINTERFACE},
1671 {&IID_IDirect3DViewport, NULL, E_NOINTERFACE},
1672 {&IID_IDirect3DViewport2, NULL, E_NOINTERFACE},
1673 {&IID_IDirect3DViewport3, NULL, E_NOINTERFACE},
1674 {&IID_IDirect3DVertexBuffer, NULL, E_NOINTERFACE},
1675 {&IID_IDirect3DVertexBuffer7, NULL, E_NOINTERFACE},
1676 {&IID_IDirectDrawPalette, NULL, E_NOINTERFACE},
1677 {&IID_IDirectDrawClipper, NULL, E_NOINTERFACE},
1678 {&IID_IUnknown, &IID_IDirectDrawSurface, S_OK },
1679 };
1680
1681 IDirectDrawSurface7 *surface;
1682 DDSURFACEDESC2 surface_desc;
1683 IDirect3DDevice7 *device;
1684 IDirectDraw7 *ddraw;
1685 HWND window;
1686 HRESULT hr;
1687
1688 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1689 0, 0, 640, 480, 0, 0, 0, 0);
1690 /* Try to create a D3D device to see if the ddraw implementation supports
1691 * D3D. 64-bit ddraw in particular doesn't seem to support D3D, and
1692 * doesn't support e.g. the IDirect3DTexture interfaces. */
1693 if (!(device = create_device(window, DDSCL_NORMAL)))
1694 {
1695 skip("Failed to create D3D device, skipping test.\n");
1696 DestroyWindow(window);
1697 return;
1698 }
1699 IDirect3DDevice_Release(device);
1700 if (!(ddraw = create_ddraw()))
1701 {
1702 skip("Failed to create a ddraw object, skipping test.\n");
1703 DestroyWindow(window);
1704 return;
1705 }
1706 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
1707 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
1708
1709 memset(&surface_desc, 0, sizeof(surface_desc));
1710 surface_desc.dwSize = sizeof(surface_desc);
1711 surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
1712 surface_desc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1713 surface_desc.dwWidth = 512;
1714 surface_desc.dwHeight = 512;
1715 hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &surface, NULL);
1716 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
1717
1718 test_qi("surface_qi", (IUnknown *)surface, &IID_IDirectDrawSurface7, tests, sizeof(tests) / sizeof(*tests));
1719
1720 IDirectDrawSurface7_Release(surface);
1721 IDirectDraw7_Release(ddraw);
1722 DestroyWindow(window);
1723 }
1724
1725 static void test_device_qi(void)
1726 {
1727 static const struct qi_test tests[] =
1728 {
1729 {&IID_IDirect3DTexture2, NULL, E_NOINTERFACE},
1730 {&IID_IDirect3DTexture, NULL, E_NOINTERFACE},
1731 {&IID_IDirectDrawGammaControl, NULL, E_NOINTERFACE},
1732 {&IID_IDirectDrawColorControl, NULL, E_NOINTERFACE},
1733 {&IID_IDirectDrawSurface7, NULL, E_NOINTERFACE},
1734 {&IID_IDirectDrawSurface4, NULL, E_NOINTERFACE},
1735 {&IID_IDirectDrawSurface3, NULL, E_NOINTERFACE},
1736 {&IID_IDirectDrawSurface2, NULL, E_NOINTERFACE},
1737 {&IID_IDirectDrawSurface, NULL, E_NOINTERFACE},
1738 {&IID_IDirect3DDevice7, &IID_IDirect3DDevice7, S_OK },
1739 {&IID_IDirect3DDevice3, NULL, E_NOINTERFACE},
1740 {&IID_IDirect3DDevice2, NULL, E_NOINTERFACE},
1741 {&IID_IDirect3DDevice, NULL, E_NOINTERFACE},
1742 {&IID_IDirect3DRampDevice, NULL, E_NOINTERFACE},
1743 {&IID_IDirect3DRGBDevice, NULL, E_NOINTERFACE},
1744 {&IID_IDirect3DHALDevice, NULL, E_NOINTERFACE},
1745 {&IID_IDirect3DMMXDevice, NULL, E_NOINTERFACE},
1746 {&IID_IDirect3DRefDevice, NULL, E_NOINTERFACE},
1747 {&IID_IDirect3DTnLHalDevice, NULL, E_NOINTERFACE},
1748 {&IID_IDirect3DNullDevice, NULL, E_NOINTERFACE},
1749 {&IID_IDirect3D7, NULL, E_NOINTERFACE},
1750 {&IID_IDirect3D3, NULL, E_NOINTERFACE},
1751 {&IID_IDirect3D2, NULL, E_NOINTERFACE},
1752 {&IID_IDirect3D, NULL, E_NOINTERFACE},
1753 {&IID_IDirectDraw7, NULL, E_NOINTERFACE},
1754 {&IID_IDirectDraw4, NULL, E_NOINTERFACE},
1755 {&IID_IDirectDraw3, NULL, E_NOINTERFACE},
1756 {&IID_IDirectDraw2, NULL, E_NOINTERFACE},
1757 {&IID_IDirectDraw, NULL, E_NOINTERFACE},
1758 {&IID_IDirect3DLight, NULL, E_NOINTERFACE},
1759 {&IID_IDirect3DMaterial, NULL, E_NOINTERFACE},
1760 {&IID_IDirect3DMaterial2, NULL, E_NOINTERFACE},
1761 {&IID_IDirect3DMaterial3, NULL, E_NOINTERFACE},
1762 {&IID_IDirect3DExecuteBuffer, NULL, E_NOINTERFACE},
1763 {&IID_IDirect3DViewport, NULL, E_NOINTERFACE},
1764 {&IID_IDirect3DViewport2, NULL, E_NOINTERFACE},
1765 {&IID_IDirect3DViewport3, NULL, E_NOINTERFACE},
1766 {&IID_IDirect3DVertexBuffer, NULL, E_NOINTERFACE},
1767 {&IID_IDirect3DVertexBuffer7, NULL, E_NOINTERFACE},
1768 {&IID_IDirectDrawPalette, NULL, E_NOINTERFACE},
1769 {&IID_IDirectDrawClipper, NULL, E_NOINTERFACE},
1770 {&IID_IUnknown, &IID_IDirect3DDevice7, S_OK },
1771 };
1772
1773 IDirect3DDevice7 *device;
1774 HWND window;
1775
1776 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1777 0, 0, 640, 480, 0, 0, 0, 0);
1778 if (!(device = create_device(window, DDSCL_NORMAL)))
1779 {
1780 skip("Failed to create D3D device, skipping test.\n");
1781 DestroyWindow(window);
1782 return;
1783 }
1784
1785 test_qi("device_qi", (IUnknown *)device, &IID_IDirect3DDevice7, tests, sizeof(tests) / sizeof(*tests));
1786
1787 IDirect3DDevice7_Release(device);
1788 DestroyWindow(window);
1789 }
1790
1791 static void test_wndproc(void)
1792 {
1793 LONG_PTR proc, ddraw_proc;
1794 IDirectDraw7 *ddraw;
1795 WNDCLASSA wc = {0};
1796 HWND window;
1797 HRESULT hr;
1798 ULONG ref;
1799
1800 static const UINT messages[] =
1801 {
1802 WM_WINDOWPOSCHANGING,
1803 WM_MOVE,
1804 WM_SIZE,
1805 WM_WINDOWPOSCHANGING,
1806 WM_ACTIVATE,
1807 WM_SETFOCUS,
1808 0,
1809 };
1810
1811 /* DDSCL_EXCLUSIVE replaces the window's window proc. */
1812 if (!(ddraw = create_ddraw()))
1813 {
1814 skip("Failed to create IDirectDraw7 object, skipping tests.\n");
1815 return;
1816 }
1817
1818 wc.lpfnWndProc = test_proc;
1819 wc.lpszClassName = "ddraw_test_wndproc_wc";
1820 ok(RegisterClassA(&wc), "Failed to register window class.\n");
1821
1822 window = CreateWindowA("ddraw_test_wndproc_wc", "ddraw_test",
1823 WS_MAXIMIZE | WS_CAPTION , 0, 0, 640, 480, 0, 0, 0, 0);
1824
1825 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1826 ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1827 (LONG_PTR)test_proc, proc);
1828 expect_messages = messages;
1829 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
1830 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
1831 ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
1832 expect_messages = NULL;
1833 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1834 ok(proc != (LONG_PTR)test_proc, "Expected wndproc != %#lx, got %#lx.\n",
1835 (LONG_PTR)test_proc, proc);
1836 ref = IDirectDraw7_Release(ddraw);
1837 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
1838 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1839 ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1840 (LONG_PTR)test_proc, proc);
1841
1842 /* DDSCL_NORMAL doesn't. */
1843 ddraw = create_ddraw();
1844 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1845 ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1846 (LONG_PTR)test_proc, proc);
1847 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL | DDSCL_FULLSCREEN);
1848 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
1849 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1850 ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1851 (LONG_PTR)test_proc, proc);
1852 ref = IDirectDraw7_Release(ddraw);
1853 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
1854 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1855 ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1856 (LONG_PTR)test_proc, proc);
1857
1858 /* The original window proc is only restored by ddraw if the current
1859 * window proc matches the one ddraw set. This also affects switching
1860 * from DDSCL_NORMAL to DDSCL_EXCLUSIVE. */
1861 ddraw = create_ddraw();
1862 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1863 ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1864 (LONG_PTR)test_proc, proc);
1865 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
1866 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
1867 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1868 ok(proc != (LONG_PTR)test_proc, "Expected wndproc != %#lx, got %#lx.\n",
1869 (LONG_PTR)test_proc, proc);
1870 ddraw_proc = proc;
1871 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
1872 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
1873 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1874 ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1875 (LONG_PTR)test_proc, proc);
1876 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
1877 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
1878 proc = SetWindowLongPtrA(window, GWLP_WNDPROC, (LONG_PTR)DefWindowProcA);
1879 ok(proc != (LONG_PTR)test_proc, "Expected wndproc != %#lx, got %#lx.\n",
1880 (LONG_PTR)test_proc, proc);
1881 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
1882 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
1883 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1884 ok(proc == (LONG_PTR)DefWindowProcA, "Expected wndproc %#lx, got %#lx.\n",
1885 (LONG_PTR)DefWindowProcA, proc);
1886 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
1887 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
1888 proc = SetWindowLongPtrA(window, GWLP_WNDPROC, (LONG_PTR)ddraw_proc);
1889 ok(proc == (LONG_PTR)DefWindowProcA, "Expected wndproc %#lx, got %#lx.\n",
1890 (LONG_PTR)DefWindowProcA, proc);
1891 ref = IDirectDraw7_Release(ddraw);
1892 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
1893 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1894 ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1895 (LONG_PTR)test_proc, proc);
1896
1897 ddraw = create_ddraw();
1898 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1899 ok(proc == (LONG_PTR)test_proc, "Expected wndproc %#lx, got %#lx.\n",
1900 (LONG_PTR)test_proc, proc);
1901 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
1902 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
1903 proc = SetWindowLongPtrA(window, GWLP_WNDPROC, (LONG_PTR)DefWindowProcA);
1904 ok(proc != (LONG_PTR)test_proc, "Expected wndproc != %#lx, got %#lx.\n",
1905 (LONG_PTR)test_proc, proc);
1906 ref = IDirectDraw7_Release(ddraw);
1907 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
1908 proc = GetWindowLongPtrA(window, GWLP_WNDPROC);
1909 ok(proc == (LONG_PTR)DefWindowProcA, "Expected wndproc %#lx, got %#lx.\n",
1910 (LONG_PTR)DefWindowProcA, proc);
1911
1912 fix_wndproc(window, (LONG_PTR)test_proc);
1913 expect_messages = NULL;
1914 DestroyWindow(window);
1915 UnregisterClassA("ddraw_test_wndproc_wc", GetModuleHandleA(NULL));
1916 }
1917
1918 static void test_window_style(void)
1919 {
1920 LONG style, exstyle, tmp;
1921 RECT fullscreen_rect, r;
1922 IDirectDraw7 *ddraw;
1923 HWND window;
1924 HRESULT hr;
1925 ULONG ref;
1926
1927 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1928 0, 0, 100, 100, 0, 0, 0, 0);
1929 if (!(ddraw = create_ddraw()))
1930 {
1931 skip("Failed to create a ddraw object, skipping test.\n");
1932 DestroyWindow(window);
1933 return;
1934 }
1935
1936 style = GetWindowLongA(window, GWL_STYLE);
1937 exstyle = GetWindowLongA(window, GWL_EXSTYLE);
1938 SetRect(&fullscreen_rect, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
1939
1940 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
1941 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
1942
1943 tmp = GetWindowLongA(window, GWL_STYLE);
1944 todo_wine ok(tmp == style, "Expected window style %#x, got %#x.\n", style, tmp);
1945 tmp = GetWindowLongA(window, GWL_EXSTYLE);
1946 todo_wine ok(tmp == exstyle, "Expected window extended style %#x, got %#x.\n", exstyle, tmp);
1947
1948 GetWindowRect(window, &r);
1949 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
1950 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
1951 r.left, r.top, r.right, r.bottom);
1952 GetClientRect(window, &r);
1953 todo_wine ok(!EqualRect(&r, &fullscreen_rect), "Client rect and window rect are equal.\n");
1954
1955 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
1956 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
1957
1958 tmp = GetWindowLongA(window, GWL_STYLE);
1959 todo_wine ok(tmp == style, "Expected window style %#x, got %#x.\n", style, tmp);
1960 tmp = GetWindowLongA(window, GWL_EXSTYLE);
1961 todo_wine ok(tmp == exstyle, "Expected window extended style %#x, got %#x.\n", exstyle, tmp);
1962
1963 ref = IDirectDraw7_Release(ddraw);
1964 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
1965
1966 DestroyWindow(window);
1967 }
1968
1969 static void test_redundant_mode_set(void)
1970 {
1971 DDSURFACEDESC2 surface_desc = {0};
1972 IDirectDraw7 *ddraw;
1973 HWND window;
1974 HRESULT hr;
1975 RECT r, s;
1976 ULONG ref;
1977
1978 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1979 0, 0, 100, 100, 0, 0, 0, 0);
1980 if (!(ddraw = create_ddraw()))
1981 {
1982 skip("Failed to create a ddraw object, skipping test.\n");
1983 DestroyWindow(window);
1984 return;
1985 }
1986
1987 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
1988 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
1989
1990 surface_desc.dwSize = sizeof(surface_desc);
1991 hr = IDirectDraw7_GetDisplayMode(ddraw, &surface_desc);
1992 ok(SUCCEEDED(hr), "GetDipslayMode failed, hr %#x.\n", hr);
1993
1994 hr = IDirectDraw7_SetDisplayMode(ddraw, surface_desc.dwWidth, surface_desc.dwHeight,
1995 U1(U4(surface_desc).ddpfPixelFormat).dwRGBBitCount, 0, 0);
1996 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
1997
1998 GetWindowRect(window, &r);
1999 r.right /= 2;
2000 r.bottom /= 2;
2001 SetWindowPos(window, HWND_TOP, r.left, r.top, r.right, r.bottom, 0);
2002 GetWindowRect(window, &s);
2003 ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2004 r.left, r.top, r.right, r.bottom,
2005 s.left, s.top, s.right, s.bottom);
2006
2007 hr = IDirectDraw7_SetDisplayMode(ddraw, surface_desc.dwWidth, surface_desc.dwHeight,
2008 U1(U4(surface_desc).ddpfPixelFormat).dwRGBBitCount, 0, 0);
2009 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2010
2011 GetWindowRect(window, &s);
2012 ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2013 r.left, r.top, r.right, r.bottom,
2014 s.left, s.top, s.right, s.bottom);
2015
2016 ref = IDirectDraw7_Release(ddraw);
2017 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2018
2019 DestroyWindow(window);
2020 }
2021
2022 static SIZE screen_size;
2023
2024 static LRESULT CALLBACK mode_set_proc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
2025 {
2026 if (message == WM_SIZE)
2027 {
2028 screen_size.cx = GetSystemMetrics(SM_CXSCREEN);
2029 screen_size.cy = GetSystemMetrics(SM_CYSCREEN);
2030 }
2031
2032 return test_proc(hwnd, message, wparam, lparam);
2033 }
2034
2035 static void test_coop_level_mode_set(void)
2036 {
2037 IDirectDrawSurface7 *primary;
2038 RECT fullscreen_rect, r, s;
2039 IDirectDraw7 *ddraw;
2040 DDSURFACEDESC2 ddsd;
2041 WNDCLASSA wc = {0};
2042 HWND window;
2043 HRESULT hr;
2044 ULONG ref;
2045
2046 static const UINT exclusive_messages[] =
2047 {
2048 WM_WINDOWPOSCHANGING,
2049 WM_WINDOWPOSCHANGED,
2050 WM_SIZE,
2051 WM_DISPLAYCHANGE,
2052 0,
2053 };
2054
2055 static const UINT normal_messages[] =
2056 {
2057 WM_DISPLAYCHANGE,
2058 0,
2059 };
2060
2061 if (!(ddraw = create_ddraw()))
2062 {
2063 skip("Failed to create a ddraw object, skipping test.\n");
2064 return;
2065 }
2066
2067 wc.lpfnWndProc = mode_set_proc;
2068 wc.lpszClassName = "ddraw_test_wndproc_wc";
2069 ok(RegisterClassA(&wc), "Failed to register window class.\n");
2070
2071 window = CreateWindowA("ddraw_test_wndproc_wc", "ddraw_test", WS_OVERLAPPEDWINDOW,
2072 0, 0, 100, 100, 0, 0, 0, 0);
2073
2074 SetRect(&fullscreen_rect, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
2075 SetRect(&s, 0, 0, 640, 480);
2076
2077 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
2078 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
2079
2080 GetWindowRect(window, &r);
2081 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2082 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2083 r.left, r.top, r.right, r.bottom);
2084
2085 memset(&ddsd, 0, sizeof(ddsd));
2086 ddsd.dwSize = sizeof(ddsd);
2087 ddsd.dwFlags = DDSD_CAPS;
2088 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2089
2090 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &primary, NULL);
2091 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
2092 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2093 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2094 ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
2095 fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
2096 ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
2097 fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
2098
2099 GetWindowRect(window, &r);
2100 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2101 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2102 r.left, r.top, r.right, r.bottom);
2103
2104 expect_messages = exclusive_messages;
2105 screen_size.cx = 0;
2106 screen_size.cy = 0;
2107
2108 hr = IDirectDraw7_SetDisplayMode(ddraw, 640, 480, 32, 0, 0);
2109 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2110
2111 ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
2112 expect_messages = NULL;
2113 ok(screen_size.cx == s.right && screen_size.cy == s.bottom,
2114 "Expected screen size %ux%u, got %ux%u.\n",
2115 s.right, s.bottom, screen_size.cx, screen_size.cy);
2116
2117 GetWindowRect(window, &r);
2118 ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2119 s.left, s.top, s.right, s.bottom,
2120 r.left, r.top, r.right, r.bottom);
2121
2122 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2123 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2124 ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
2125 fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
2126 ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
2127 fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
2128 IDirectDrawSurface7_Release(primary);
2129
2130 memset(&ddsd, 0, sizeof(ddsd));
2131 ddsd.dwSize = sizeof(ddsd);
2132 ddsd.dwFlags = DDSD_CAPS;
2133 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2134
2135 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &primary, NULL);
2136 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
2137 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2138 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2139 ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
2140 s.right - s.left, ddsd.dwWidth);
2141 ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
2142 s.bottom - s.top, ddsd.dwHeight);
2143
2144 GetWindowRect(window, &r);
2145 ok(EqualRect(&r, &s), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2146 s.left, s.top, s.right, s.bottom,
2147 r.left, r.top, r.right, r.bottom);
2148
2149 expect_messages = exclusive_messages;
2150 screen_size.cx = 0;
2151 screen_size.cy = 0;
2152
2153 hr = IDirectDraw_RestoreDisplayMode(ddraw);
2154 ok(SUCCEEDED(hr), "RestoreDisplayMode failed, hr %#x.\n", hr);
2155
2156 ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
2157 expect_messages = NULL;
2158 ok(screen_size.cx == fullscreen_rect.right && screen_size.cy == fullscreen_rect.bottom,
2159 "Expected screen size %ux%u, got %ux%u.\n",
2160 fullscreen_rect.right, fullscreen_rect.bottom, screen_size.cx, screen_size.cy);
2161
2162 GetWindowRect(window, &r);
2163 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2164 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2165 r.left, r.top, r.right, r.bottom);
2166
2167 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2168 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2169 ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
2170 s.right - s.left, ddsd.dwWidth);
2171 ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
2172 s.bottom - s.top, ddsd.dwHeight);
2173 IDirectDrawSurface7_Release(primary);
2174
2175 memset(&ddsd, 0, sizeof(ddsd));
2176 ddsd.dwSize = sizeof(ddsd);
2177 ddsd.dwFlags = DDSD_CAPS;
2178 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2179
2180 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &primary, NULL);
2181 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
2182 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2183 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2184 ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
2185 fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
2186 ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
2187 fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
2188
2189 GetWindowRect(window, &r);
2190 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2191 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2192 r.left, r.top, r.right, r.bottom);
2193
2194 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
2195 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
2196
2197 GetWindowRect(window, &r);
2198 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2199 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2200 r.left, r.top, r.right, r.bottom);
2201
2202 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2203 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2204 ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
2205 fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
2206 ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
2207 fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
2208 IDirectDrawSurface7_Release(primary);
2209
2210 memset(&ddsd, 0, sizeof(ddsd));
2211 ddsd.dwSize = sizeof(ddsd);
2212 ddsd.dwFlags = DDSD_CAPS;
2213 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2214
2215 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &primary, NULL);
2216 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
2217 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2218 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2219 ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
2220 fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
2221 ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
2222 fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
2223
2224 GetWindowRect(window, &r);
2225 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2226 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2227 r.left, r.top, r.right, r.bottom);
2228
2229 expect_messages = normal_messages;
2230 screen_size.cx = 0;
2231 screen_size.cy = 0;
2232
2233 hr = IDirectDraw7_SetDisplayMode(ddraw, 640, 480, 32, 0, 0);
2234 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2235
2236 ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
2237 expect_messages = NULL;
2238 ok(!screen_size.cx && !screen_size.cy, "Got unxpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
2239
2240 GetWindowRect(window, &r);
2241 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2242 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2243 r.left, r.top, r.right, r.bottom);
2244
2245 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2246 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2247 ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
2248 fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
2249 ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
2250 fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
2251 IDirectDrawSurface7_Release(primary);
2252
2253 memset(&ddsd, 0, sizeof(ddsd));
2254 ddsd.dwSize = sizeof(ddsd);
2255 ddsd.dwFlags = DDSD_CAPS;
2256 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2257
2258 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &primary, NULL);
2259 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
2260 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2261 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2262 ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
2263 s.right - s.left, ddsd.dwWidth);
2264 ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
2265 s.bottom - s.top, ddsd.dwHeight);
2266
2267 GetWindowRect(window, &r);
2268 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2269 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2270 r.left, r.top, r.right, r.bottom);
2271
2272 expect_messages = normal_messages;
2273 screen_size.cx = 0;
2274 screen_size.cy = 0;
2275
2276 hr = IDirectDraw_RestoreDisplayMode(ddraw);
2277 ok(SUCCEEDED(hr), "RestoreDisplayMode failed, hr %#x.\n", hr);
2278
2279 ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
2280 expect_messages = NULL;
2281 ok(!screen_size.cx && !screen_size.cy, "Got unxpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
2282
2283 GetWindowRect(window, &r);
2284 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2285 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2286 r.left, r.top, r.right, r.bottom);
2287
2288 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2289 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2290 ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
2291 s.right - s.left, ddsd.dwWidth);
2292 ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
2293 s.bottom - s.top, ddsd.dwHeight);
2294 IDirectDrawSurface7_Release(primary);
2295
2296 memset(&ddsd, 0, sizeof(ddsd));
2297 ddsd.dwSize = sizeof(ddsd);
2298 ddsd.dwFlags = DDSD_CAPS;
2299 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2300
2301 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &primary, NULL);
2302 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
2303 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2304 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2305 ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
2306 fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
2307 ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
2308 fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
2309
2310 GetWindowRect(window, &r);
2311 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2312 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2313 r.left, r.top, r.right, r.bottom);
2314
2315 /* DDSCL_NORMAL | DDSCL_FULLSCREEN behaves the same as just DDSCL_NORMAL.
2316 * Resizing the window on mode changes is a property of DDSCL_EXCLUSIVE,
2317 * not DDSCL_FULLSCREEN. */
2318 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL | DDSCL_FULLSCREEN);
2319 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
2320
2321 GetWindowRect(window, &r);
2322 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2323 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2324 r.left, r.top, r.right, r.bottom);
2325
2326 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2327 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2328 ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
2329 fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
2330 ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
2331 fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
2332 IDirectDrawSurface7_Release(primary);
2333
2334 memset(&ddsd, 0, sizeof(ddsd));
2335 ddsd.dwSize = sizeof(ddsd);
2336 ddsd.dwFlags = DDSD_CAPS;
2337 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2338
2339 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &primary, NULL);
2340 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
2341 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2342 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2343 ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
2344 fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
2345 ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
2346 fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
2347
2348 GetWindowRect(window, &r);
2349 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2350 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2351 r.left, r.top, r.right, r.bottom);
2352
2353 expect_messages = normal_messages;
2354 screen_size.cx = 0;
2355 screen_size.cy = 0;
2356
2357 hr = IDirectDraw7_SetDisplayMode(ddraw, 640, 480, 32, 0, 0);
2358 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2359
2360 ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
2361 expect_messages = NULL;
2362 ok(!screen_size.cx && !screen_size.cy, "Got unxpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
2363
2364 GetWindowRect(window, &r);
2365 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2366 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2367 r.left, r.top, r.right, r.bottom);
2368
2369 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2370 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2371 ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
2372 fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
2373 ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
2374 fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
2375 IDirectDrawSurface7_Release(primary);
2376
2377 memset(&ddsd, 0, sizeof(ddsd));
2378 ddsd.dwSize = sizeof(ddsd);
2379 ddsd.dwFlags = DDSD_CAPS;
2380 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2381
2382 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &primary, NULL);
2383 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
2384 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2385 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2386 ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
2387 s.right - s.left, ddsd.dwWidth);
2388 ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
2389 s.bottom - s.top, ddsd.dwHeight);
2390
2391 GetWindowRect(window, &r);
2392 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2393 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2394 r.left, r.top, r.right, r.bottom);
2395
2396 expect_messages = normal_messages;
2397 screen_size.cx = 0;
2398 screen_size.cy = 0;
2399
2400 hr = IDirectDraw_RestoreDisplayMode(ddraw);
2401 ok(SUCCEEDED(hr), "RestoreDisplayMode failed, hr %#x.\n", hr);
2402
2403 ok(!*expect_messages, "Expected message %#x, but didn't receive it.\n", *expect_messages);
2404 expect_messages = NULL;
2405 ok(!screen_size.cx && !screen_size.cy, "Got unxpected screen size %ux%u.\n", screen_size.cx, screen_size.cy);
2406
2407 GetWindowRect(window, &r);
2408 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2409 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2410 r.left, r.top, r.right, r.bottom);
2411
2412 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2413 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2414 ok(ddsd.dwWidth == s.right - s.left, "Expected surface width %u, got %u.\n",
2415 s.right - s.left, ddsd.dwWidth);
2416 ok(ddsd.dwHeight == s.bottom - s.top, "Expected surface height %u, got %u.\n",
2417 s.bottom - s.top, ddsd.dwHeight);
2418 IDirectDrawSurface7_Release(primary);
2419
2420 memset(&ddsd, 0, sizeof(ddsd));
2421 ddsd.dwSize = sizeof(ddsd);
2422 ddsd.dwFlags = DDSD_CAPS;
2423 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2424
2425 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &primary, NULL);
2426 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n",hr);
2427 hr = IDirectDrawSurface7_GetSurfaceDesc(primary, &ddsd);
2428 ok(SUCCEEDED(hr), "Failed to get surface desc, hr %#x.\n", hr);
2429 ok(ddsd.dwWidth == fullscreen_rect.right - fullscreen_rect.left, "Expected surface width %u, got %u.\n",
2430 fullscreen_rect.right - fullscreen_rect.left, ddsd.dwWidth);
2431 ok(ddsd.dwHeight == fullscreen_rect.bottom - fullscreen_rect.top, "Expected surface height %u, got %u.\n",
2432 fullscreen_rect.bottom - fullscreen_rect.top, ddsd.dwHeight);
2433 IDirectDrawSurface7_Release(primary);
2434
2435 GetWindowRect(window, &r);
2436 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2437 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2438 r.left, r.top, r.right, r.bottom);
2439
2440 ref = IDirectDraw7_Release(ddraw);
2441 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2442
2443 GetWindowRect(window, &r);
2444 ok(EqualRect(&r, &fullscreen_rect), "Expected {%d, %d, %d, %d}, got {%d, %d, %d, %d}.\n",
2445 fullscreen_rect.left, fullscreen_rect.top, fullscreen_rect.right, fullscreen_rect.bottom,
2446 r.left, r.top, r.right, r.bottom);
2447
2448 expect_messages = NULL;
2449 DestroyWindow(window);
2450 UnregisterClassA("ddraw_test_wndproc_wc", GetModuleHandleA(NULL));
2451 }
2452
2453 static void test_coop_level_mode_set_multi(void)
2454 {
2455 IDirectDraw7 *ddraw1, *ddraw2;
2456 UINT orig_w, orig_h, w, h;
2457 HWND window;
2458 HRESULT hr;
2459 ULONG ref;
2460
2461 if (!(ddraw1 = create_ddraw()))
2462 {
2463 skip("Failed to create a ddraw object, skipping test.\n");
2464 return;
2465 }
2466
2467 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
2468 0, 0, 100, 100, 0, 0, 0, 0);
2469
2470 orig_w = GetSystemMetrics(SM_CXSCREEN);
2471 orig_h = GetSystemMetrics(SM_CYSCREEN);
2472
2473 /* With just a single ddraw object, the display mode is restored on
2474 * release. */
2475 hr = IDirectDraw7_SetDisplayMode(ddraw1, 800, 600, 32, 0, 0);
2476 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2477 w = GetSystemMetrics(SM_CXSCREEN);
2478 ok(w == 800, "Got unexpected screen width %u.\n", w);
2479 h = GetSystemMetrics(SM_CYSCREEN);
2480 ok(h == 600, "Got unexpected screen height %u.\n", h);
2481
2482 ref = IDirectDraw7_Release(ddraw1);
2483 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2484 w = GetSystemMetrics(SM_CXSCREEN);
2485 ok(w == orig_w, "Got unexpected screen width %u.\n", w);
2486 h = GetSystemMetrics(SM_CYSCREEN);
2487 ok(h == orig_h, "Got unexpected screen height %u.\n", h);
2488
2489 /* When there are multiple ddraw objects, the display mode is restored to
2490 * the initial mode, before the first SetDisplayMode() call. */
2491 ddraw1 = create_ddraw();
2492 hr = IDirectDraw7_SetDisplayMode(ddraw1, 800, 600, 32, 0, 0);
2493 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2494 w = GetSystemMetrics(SM_CXSCREEN);
2495 ok(w == 800, "Got unexpected screen width %u.\n", w);
2496 h = GetSystemMetrics(SM_CYSCREEN);
2497 ok(h == 600, "Got unexpected screen height %u.\n", h);
2498
2499 ddraw2 = create_ddraw();
2500 hr = IDirectDraw7_SetDisplayMode(ddraw2, 640, 480, 32, 0, 0);
2501 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2502 w = GetSystemMetrics(SM_CXSCREEN);
2503 ok(w == 640, "Got unexpected screen width %u.\n", w);
2504 h = GetSystemMetrics(SM_CYSCREEN);
2505 ok(h == 480, "Got unexpected screen height %u.\n", h);
2506
2507 ref = IDirectDraw7_Release(ddraw2);
2508 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2509 w = GetSystemMetrics(SM_CXSCREEN);
2510 ok(w == orig_w, "Got unexpected screen width %u.\n", w);
2511 h = GetSystemMetrics(SM_CYSCREEN);
2512 ok(h == orig_h, "Got unexpected screen height %u.\n", h);
2513
2514 ref = IDirectDraw7_Release(ddraw1);
2515 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2516 w = GetSystemMetrics(SM_CXSCREEN);
2517 ok(w == orig_w, "Got unexpected screen width %u.\n", w);
2518 h = GetSystemMetrics(SM_CYSCREEN);
2519 ok(h == orig_h, "Got unexpected screen height %u.\n", h);
2520
2521 /* Regardless of release ordering. */
2522 ddraw1 = create_ddraw();
2523 hr = IDirectDraw7_SetDisplayMode(ddraw1, 800, 600, 32, 0, 0);
2524 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2525 w = GetSystemMetrics(SM_CXSCREEN);
2526 ok(w == 800, "Got unexpected screen width %u.\n", w);
2527 h = GetSystemMetrics(SM_CYSCREEN);
2528 ok(h == 600, "Got unexpected screen height %u.\n", h);
2529
2530 ddraw2 = create_ddraw();
2531 hr = IDirectDraw7_SetDisplayMode(ddraw2, 640, 480, 32, 0, 0);
2532 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2533 w = GetSystemMetrics(SM_CXSCREEN);
2534 ok(w == 640, "Got unexpected screen width %u.\n", w);
2535 h = GetSystemMetrics(SM_CYSCREEN);
2536 ok(h == 480, "Got unexpected screen height %u.\n", h);
2537
2538 ref = IDirectDraw7_Release(ddraw1);
2539 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2540 w = GetSystemMetrics(SM_CXSCREEN);
2541 ok(w == orig_w, "Got unexpected screen width %u.\n", w);
2542 h = GetSystemMetrics(SM_CYSCREEN);
2543 ok(h == orig_h, "Got unexpected screen height %u.\n", h);
2544
2545 ref = IDirectDraw7_Release(ddraw2);
2546 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2547 w = GetSystemMetrics(SM_CXSCREEN);
2548 ok(w == orig_w, "Got unexpected screen width %u.\n", w);
2549 h = GetSystemMetrics(SM_CYSCREEN);
2550 ok(h == orig_h, "Got unexpected screen height %u.\n", h);
2551
2552 /* But only for ddraw objects that called SetDisplayMode(). */
2553 ddraw1 = create_ddraw();
2554 ddraw2 = create_ddraw();
2555 hr = IDirectDraw7_SetDisplayMode(ddraw2, 640, 480, 32, 0, 0);
2556 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2557 w = GetSystemMetrics(SM_CXSCREEN);
2558 ok(w == 640, "Got unexpected screen width %u.\n", w);
2559 h = GetSystemMetrics(SM_CYSCREEN);
2560 ok(h == 480, "Got unexpected screen height %u.\n", h);
2561
2562 ref = IDirectDraw7_Release(ddraw1);
2563 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2564 w = GetSystemMetrics(SM_CXSCREEN);
2565 ok(w == 640, "Got unexpected screen width %u.\n", w);
2566 h = GetSystemMetrics(SM_CYSCREEN);
2567 ok(h == 480, "Got unexpected screen height %u.\n", h);
2568
2569 ref = IDirectDraw7_Release(ddraw2);
2570 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2571 w = GetSystemMetrics(SM_CXSCREEN);
2572 ok(w == orig_w, "Got unexpected screen width %u.\n", w);
2573 h = GetSystemMetrics(SM_CYSCREEN);
2574 ok(h == orig_h, "Got unexpected screen height %u.\n", h);
2575
2576 /* If there's a ddraw object that's currently in exclusive mode, it blocks
2577 * restoring the display mode. */
2578 ddraw1 = create_ddraw();
2579 hr = IDirectDraw7_SetDisplayMode(ddraw1, 800, 600, 32, 0, 0);
2580 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2581 w = GetSystemMetrics(SM_CXSCREEN);
2582 ok(w == 800, "Got unexpected screen width %u.\n", w);
2583 h = GetSystemMetrics(SM_CYSCREEN);
2584 ok(h == 600, "Got unexpected screen height %u.\n", h);
2585
2586 ddraw2 = create_ddraw();
2587 hr = IDirectDraw7_SetDisplayMode(ddraw2, 640, 480, 32, 0, 0);
2588 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2589 w = GetSystemMetrics(SM_CXSCREEN);
2590 ok(w == 640, "Got unexpected screen width %u.\n", w);
2591 h = GetSystemMetrics(SM_CYSCREEN);
2592 ok(h == 480, "Got unexpected screen height %u.\n", h);
2593
2594 hr = IDirectDraw7_SetCooperativeLevel(ddraw2, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
2595 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
2596
2597 ref = IDirectDraw7_Release(ddraw1);
2598 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2599 w = GetSystemMetrics(SM_CXSCREEN);
2600 ok(w == 640, "Got unexpected screen width %u.\n", w);
2601 h = GetSystemMetrics(SM_CYSCREEN);
2602 ok(h == 480, "Got unexpected screen height %u.\n", h);
2603
2604 ref = IDirectDraw7_Release(ddraw2);
2605 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2606 w = GetSystemMetrics(SM_CXSCREEN);
2607 ok(w == orig_w, "Got unexpected screen width %u.\n", w);
2608 h = GetSystemMetrics(SM_CYSCREEN);
2609 ok(h == orig_h, "Got unexpected screen height %u.\n", h);
2610
2611 /* Exclusive mode blocks mode setting on other ddraw objects in general. */
2612 ddraw1 = create_ddraw();
2613 hr = IDirectDraw7_SetDisplayMode(ddraw1, 800, 600, 32, 0, 0);
2614 ok(SUCCEEDED(hr), "SetDipslayMode failed, hr %#x.\n", hr);
2615 w = GetSystemMetrics(SM_CXSCREEN);
2616 ok(w == 800, "Got unexpected screen width %u.\n", w);
2617 h = GetSystemMetrics(SM_CYSCREEN);
2618 ok(h == 600, "Got unexpected screen height %u.\n", h);
2619
2620 hr = IDirectDraw7_SetCooperativeLevel(ddraw1, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
2621 ok(SUCCEEDED(hr), "SetCooperativeLevel failed, hr %#x.\n", hr);
2622
2623 ddraw2 = create_ddraw();
2624 hr = IDirectDraw7_SetDisplayMode(ddraw2, 640, 480, 32, 0, 0);
2625 ok(hr == DDERR_NOEXCLUSIVEMODE, "Got unexpected hr %#x.\n", hr);
2626
2627 ref = IDirectDraw7_Release(ddraw1);
2628 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2629 w = GetSystemMetrics(SM_CXSCREEN);
2630 ok(w == orig_w, "Got unexpected screen width %u.\n", w);
2631 h = GetSystemMetrics(SM_CYSCREEN);
2632 ok(h == orig_h, "Got unexpected screen height %u.\n", h);
2633
2634 ref = IDirectDraw7_Release(ddraw2);
2635 ok(ref == 0, "The ddraw object was not properly freed: refcount %u.\n", ref);
2636 w = GetSystemMetrics(SM_CXSCREEN);
2637 ok(w == orig_w, "Got unexpected screen width %u.\n", w);
2638 h = GetSystemMetrics(SM_CYSCREEN);
2639 ok(h == orig_h, "Got unexpected screen height %u.\n", h);
2640
2641 DestroyWindow(window);
2642 }
2643
2644 static void test_initialize(void)
2645 {
2646 IDirectDraw7 *ddraw;
2647 HRESULT hr;
2648
2649 if (!(ddraw = create_ddraw()))
2650 {
2651 skip("Failed to create a ddraw object, skipping test.\n");
2652 return;
2653 }
2654
2655 hr = IDirectDraw7_Initialize(ddraw, NULL);
2656 ok(hr == DDERR_ALREADYINITIALIZED, "Initialize returned hr %#x.\n", hr);
2657 IDirectDraw7_Release(ddraw);
2658
2659 CoInitialize(NULL);
2660 hr = CoCreateInstance(&CLSID_DirectDraw, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectDraw7, (void **)&ddraw);
2661 ok(SUCCEEDED(hr), "Failed to create IDirectDraw7 instance, hr %#x.\n", hr);
2662 hr = IDirectDraw7_Initialize(ddraw, NULL);
2663 ok(hr == DD_OK, "Initialize returned hr %#x, expected DD_OK.\n", hr);
2664 hr = IDirectDraw7_Initialize(ddraw, NULL);
2665 ok(hr == DDERR_ALREADYINITIALIZED, "Initialize returned hr %#x, expected DDERR_ALREADYINITIALIZED.\n", hr);
2666 IDirectDraw7_Release(ddraw);
2667 CoUninitialize();
2668 }
2669
2670 static void test_coop_level_surf_create(void)
2671 {
2672 IDirectDrawSurface7 *surface;
2673 IDirectDraw7 *ddraw;
2674 DDSURFACEDESC2 ddsd;
2675 HRESULT hr;
2676
2677 if (!(ddraw = create_ddraw()))
2678 {
2679 skip("Failed to create a ddraw object, skipping test.\n");
2680 return;
2681 }
2682
2683 memset(&ddsd, 0, sizeof(ddsd));
2684 ddsd.dwSize = sizeof(ddsd);
2685 ddsd.dwFlags = DDSD_CAPS;
2686 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2687 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &surface, NULL);
2688 ok(hr == DDERR_NOCOOPERATIVELEVELSET, "Surface creation returned hr %#x.\n", hr);
2689
2690 IDirectDraw7_Release(ddraw);
2691 }
2692
2693 static void test_vb_discard(void)
2694 {
2695 static const struct vec4 quad[] =
2696 {
2697 { 0.0f, 480.0f, 0.0f, 1.0f},
2698 { 0.0f, 0.0f, 0.0f, 1.0f},
2699 {640.0f, 480.0f, 0.0f, 1.0f},
2700 {640.0f, 0.0f, 0.0f, 1.0f},
2701 };
2702
2703 IDirect3DDevice7 *device;
2704 IDirect3D7 *d3d;
2705 IDirect3DVertexBuffer7 *buffer;
2706 HWND window;
2707 HRESULT hr;
2708 D3DVERTEXBUFFERDESC desc;
2709 BYTE *data;
2710 static const unsigned int vbsize = 16;
2711 unsigned int i;
2712
2713 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
2714 0, 0, 640, 480, 0, 0, 0, 0);
2715
2716 if (!(device = create_device(window, DDSCL_NORMAL)))
2717 {
2718 skip("Failed to create D3D device, skipping test.\n");
2719 DestroyWindow(window);
2720 return;
2721 }
2722
2723 hr = IDirect3DDevice7_GetDirect3D(device, &d3d);
2724 ok(SUCCEEDED(hr), "Failed to get d3d interface, hr %#x.\n", hr);
2725
2726 memset(&desc, 0, sizeof(desc));
2727 desc.dwSize = sizeof(desc);
2728 desc.dwCaps = D3DVBCAPS_WRITEONLY;
2729 desc.dwFVF = D3DFVF_XYZRHW;
2730 desc.dwNumVertices = vbsize;
2731 hr = IDirect3D7_CreateVertexBuffer(d3d, &desc, &buffer, 0);
2732 ok(SUCCEEDED(hr), "Failed to create vertex buffer, hr %#x.\n", hr);
2733
2734 hr = IDirect3DVertexBuffer7_Lock(buffer, DDLOCK_DISCARDCONTENTS, (void **)&data, NULL);
2735 ok(SUCCEEDED(hr), "Failed to lock vertex buffer, hr %#x.\n", hr);
2736 memcpy(data, quad, sizeof(quad));
2737 hr = IDirect3DVertexBuffer7_Unlock(buffer);
2738 ok(SUCCEEDED(hr), "Failed to unlock vertex buffer, hr %#x.\n", hr);
2739
2740 hr = IDirect3DDevice7_BeginScene(device);
2741 ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
2742 hr = IDirect3DDevice7_DrawPrimitiveVB(device, D3DPT_TRIANGLESTRIP, buffer, 0, 4, 0);
2743 ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
2744 hr = IDirect3DDevice7_EndScene(device);
2745 ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
2746
2747 hr = IDirect3DVertexBuffer7_Lock(buffer, DDLOCK_DISCARDCONTENTS, (void **)&data, NULL);
2748 ok(SUCCEEDED(hr), "Failed to lock vertex buffer, hr %#x.\n", hr);
2749 memset(data, 0xaa, sizeof(struct vec4) * vbsize);
2750 hr = IDirect3DVertexBuffer7_Unlock(buffer);
2751 ok(SUCCEEDED(hr), "Failed to unlock vertex buffer, hr %#x.\n", hr);
2752
2753 hr = IDirect3DVertexBuffer7_Lock(buffer, DDLOCK_DISCARDCONTENTS, (void **)&data, NULL);
2754 ok(SUCCEEDED(hr), "Failed to lock vertex buffer, hr %#x.\n", hr);
2755 for (i = 0; i < sizeof(struct vec4) * vbsize; i++)
2756 {
2757 if (data[i] != 0xaa)
2758 {
2759 ok(FALSE, "Vertex buffer data byte %u is 0x%02x, expected 0xaa\n", i, data[i]);
2760 break;
2761 }
2762 }
2763 hr = IDirect3DVertexBuffer7_Unlock(buffer);
2764 ok(SUCCEEDED(hr), "Failed to unlock vertex buffer, hr %#x.\n", hr);
2765
2766 IDirect3DVertexBuffer7_Release(buffer);
2767 IDirect3D7_Release(d3d);
2768 IDirect3DDevice7_Release(device);
2769 DestroyWindow(window);
2770 }
2771
2772 static void test_coop_level_multi_window(void)
2773 {
2774 HWND window1, window2;
2775 IDirectDraw7 *ddraw;
2776 HRESULT hr;
2777
2778 window1 = CreateWindowA("static", "ddraw_test1", WS_OVERLAPPEDWINDOW,
2779 0, 0, 640, 480, 0, 0, 0, 0);
2780 window2 = CreateWindowA("static", "ddraw_test2", WS_OVERLAPPEDWINDOW,
2781 0, 0, 640, 480, 0, 0, 0, 0);
2782 if (!(ddraw = create_ddraw()))
2783 {
2784 skip("Failed to create a ddraw object, skipping test.\n");
2785 DestroyWindow(window2);
2786 DestroyWindow(window1);
2787 return;
2788 }
2789
2790 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window1, DDSCL_NORMAL);
2791 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
2792 hr = IDirectDraw7_SetCooperativeLevel(ddraw, window2, DDSCL_NORMAL);
2793 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
2794 ok(IsWindow(window1), "Window 1 was destroyed.\n");
2795 ok(IsWindow(window2), "Window 2 was destroyed.\n");
2796
2797 IDirectDraw7_Release(ddraw);
2798 DestroyWindow(window2);
2799 DestroyWindow(window1);
2800 }
2801
2802 static void test_draw_strided(void)
2803 {
2804 static struct vec3 position[] =
2805 {
2806 {-1.0, -1.0, 0.0},
2807 {-1.0, 1.0, 0.0},
2808 { 1.0, 1.0, 0.0},
2809 { 1.0, -1.0, 0.0},
2810 };
2811 static DWORD diffuse[] =
2812 {
2813 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00,
2814 };
2815 static WORD indices[] =
2816 {
2817 0, 1, 2, 2, 3, 0
2818 };
2819
2820 IDirectDrawSurface7 *rt;
2821 IDirect3DDevice7 *device;
2822 D3DCOLOR color;
2823 HWND window;
2824 HRESULT hr;
2825 D3DDRAWPRIMITIVESTRIDEDDATA strided;
2826
2827 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
2828 0, 0, 640, 480, 0, 0, 0, 0);
2829
2830 if (!(device = create_device(window, DDSCL_NORMAL)))
2831 {
2832 skip("Failed to create D3D device, skipping test.\n");
2833 DestroyWindow(window);
2834 return;
2835 }
2836
2837 hr = IDirect3DDevice7_GetRenderTarget(device, &rt);
2838 ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
2839
2840 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE);
2841 ok(SUCCEEDED(hr), "Failed to disable lighting, hr %#x.\n", hr);
2842 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x00000000, 1.0f, 0);
2843 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
2844 hr = IDirect3DDevice7_BeginScene(device);
2845 ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
2846
2847 memset(&strided, 0x55, sizeof(strided));
2848 strided.position.lpvData = position;
2849 strided.position.dwStride = sizeof(*position);
2850 strided.diffuse.lpvData = diffuse;
2851 strided.diffuse.dwStride = sizeof(*diffuse);
2852 hr = IDirect3DDevice7_DrawIndexedPrimitiveStrided(device, D3DPT_TRIANGLELIST, D3DFVF_XYZ | D3DFVF_DIFFUSE,
2853 &strided, 4, indices, 6, 0);
2854 ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr);
2855
2856 hr = IDirect3DDevice7_EndScene(device);
2857 ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
2858
2859 color = get_surface_color(rt, 320, 240);
2860 ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x.\n", color);
2861
2862 IDirectDrawSurface7_Release(rt);
2863 IDirect3DDevice7_Release(device);
2864 DestroyWindow(window);
2865 }
2866
2867 static void test_clear_rect_count(void)
2868 {
2869 IDirectDrawSurface7 *rt;
2870 IDirect3DDevice7 *device;
2871 D3DCOLOR color;
2872 HWND window;
2873 HRESULT hr;
2874 D3DRECT rect = {{0}, {0}, {640}, {480}};
2875
2876 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
2877 0, 0, 640, 480, 0, 0, 0, 0);
2878 if (!(device = create_device(window, DDSCL_NORMAL)))
2879 {
2880 skip("Failed to create D3D device, skipping test.\n");
2881 DestroyWindow(window);
2882 return;
2883 }
2884
2885 hr = IDirect3DDevice7_GetRenderTarget(device, &rt);
2886 ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
2887
2888 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x00ffffff, 1.0f, 0);
2889 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
2890 hr = IDirect3DDevice7_Clear(device, 0, &rect, D3DCLEAR_TARGET, 0x00ff0000, 1.0f, 0);
2891 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
2892
2893 color = get_surface_color(rt, 320, 240);
2894 ok(compare_color(color, 0x00ffffff, 1),
2895 "Clear with count = 0, rect != NULL has color %#08x.\n", color);
2896
2897 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x00ffffff, 1.0f, 0);
2898 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
2899 hr = IDirect3DDevice7_Clear(device, 1, NULL, D3DCLEAR_TARGET, 0x0000ff00, 1.0f, 0);
2900 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
2901
2902 color = get_surface_color(rt, 320, 240);
2903 ok(compare_color(color, 0x0000ff00, 1),
2904 "Clear with count = 1, rect = NULL has color %#08x.\n", color);
2905
2906 IDirectDrawSurface7_Release(rt);
2907 IDirect3DDevice7_Release(device);
2908 DestroyWindow(window);
2909 }
2910
2911 START_TEST(ddraw7)
2912 {
2913 HMODULE module = GetModuleHandleA("ddraw.dll");
2914
2915 if (!(pDirectDrawCreateEx = (void *)GetProcAddress(module, "DirectDrawCreateEx")))
2916 {
2917 win_skip("DirectDrawCreateEx not available, skipping tests.\n");
2918 return;
2919 }
2920
2921 test_process_vertices();
2922 test_coop_level_create_device_window();
2923 test_clipper_blt();
2924 test_coop_level_d3d_state();
2925 test_surface_interface_mismatch();
2926 test_coop_level_threaded();
2927 test_depth_blit();
2928 test_texture_load_ckey();
2929 test_zenable();
2930 test_ck_rgba();
2931 test_ck_default();
2932 test_surface_qi();
2933 test_device_qi();
2934 test_wndproc();
2935 test_window_style();
2936 test_redundant_mode_set();
2937 test_coop_level_mode_set();
2938 test_coop_level_mode_set_multi();
2939 test_initialize();
2940 test_coop_level_surf_create();
2941 test_vb_discard();
2942 test_coop_level_multi_window();
2943 test_draw_strided();
2944 test_clear_rect_count();
2945 }
Windows API implementation