?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ddraw/tests: Add a helper function to set the viewport background material.
[wine/multimedia.git] / dlls / ddraw / tests / ddraw1.c
blobb5c50c55ade2becf1677e7da8af145477c3cb8f7
1 /*
2 * Copyright 2011-2012 Henri Verbeet for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18 #define COBJMACROS
19
20 #include "wine/test.h"
21 #include "d3d.h"
22
23 struct create_window_thread_param
24 {
25 HWND window;
26 HANDLE window_created;
27 HANDLE destroy_window;
28 HANDLE thread;
29 };
30
31 static BOOL compare_color(D3DCOLOR c1, D3DCOLOR c2, BYTE max_diff)
32 {
33 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
34 c1 >>= 8; c2 >>= 8;
35 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
36 c1 >>= 8; c2 >>= 8;
37 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
38 c1 >>= 8; c2 >>= 8;
39 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
40 return TRUE;
41 }
42
43 static DWORD WINAPI create_window_thread_proc(void *param)
44 {
45 struct create_window_thread_param *p = param;
46 DWORD res;
47 BOOL ret;
48
49 p->window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
50 0, 0, 640, 480, 0, 0, 0, 0);
51 ret = SetEvent(p->window_created);
52 ok(ret, "SetEvent failed, last error %#x.\n", GetLastError());
53
54 for (;;)
55 {
56 MSG msg;
57
58 while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
59 DispatchMessage(&msg);
60 res = WaitForSingleObject(p->destroy_window, 100);
61 if (res == WAIT_OBJECT_0)
62 break;
63 if (res != WAIT_TIMEOUT)
64 {
65 ok(0, "Wait failed (%#x), last error %#x.\n", res, GetLastError());
66 break;
67 }
68 }
69
70 DestroyWindow(p->window);
71
72 return 0;
73 }
74
75 static void create_window_thread(struct create_window_thread_param *p)
76 {
77 DWORD res, tid;
78
79 p->window_created = CreateEvent(NULL, FALSE, FALSE, NULL);
80 ok(!!p->window_created, "CreateEvent failed, last error %#x.\n", GetLastError());
81 p->destroy_window = CreateEvent(NULL, FALSE, FALSE, NULL);
82 ok(!!p->destroy_window, "CreateEvent failed, last error %#x.\n", GetLastError());
83 p->thread = CreateThread(NULL, 0, create_window_thread_proc, p, 0, &tid);
84 ok(!!p->thread, "Failed to create thread, last error %#x.\n", GetLastError());
85 res = WaitForSingleObject(p->window_created, INFINITE);
86 ok(res == WAIT_OBJECT_0, "Wait failed (%#x), last error %#x.\n", res, GetLastError());
87 }
88
89 static void destroy_window_thread(struct create_window_thread_param *p)
90 {
91 SetEvent(p->destroy_window);
92 WaitForSingleObject(p->thread, INFINITE);
93 CloseHandle(p->destroy_window);
94 CloseHandle(p->window_created);
95 CloseHandle(p->thread);
96 }
97
98 static D3DCOLOR get_surface_color(IDirectDrawSurface *surface, UINT x, UINT y)
99 {
100 RECT rect = {x, y, x + 1, y + 1};
101 DDSURFACEDESC surface_desc;
102 D3DCOLOR color;
103 HRESULT hr;
104
105 memset(&surface_desc, 0, sizeof(surface_desc));
106 surface_desc.dwSize = sizeof(surface_desc);
107
108 hr = IDirectDrawSurface_Lock(surface, &rect, &surface_desc, DDLOCK_READONLY | DDLOCK_WAIT, NULL);
109 ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr);
110 if (FAILED(hr))
111 return 0xdeadbeef;
112
113 color = *((DWORD *)surface_desc.lpSurface) & 0x00ffffff;
114
115 hr = IDirectDrawSurface_Unlock(surface, NULL);
116 ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr);
117
118 return color;
119 }
120
121 static void emit_process_vertices(void **ptr, WORD base_idx, DWORD vertex_count)
122 {
123 D3DINSTRUCTION *inst = *ptr;
124 D3DPROCESSVERTICES *pv = (D3DPROCESSVERTICES *)(inst + 1);
125
126 inst->bOpcode = D3DOP_PROCESSVERTICES;
127 inst->bSize = sizeof(*pv);
128 inst->wCount = 1;
129
130 pv->dwFlags = D3DPROCESSVERTICES_COPY;
131 pv->wStart = base_idx;
132 pv->wDest = 0;
133 pv->dwCount = vertex_count;
134 pv->dwReserved = 0;
135
136 *ptr = pv + 1;
137 }
138
139 static void emit_set_rs(void **ptr, D3DRENDERSTATETYPE state, DWORD value)
140 {
141 D3DINSTRUCTION *inst = *ptr;
142 D3DSTATE *rs = (D3DSTATE *)(inst + 1);
143
144 inst->bOpcode = D3DOP_STATERENDER;
145 inst->bSize = sizeof(*rs);
146 inst->wCount = 1;
147
148 U1(*rs).drstRenderStateType = state;
149 U2(*rs).dwArg[0] = value;
150
151 *ptr = rs + 1;
152 }
153
154 static void emit_tquad(void **ptr, WORD base_idx)
155 {
156 D3DINSTRUCTION *inst = *ptr;
157 D3DTRIANGLE *tri = (D3DTRIANGLE *)(inst + 1);
158
159 inst->bOpcode = D3DOP_TRIANGLE;
160 inst->bSize = sizeof(*tri);
161 inst->wCount = 2;
162
163 U1(*tri).v1 = base_idx;
164 U2(*tri).v2 = base_idx + 1;
165 U3(*tri).v3 = base_idx + 2;
166 tri->wFlags = D3DTRIFLAG_START;
167 ++tri;
168
169 U1(*tri).v1 = base_idx + 2;
170 U2(*tri).v2 = base_idx + 1;
171 U3(*tri).v3 = base_idx + 3;
172 tri->wFlags = D3DTRIFLAG_ODD;
173 ++tri;
174
175 *ptr = tri;
176 }
177
178 static void emit_end(void **ptr)
179 {
180 D3DINSTRUCTION *inst = *ptr;
181
182 inst->bOpcode = D3DOP_EXIT;
183 inst->bSize = 0;
184 inst->wCount = 0;
185
186 *ptr = inst + 1;
187 }
188
189 static HRESULT CALLBACK enum_z_fmt(GUID *guid, char *description, char *name,
190 D3DDEVICEDESC *hal_desc, D3DDEVICEDESC *hel_desc, void *ctx)
191 {
192 DWORD *z_depth = ctx;
193
194 if (!IsEqualGUID(&IID_IDirect3DHALDevice, guid))
195 return D3DENUMRET_OK;
196
197 if (hal_desc->dwDeviceZBufferBitDepth & DDBD_32)
198 *z_depth = 32;
199 else if (hal_desc->dwDeviceZBufferBitDepth & DDBD_24)
200 *z_depth = 24;
201 else if (hal_desc->dwDeviceZBufferBitDepth & DDBD_16)
202 *z_depth = 16;
203
204 return DDENUMRET_OK;
205 }
206
207 static IDirectDraw *create_ddraw(void)
208 {
209 IDirectDraw *ddraw;
210
211 if (FAILED(DirectDrawCreate(NULL, &ddraw, NULL)))
212 return NULL;
213
214 return ddraw;
215 }
216
217 static IDirect3DDevice *create_device(IDirectDraw *ddraw, HWND window, DWORD coop_level)
218 {
219 IDirectDrawSurface *surface, *ds;
220 IDirect3DDevice *device = NULL;
221 DDSURFACEDESC surface_desc;
222 DWORD z_depth = 0;
223 IDirect3D *d3d;
224 HRESULT hr;
225
226 hr = IDirectDraw_SetCooperativeLevel(ddraw, window, coop_level);
227 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
228
229 memset(&surface_desc, 0, sizeof(surface_desc));
230 surface_desc.dwSize = sizeof(surface_desc);
231 surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
232 surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
233 surface_desc.dwWidth = 640;
234 surface_desc.dwHeight = 480;
235
236 hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &surface, NULL);
237 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
238
239 if (coop_level & DDSCL_NORMAL)
240 {
241 IDirectDrawClipper *clipper;
242
243 hr = IDirectDraw_CreateClipper(ddraw, 0, &clipper, NULL);
244 ok(SUCCEEDED(hr), "Failed to create clipper, hr %#x.\n", hr);
245 hr = IDirectDrawClipper_SetHWnd(clipper, 0, window);
246 ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
247 hr = IDirectDrawSurface_SetClipper(surface, clipper);
248 ok(SUCCEEDED(hr), "Failed to set surface clipper, hr %#x.\n", hr);
249 IDirectDrawClipper_Release(clipper);
250 }
251
252 hr = IDirectDraw_QueryInterface(ddraw, &IID_IDirect3D, (void **)&d3d);
253 if (FAILED(hr))
254 {
255 IDirectDrawSurface_Release(surface);
256 return NULL;
257 }
258
259 hr = IDirect3D_EnumDevices(d3d, enum_z_fmt, &z_depth);
260 ok(SUCCEEDED(hr), "Failed to enumerate z-formats, hr %#x.\n", hr);
261 IDirect3D_Release(d3d);
262 if (FAILED(hr) || !z_depth)
263 {
264 IDirectDrawSurface_Release(surface);
265 return NULL;
266 }
267
268 memset(&surface_desc, 0, sizeof(surface_desc));
269 surface_desc.dwSize = sizeof(surface_desc);
270 surface_desc.dwFlags = DDSD_CAPS | DDSD_ZBUFFERBITDEPTH | DDSD_WIDTH | DDSD_HEIGHT;
271 surface_desc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
272 U2(surface_desc).dwZBufferBitDepth = z_depth;
273 surface_desc.dwWidth = 640;
274 surface_desc.dwHeight = 480;
275 hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &ds, NULL);
276 ok(SUCCEEDED(hr), "Failed to create depth buffer, hr %#x.\n", hr);
277 if (FAILED(hr))
278 {
279 IDirectDrawSurface_Release(surface);
280 return NULL;
281 }
282
283 hr = IDirectDrawSurface_AddAttachedSurface(surface, ds);
284 ok(SUCCEEDED(hr), "Failed to attach depth buffer, hr %#x.\n", hr);
285 IDirectDrawSurface_Release(ds);
286 if (FAILED(hr))
287 {
288 IDirectDrawSurface_Release(surface);
289 return NULL;
290 }
291
292 hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirect3DHALDevice, (void **)&device);
293 IDirectDrawSurface_Release(surface);
294 if (FAILED(hr))
295 return NULL;
296
297 return device;
298 }
299
300 static IDirect3DViewport *create_viewport(IDirect3DDevice *device, UINT x, UINT y, UINT w, UINT h)
301 {
302 IDirect3DViewport *viewport;
303 D3DVIEWPORT vp;
304 IDirect3D *d3d;
305 HRESULT hr;
306
307 hr = IDirect3DDevice_GetDirect3D(device, &d3d);
308 ok(SUCCEEDED(hr), "Failed to get d3d interface, hr %#x.\n", hr);
309 hr = IDirect3D_CreateViewport(d3d, &viewport, NULL);
310 ok(SUCCEEDED(hr), "Failed to create viewport, hr %#x.\n", hr);
311 hr = IDirect3DDevice_AddViewport(device, viewport);
312 ok(SUCCEEDED(hr), "Failed to add viewport, hr %#x.\n", hr);
313 memset(&vp, 0, sizeof(vp));
314 vp.dwSize = sizeof(vp);
315 vp.dwX = x;
316 vp.dwY = y;
317 vp.dwWidth = w;
318 vp.dwHeight = h;
319 vp.dvScaleX = (float)w / 2.0f;
320 vp.dvScaleY = (float)h / 2.0f;
321 vp.dvMaxX = 1.0f;
322 vp.dvMaxY = 1.0f;
323 vp.dvMinZ = 0.0f;
324 vp.dvMaxZ = 1.0f;
325 hr = IDirect3DViewport_SetViewport(viewport, &vp);
326 ok(SUCCEEDED(hr), "Failed to set viewport data, hr %#x.\n", hr);
327 IDirect3D_Release(d3d);
328
329 return viewport;
330 }
331
332 static void viewport_set_background(IDirect3DDevice *device, IDirect3DViewport *viewport,
333 IDirect3DMaterial *material)
334 {
335 D3DMATERIALHANDLE material_handle;
336 HRESULT hr;
337
338 hr = IDirect3DMaterial2_GetHandle(material, device, &material_handle);
339 ok(SUCCEEDED(hr), "Failed to get material handle, hr %#x.\n", hr);
340 hr = IDirect3DViewport2_SetBackground(viewport, material_handle);
341 ok(SUCCEEDED(hr), "Failed to set viewport background, hr %#x.\n", hr);
342 }
343
344 static void destroy_viewport(IDirect3DDevice *device, IDirect3DViewport *viewport)
345 {
346 HRESULT hr;
347
348 hr = IDirect3DDevice_DeleteViewport(device, viewport);
349 ok(SUCCEEDED(hr), "Failed to delete viewport, hr %#x.\n", hr);
350 IDirect3DViewport_Release(viewport);
351 }
352
353 static IDirect3DMaterial *create_diffuse_material(IDirect3DDevice *device, float r, float g, float b, float a)
354 {
355 IDirect3DMaterial *material;
356 D3DMATERIAL mat;
357 IDirect3D *d3d;
358 HRESULT hr;
359
360 hr = IDirect3DDevice_GetDirect3D(device, &d3d);
361 ok(SUCCEEDED(hr), "Failed to get d3d interface, hr %#x.\n", hr);
362 hr = IDirect3D_CreateMaterial(d3d, &material, NULL);
363 ok(SUCCEEDED(hr), "Failed to create material, hr %#x.\n", hr);
364 memset(&mat, 0, sizeof(mat));
365 mat.dwSize = sizeof(mat);
366 U1(U(mat).diffuse).r = r;
367 U2(U(mat).diffuse).g = g;
368 U3(U(mat).diffuse).b = b;
369 U4(U(mat).diffuse).a = a;
370 hr = IDirect3DMaterial_SetMaterial(material, &mat);
371 ok(SUCCEEDED(hr), "Failed to set material data, hr %#x.\n", hr);
372 IDirect3D_Release(d3d);
373
374 return material;
375 }
376
377 static void destroy_material(IDirect3DMaterial *material)
378 {
379 IDirect3DMaterial_Release(material);
380 }
381
382 static HRESULT CALLBACK restore_callback(IDirectDrawSurface *surface, DDSURFACEDESC *desc, void *context)
383 {
384 HRESULT hr = IDirectDrawSurface_Restore(surface);
385 ok(SUCCEEDED(hr), "Failed to restore surface, hr %#x.\n", hr);
386 IDirectDrawSurface_Release(surface);
387
388 return DDENUMRET_OK;
389 }
390
391 static HRESULT restore_surfaces(IDirectDraw *ddraw)
392 {
393 return IDirectDraw_EnumSurfaces(ddraw, DDENUMSURFACES_ALL | DDENUMSURFACES_DOESEXIST,
394 NULL, NULL, restore_callback);
395 }
396
397 static void test_coop_level_create_device_window(void)
398 {
399 HWND focus_window, device_window;
400 IDirectDraw *ddraw;
401 HRESULT hr;
402
403 focus_window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
404 0, 0, 640, 480, 0, 0, 0, 0);
405 if (!(ddraw = create_ddraw()))
406 {
407 skip("Failed to create a ddraw object, skipping test.\n");
408 DestroyWindow(focus_window);
409 return;
410 }
411
412 hr = IDirectDraw_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL);
413 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
414 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
415 ok(!device_window, "Unexpected device window found.\n");
416 hr = IDirectDraw_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW);
417 ok(hr == DDERR_INVALIDPARAMS, "Got unexpected hr %#x.\n", hr);
418 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
419 ok(!device_window, "Unexpected device window found.\n");
420 hr = IDirectDraw_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_NORMAL);
421 ok(hr == DDERR_INVALIDPARAMS, "Got unexpected hr %#x.\n", hr);
422 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
423 ok(!device_window, "Unexpected device window found.\n");
424 hr = IDirectDraw_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_NORMAL | DDSCL_FULLSCREEN);
425 ok(hr == DDERR_INVALIDPARAMS, "Got unexpected hr %#x.\n", hr);
426 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
427 ok(!device_window, "Unexpected device window found.\n");
428 hr = IDirectDraw_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
429 ok(hr == DDERR_NOFOCUSWINDOW || broken(hr == DDERR_INVALIDPARAMS), "Got unexpected hr %#x.\n", hr);
430 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
431 ok(!device_window, "Unexpected device window found.\n");
432
433 /* Windows versions before 98 / NT5 don't support DDSCL_CREATEDEVICEWINDOW. */
434 if (broken(hr == DDERR_INVALIDPARAMS))
435 {
436 win_skip("DDSCL_CREATEDEVICEWINDOW not supported, skipping test.\n");
437 IDirectDraw_Release(ddraw);
438 DestroyWindow(focus_window);
439 return;
440 }
441
442 hr = IDirectDraw_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL);
443 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
444 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
445 ok(!device_window, "Unexpected device window found.\n");
446 hr = IDirectDraw_SetCooperativeLevel(ddraw, focus_window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
447 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
448 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
449 ok(!device_window, "Unexpected device window found.\n");
450
451 hr = IDirectDraw_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL);
452 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
453 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
454 ok(!device_window, "Unexpected device window found.\n");
455 hr = IDirectDraw_SetCooperativeLevel(ddraw, NULL, DDSCL_SETFOCUSWINDOW
456 | DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
457 ok(hr == DDERR_NOHWND, "Got unexpected hr %#x.\n", hr);
458 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
459 ok(!!device_window, "Device window not found.\n");
460
461 hr = IDirectDraw_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL);
462 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
463 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
464 ok(!device_window, "Unexpected device window found.\n");
465 hr = IDirectDraw_SetCooperativeLevel(ddraw, focus_window, DDSCL_SETFOCUSWINDOW
466 | DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
467 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
468 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
469 ok(!!device_window, "Device window not found.\n");
470
471 hr = IDirectDraw_SetCooperativeLevel(ddraw, NULL, DDSCL_NORMAL);
472 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
473 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
474 ok(!device_window, "Unexpected device window found.\n");
475 hr = IDirectDraw_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
476 ok(hr == DDERR_NOFOCUSWINDOW, "Got unexpected hr %#x.\n", hr);
477 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
478 ok(!device_window, "Unexpected device window found.\n");
479 hr = IDirectDraw_SetCooperativeLevel(ddraw, focus_window, DDSCL_SETFOCUSWINDOW);
480 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
481 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
482 ok(!device_window, "Unexpected device window found.\n");
483 hr = IDirectDraw_SetCooperativeLevel(ddraw, NULL, DDSCL_CREATEDEVICEWINDOW | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
484 ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr);
485 device_window = FindWindowA("DirectDrawDeviceWnd", "DirectDrawDeviceWnd");
486 ok(!!device_window, "Device window not found.\n");
487
488 IDirectDraw_Release(ddraw);
489 DestroyWindow(focus_window);
490 }
491
492 static void test_clipper_blt(void)
493 {
494 IDirectDrawSurface *src_surface, *dst_surface;
495 RECT client_rect, src_rect, *rect;
496 IDirectDrawClipper *clipper;
497 DDSURFACEDESC surface_desc;
498 unsigned int i, j, x, y;
499 IDirectDraw *ddraw;
500 RGNDATA *rgn_data;
501 D3DCOLOR color;
502 HRGN r1, r2;
503 HWND window;
504 DDBLTFX fx;
505 HRESULT hr;
506 DWORD *ptr;
507 DWORD ret;
508
509 static const DWORD src_data[] =
510 {
511 0xff0000ff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffffffff, 0xffffffff,
512 0xff0000ff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffffffff, 0xffffffff,
513 0xff0000ff, 0xff0000ff, 0xff00ff00, 0xffff0000, 0xffffffff, 0xffffffff,
514 };
515 static const D3DCOLOR expected1[] =
516 {
517 0x000000ff, 0x0000ff00, 0x00000000, 0x00000000,
518 0x000000ff, 0x0000ff00, 0x00000000, 0x00000000,
519 0x00000000, 0x00000000, 0x00ff0000, 0x00ffffff,
520 0x00000000, 0x00000000, 0x00ff0000, 0x00ffffff,
521 };
522 static const D3DCOLOR expected2[] =
523 {
524 0x000000ff, 0x000000ff, 0x00000000, 0x00000000,
525 0x000000ff, 0x000000ff, 0x00000000, 0x00000000,
526 0x00000000, 0x00000000, 0x000000ff, 0x000000ff,
527 0x00000000, 0x00000000, 0x000000ff, 0x000000ff,
528 };
529
530 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
531 10, 10, 640, 480, 0, 0, 0, 0);
532 ShowWindow(window, SW_SHOW);
533 if (!(ddraw = create_ddraw()))
534 {
535 skip("Failed to create a ddraw object, skipping test.\n");
536 DestroyWindow(window);
537 return;
538 }
539
540 ret = GetClientRect(window, &client_rect);
541 ok(ret, "Failed to get client rect.\n");
542 ret = MapWindowPoints(window, NULL, (POINT *)&client_rect, 2);
543 ok(ret, "Failed to map client rect.\n");
544
545 hr = IDirectDraw_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
546 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
547
548 hr = IDirectDraw_CreateClipper(ddraw, 0, &clipper, NULL);
549 ok(SUCCEEDED(hr), "Failed to create clipper, hr %#x.\n", hr);
550 hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
551 ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr);
552 hr = IDirectDrawClipper_SetHWnd(clipper, 0, window);
553 ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
554 hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
555 ok(SUCCEEDED(hr), "Failed to get clip list size, hr %#x.\n", hr);
556 rgn_data = HeapAlloc(GetProcessHeap(), 0, ret);
557 hr = IDirectDrawClipper_GetClipList(clipper, NULL, rgn_data, &ret);
558 ok(SUCCEEDED(hr), "Failed to get clip list, hr %#x.\n", hr);
559 ok(rgn_data->rdh.dwSize == sizeof(rgn_data->rdh), "Got unexpected structure size %#x.\n", rgn_data->rdh.dwSize);
560 ok(rgn_data->rdh.iType == RDH_RECTANGLES, "Got unexpected type %#x.\n", rgn_data->rdh.iType);
561 ok(rgn_data->rdh.nCount == 1, "Got unexpected count %u.\n", rgn_data->rdh.nCount);
562 ok(rgn_data->rdh.nRgnSize == 16 || broken(rgn_data->rdh.nRgnSize == 168 /* NT4 */),
563 "Got unexpected region size %u.\n", rgn_data->rdh.nRgnSize);
564 ok(EqualRect(&rgn_data->rdh.rcBound, &client_rect),
565 "Got unexpected bounding rect {%d, %d, %d, %d}, expected {%d, %d, %d, %d}.\n",
566 rgn_data->rdh.rcBound.left, rgn_data->rdh.rcBound.top,
567 rgn_data->rdh.rcBound.right, rgn_data->rdh.rcBound.bottom,
568 client_rect.left, client_rect.top, client_rect.right, client_rect.bottom);
569 rect = (RECT *)&rgn_data->Buffer[0];
570 ok(EqualRect(rect, &client_rect),
571 "Got unexpected clip rect {%d, %d, %d, %d}, expected {%d, %d, %d, %d}.\n",
572 rect->left, rect->top, rect->right, rect->bottom,
573 client_rect.left, client_rect.top, client_rect.right, client_rect.bottom);
574 HeapFree(GetProcessHeap(), 0, rgn_data);
575
576 r1 = CreateRectRgn(0, 0, 320, 240);
577 ok(!!r1, "Failed to create region.\n");
578 r2 = CreateRectRgn(320, 240, 640, 480);
579 ok(!!r2, "Failed to create region.\n");
580 CombineRgn(r1, r1, r2, RGN_OR);
581 ret = GetRegionData(r1, 0, NULL);
582 rgn_data = HeapAlloc(GetProcessHeap(), 0, ret);
583 ret = GetRegionData(r1, ret, rgn_data);
584 ok(!!ret, "Failed to get region data.\n");
585
586 DeleteObject(r2);
587 DeleteObject(r1);
588
589 hr = IDirectDrawClipper_SetClipList(clipper, rgn_data, 0);
590 ok(hr == DDERR_CLIPPERISUSINGHWND, "Got unexpected hr %#x.\n", hr);
591 hr = IDirectDrawClipper_SetHWnd(clipper, 0, NULL);
592 ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
593 hr = IDirectDrawClipper_SetClipList(clipper, rgn_data, 0);
594 ok(SUCCEEDED(hr), "Failed to set clip list, hr %#x.\n", hr);
595
596 HeapFree(GetProcessHeap(), 0, rgn_data);
597
598 memset(&surface_desc, 0, sizeof(surface_desc));
599 surface_desc.dwSize = sizeof(surface_desc);
600 surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
601 surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
602 surface_desc.dwWidth = 640;
603 surface_desc.dwHeight = 480;
604 surface_desc.ddpfPixelFormat.dwSize = sizeof(surface_desc.ddpfPixelFormat);
605 surface_desc.ddpfPixelFormat.dwFlags = DDPF_RGB;
606 U1(surface_desc.ddpfPixelFormat).dwRGBBitCount = 32;
607 U2(surface_desc.ddpfPixelFormat).dwRBitMask = 0x00ff0000;
608 U3(surface_desc.ddpfPixelFormat).dwGBitMask = 0x0000ff00;
609 U4(surface_desc.ddpfPixelFormat).dwBBitMask = 0x000000ff;
610
611 hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &src_surface, NULL);
612 ok(SUCCEEDED(hr), "Failed to create source surface, hr %#x.\n", hr);
613 hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &dst_surface, NULL);
614 ok(SUCCEEDED(hr), "Failed to create destination surface, hr %#x.\n", hr);
615
616 memset(&fx, 0, sizeof(fx));
617 fx.dwSize = sizeof(fx);
618 hr = IDirectDrawSurface_Blt(src_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
619 ok(SUCCEEDED(hr), "Failed to clear source surface, hr %#x.\n", hr);
620 hr = IDirectDrawSurface_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
621 ok(SUCCEEDED(hr), "Failed to clear destination surface, hr %#x.\n", hr);
622
623 hr = IDirectDrawSurface_Lock(src_surface, NULL, &surface_desc, DDLOCK_WAIT, NULL);
624 ok(SUCCEEDED(hr), "Failed to lock source surface, hr %#x.\n", hr);
625 ok(U1(surface_desc).lPitch == 2560, "Got unexpected surface pitch %u.\n", U1(surface_desc).lPitch);
626 ptr = surface_desc.lpSurface;
627 memcpy(&ptr[ 0], &src_data[ 0], 6 * sizeof(DWORD));
628 memcpy(&ptr[ 640], &src_data[ 6], 6 * sizeof(DWORD));
629 memcpy(&ptr[1280], &src_data[12], 6 * sizeof(DWORD));
630 hr = IDirectDrawSurface_Unlock(src_surface, NULL);
631 ok(SUCCEEDED(hr), "Failed to unlock source surface, hr %#x.\n", hr);
632
633 hr = IDirectDrawSurface_SetClipper(dst_surface, clipper);
634 ok(SUCCEEDED(hr), "Failed to set clipper, hr %#x.\n", hr);
635
636 SetRect(&src_rect, 1, 1, 5, 2);
637 hr = IDirectDrawSurface_Blt(dst_surface, NULL, src_surface, &src_rect, DDBLT_WAIT, NULL);
638 ok(SUCCEEDED(hr), "Failed to blit, hr %#x.\n", hr);
639 for (i = 0; i < 4; ++i)
640 {
641 for (j = 0; j < 4; ++j)
642 {
643 x = 80 * ((2 * j) + 1);
644 y = 60 * ((2 * i) + 1);
645 color = get_surface_color(dst_surface, x, y);
646 ok(compare_color(color, expected1[i * 4 + j], 1),
647 "Expected color 0x%08x at %u,%u, got 0x%08x.\n", expected1[i * 4 + j], x, y, color);
648 }
649 }
650
651 U5(fx).dwFillColor = 0xff0000ff;
652 hr = IDirectDrawSurface_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
653 ok(SUCCEEDED(hr), "Failed to clear destination surface, hr %#x.\n", hr);
654 for (i = 0; i < 4; ++i)
655 {
656 for (j = 0; j < 4; ++j)
657 {
658 x = 80 * ((2 * j) + 1);
659 y = 60 * ((2 * i) + 1);
660 color = get_surface_color(dst_surface, x, y);
661 ok(compare_color(color, expected2[i * 4 + j], 1),
662 "Expected color 0x%08x at %u,%u, got 0x%08x.\n", expected2[i * 4 + j], x, y, color);
663 }
664 }
665
666 hr = IDirectDrawSurface_BltFast(dst_surface, 0, 0, src_surface, NULL, DDBLTFAST_WAIT);
667 ok(hr == DDERR_BLTFASTCANTCLIP || broken(hr == E_NOTIMPL /* NT4 */), "Got unexpected hr %#x.\n", hr);
668
669 hr = IDirectDrawClipper_SetHWnd(clipper, 0, window);
670 ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
671 hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
672 ok(SUCCEEDED(hr), "Failed to get clip list size, hr %#x.\n", hr);
673 DestroyWindow(window);
674 hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
675 ok(hr == E_FAIL, "Got unexpected hr %#x.\n", hr);
676 hr = IDirectDrawClipper_SetHWnd(clipper, 0, NULL);
677 ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
678 hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
679 ok(SUCCEEDED(hr), "Failed to get clip list size, hr %#x.\n", hr);
680 hr = IDirectDrawClipper_SetClipList(clipper, NULL, 0);
681 ok(SUCCEEDED(hr), "Failed to set clip list, hr %#x.\n", hr);
682 hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
683 ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr);
684 hr = IDirectDrawSurface_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
685 ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr);
686
687 IDirectDrawSurface_Release(dst_surface);
688 IDirectDrawSurface_Release(src_surface);
689 IDirectDrawClipper_Release(clipper);
690 IDirectDraw_Release(ddraw);
691 }
692
693 static void test_coop_level_d3d_state(void)
694 {
695 D3DRECT clear_rect = {{0}, {0}, {640}, {480}};
696 IDirectDrawSurface *rt, *surface;
697 IDirect3DMaterial *background;
698 IDirect3DViewport *viewport;
699 IDirect3DDevice *device;
700 D3DMATERIAL material;
701 IDirectDraw *ddraw;
702 D3DCOLOR color;
703 HWND window;
704 HRESULT hr;
705
706 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
707 0, 0, 640, 480, 0, 0, 0, 0);
708 if (!(ddraw = create_ddraw()))
709 {
710 skip("Failed to create ddraw object, skipping test.\n");
711 DestroyWindow(window);
712 return;
713 }
714 if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
715 {
716 skip("Failed to create D3D device, skipping test.\n");
717 IDirectDraw_Release(ddraw);
718 DestroyWindow(window);
719 return;
720 }
721
722 background = create_diffuse_material(device, 1.0f, 0.0f, 0.0f, 1.0f);
723 viewport = create_viewport(device, 0, 0, 640, 480);
724 viewport_set_background(device, viewport, background);
725
726 hr = IDirect3DDevice_QueryInterface(device, &IID_IDirectDrawSurface, (void **)&rt);
727 ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
728 hr = IDirect3DViewport_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET);
729 ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
730 color = get_surface_color(rt, 320, 240);
731 ok(compare_color(color, 0x00ff0000, 1), "Got unexpected color 0x%08x.\n", color);
732
733 hr = IDirectDraw_SetCooperativeLevel(ddraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
734 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
735 hr = IDirectDrawSurface_IsLost(rt);
736 ok(hr == DDERR_SURFACELOST, "Got unexpected hr %#x.\n", hr);
737 hr = restore_surfaces(ddraw);
738 ok(SUCCEEDED(hr), "Failed to restore surfaces, hr %#x.\n", hr);
739
740 memset(&material, 0, sizeof(material));
741 material.dwSize = sizeof(material);
742 U1(U(material).diffuse).r = 0.0f;
743 U2(U(material).diffuse).g = 1.0f;
744 U3(U(material).diffuse).b = 0.0f;
745 U4(U(material).diffuse).a = 1.0f;
746 hr = IDirect3DMaterial_SetMaterial(background, &material);
747 ok(SUCCEEDED(hr), "Failed to set material data, hr %#x.\n", hr);
748
749 hr = IDirect3DDevice_QueryInterface(device, &IID_IDirectDrawSurface, (void **)&surface);
750 ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
751 ok(surface == rt, "Got unexpected surface %p.\n", surface);
752 hr = IDirect3DViewport_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET);
753 ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
754 color = get_surface_color(rt, 320, 240);
755 ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x.\n", color);
756
757 destroy_viewport(device, viewport);
758 destroy_material(background);
759 IDirectDrawSurface_Release(surface);
760 IDirectDrawSurface_Release(rt);
761 IDirect3DDevice_Release(device);
762 IDirectDraw_Release(ddraw);
763 DestroyWindow(window);
764 }
765
766 static void test_surface_interface_mismatch(void)
767 {
768 IDirectDraw *ddraw = NULL;
769 IDirect3D *d3d = NULL;
770 IDirectDrawSurface *surface = NULL, *ds;
771 IDirectDrawSurface3 *surface3 = NULL;
772 IDirect3DDevice *device = NULL;
773 IDirect3DViewport *viewport = NULL;
774 IDirect3DMaterial *background = NULL;
775 DDSURFACEDESC surface_desc;
776 DWORD z_depth = 0;
777 ULONG refcount;
778 HRESULT hr;
779 D3DCOLOR color;
780 HWND window;
781 D3DRECT clear_rect = {{0}, {0}, {640}, {480}};
782
783 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
784 0, 0, 640, 480, 0, 0, 0, 0);
785
786 if (!(ddraw = create_ddraw()))
787 {
788 skip("Failed to create a ddraw object, skipping test.\n");
789 goto cleanup;
790 }
791
792 hr = IDirectDraw_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
793 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
794
795 memset(&surface_desc, 0, sizeof(surface_desc));
796 surface_desc.dwSize = sizeof(surface_desc);
797 surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
798 surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
799 surface_desc.dwWidth = 640;
800 surface_desc.dwHeight = 480;
801
802 hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &surface, NULL);
803 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
804
805 hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirectDrawSurface3, (void **)&surface3);
806 if (FAILED(hr))
807 {
808 skip("Failed to get the IDirectDrawSurface3 interface, skipping test.\n");
809 goto cleanup;
810 }
811
812 hr = IDirectDraw_QueryInterface(ddraw, &IID_IDirect3D, (void **)&d3d);
813 if (FAILED(hr))
814 {
815 skip("Failed to get the IDirect3D interface, skipping test.\n");
816 goto cleanup;
817 }
818
819 hr = IDirect3D_EnumDevices(d3d, enum_z_fmt, &z_depth);
820 if (FAILED(hr) || !z_depth)
821 {
822 skip("No depth buffer formats available, skipping test.\n");
823 goto cleanup;
824 }
825
826 memset(&surface_desc, 0, sizeof(surface_desc));
827 surface_desc.dwSize = sizeof(surface_desc);
828 surface_desc.dwFlags = DDSD_CAPS | DDSD_ZBUFFERBITDEPTH | DDSD_WIDTH | DDSD_HEIGHT;
829 surface_desc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
830 U2(surface_desc).dwZBufferBitDepth = z_depth;
831 surface_desc.dwWidth = 640;
832 surface_desc.dwHeight = 480;
833 hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &ds, NULL);
834 ok(SUCCEEDED(hr), "Failed to create depth buffer, hr %#x.\n", hr);
835 if (FAILED(hr))
836 goto cleanup;
837
838 /* Using a different surface interface version still works */
839 hr = IDirectDrawSurface3_AddAttachedSurface(surface3, (IDirectDrawSurface3 *)ds);
840 ok(SUCCEEDED(hr), "Failed to attach depth buffer, hr %#x.\n", hr);
841 refcount = IDirectDrawSurface_Release(ds);
842 ok(refcount == 1, "Got unexpected refcount %u.\n", refcount);
843 if (FAILED(hr))
844 goto cleanup;
845
846 /* Here too */
847 hr = IDirectDrawSurface3_QueryInterface(surface3, &IID_IDirect3DHALDevice, (void **)&device);
848 ok(SUCCEEDED(hr), "Failed to create d3d device.\n");
849 if (FAILED(hr))
850 goto cleanup;
851
852 background = create_diffuse_material(device, 1.0f, 0.0f, 0.0f, 1.0f);
853 viewport = create_viewport(device, 0, 0, 640, 480);
854 viewport_set_background(device, viewport, background);
855
856 hr = IDirect3DViewport_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET);
857 ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr);
858 color = get_surface_color(surface, 320, 240);
859 ok(compare_color(color, 0x00ff0000, 1), "Got unexpected color 0x%08x.\n", color);
860
861 cleanup:
862 if (viewport)
863 destroy_viewport(device, viewport);
864 if (background)
865 destroy_material(background);
866 if (surface3) IDirectDrawSurface3_Release(surface3);
867 if (surface) IDirectDrawSurface_Release(surface);
868 if (device) IDirect3DDevice_Release(device);
869 if (d3d) IDirect3D_Release(d3d);
870 if (ddraw) IDirectDraw_Release(ddraw);
871 DestroyWindow(window);
872 }
873
874 static void test_coop_level_threaded(void)
875 {
876 struct create_window_thread_param p;
877 IDirectDraw *ddraw;
878 HRESULT hr;
879
880 if (!(ddraw = create_ddraw()))
881 {
882 skip("Failed to create a ddraw object, skipping test.\n");
883 return;
884 }
885 create_window_thread(&p);
886
887 hr = IDirectDraw_SetCooperativeLevel(ddraw, p.window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
888 ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
889
890 IDirectDraw_Release(ddraw);
891 destroy_window_thread(&p);
892 }
893
894 static ULONG get_refcount(IUnknown *test_iface)
895 {
896 IUnknown_AddRef(test_iface);
897 return IUnknown_Release(test_iface);
898 }
899
900 static void test_viewport_interfaces(void)
901 {
902 IDirectDraw *ddraw;
903 IDirect3D *d3d;
904 HRESULT hr;
905 ULONG ref;
906 IDirect3DViewport *viewport;
907 IDirect3DViewport2 *viewport2;
908 IDirect3DViewport3 *viewport3;
909 IDirectDrawGammaControl *gamma;
910 IUnknown *unknown;
911
912 if (!(ddraw = create_ddraw()))
913 {
914 skip("Failed to create ddraw object, skipping test.\n");
915 return;
916 }
917 hr = IDirectDraw_QueryInterface(ddraw, &IID_IDirect3D, (void **)&d3d);
918 ok(SUCCEEDED(hr) || hr == E_NOINTERFACE, "Failed to get d3d interface, hr %#x.\n", hr);
919 if (FAILED(hr))
920 {
921 skip("Direct3D not available, skipping tests\n");
922 IDirectDraw_Release(ddraw);
923 return;
924 }
925 ref = get_refcount((IUnknown *)d3d);
926 ok(ref == 2, "IDirect3D refcount is %d\n", ref);
927
928 hr = IDirect3D_CreateViewport(d3d, &viewport, NULL);
929 ok(SUCCEEDED(hr), "Failed to create viewport, hr %#x.\n", hr);
930 ref = get_refcount((IUnknown *)viewport);
931 ok(ref == 1, "Initial IDirect3DViewport refcount is %u\n", ref);
932 ref = get_refcount((IUnknown *)d3d);
933 ok(ref == 2, "IDirect3D refcount is %u\n", ref);
934
935 /* E_FAIL return values are returned by Winetestbot Windows NT machines. While not supporting
936 * newer interfaces is legitimate for old ddraw versions, E_FAIL violates Microsoft's rules
937 * for QueryInterface, hence the broken() */
938 gamma = (IDirectDrawGammaControl *)0xdeadbeef;
939 hr = IDirect3DViewport_QueryInterface(viewport, &IID_IDirectDrawGammaControl, (void **)&gamma);
940 ok(hr == E_NOINTERFACE || broken(hr == E_FAIL), "Got unexpected hr %#x.\n", hr);
941 ok(gamma == NULL, "Interface not set to NULL by failed QI call: %p\n", gamma);
942 if (SUCCEEDED(hr)) IDirectDrawGammaControl_Release(gamma);
943 /* NULL iid: Segfaults */
944
945 hr = IDirect3DViewport_QueryInterface(viewport, &IID_IDirect3DViewport2, (void **)&viewport2);
946 ok(SUCCEEDED(hr) || hr == E_NOINTERFACE || broken(hr == E_FAIL),
947 "Failed to QI IDirect3DViewport2, hr %#x.\n", hr);
948 if (viewport2)
949 {
950 ref = get_refcount((IUnknown *)viewport);
951 ok(ref == 2, "IDirect3DViewport refcount is %u\n", ref);
952 ref = get_refcount((IUnknown *)viewport2);
953 ok(ref == 2, "IDirect3DViewport2 refcount is %u\n", ref);
954 IDirect3DViewport2_Release(viewport2);
955 viewport2 = NULL;
956 }
957
958 hr = IDirect3DViewport_QueryInterface(viewport, &IID_IDirect3DViewport3, (void **)&viewport3);
959 ok(SUCCEEDED(hr) || hr == E_NOINTERFACE || broken(hr == E_FAIL),
960 "Failed to QI IDirect3DViewport3, hr %#x.\n", hr);
961 if (viewport3)
962 {
963 ref = get_refcount((IUnknown *)viewport);
964 ok(ref == 2, "IDirect3DViewport refcount is %u\n", ref);
965 ref = get_refcount((IUnknown *)viewport3);
966 ok(ref == 2, "IDirect3DViewport3 refcount is %u\n", ref);
967 IDirect3DViewport3_Release(viewport3);
968 }
969
970 hr = IDirect3DViewport_QueryInterface(viewport, &IID_IUnknown, (void **)&unknown);
971 ok(SUCCEEDED(hr), "Failed to QI IUnknown, hr %#x.\n", hr);
972 if (unknown)
973 {
974 ref = get_refcount((IUnknown *)viewport);
975 ok(ref == 2, "IDirect3DViewport refcount is %u\n", ref);
976 ref = get_refcount(unknown);
977 ok(ref == 2, "IUnknown refcount is %u\n", ref);
978 IUnknown_Release(unknown);
979 }
980
981 IDirect3DViewport_Release(viewport);
982 IDirect3D_Release(d3d);
983 IDirectDraw_Release(ddraw);
984 }
985
986 static void test_zenable(void)
987 {
988 static D3DRECT clear_rect = {{0}, {0}, {640}, {480}};
989 static D3DTLVERTEX tquad[] =
990 {
991 {{ 0.0f}, {480.0f}, {-0.5f}, {1.0f}, {0xff00ff00}, {0x00000000}, {0.0f}, {0.0f}},
992 {{ 0.0f}, { 0.0f}, {-0.5f}, {1.0f}, {0xff00ff00}, {0x00000000}, {0.0f}, {0.0f}},
993 {{640.0f}, {480.0f}, { 1.5f}, {1.0f}, {0xff00ff00}, {0x00000000}, {0.0f}, {0.0f}},
994 {{640.0f}, { 0.0f}, { 1.5f}, {1.0f}, {0xff00ff00}, {0x00000000}, {0.0f}, {0.0f}},
995 };
996 IDirect3DExecuteBuffer *execute_buffer;
997 D3DEXECUTEBUFFERDESC exec_desc;
998 IDirect3DMaterial *background;
999 IDirect3DViewport *viewport;
1000 D3DEXECUTEDATA exec_data;
1001 IDirect3DDevice *device;
1002 IDirectDrawSurface *rt;
1003 IDirectDraw *ddraw;
1004 UINT inst_length;
1005 D3DCOLOR color;
1006 HWND window;
1007 HRESULT hr;
1008 UINT x, y;
1009 UINT i, j;
1010 void *ptr;
1011
1012 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1013 0, 0, 640, 480, 0, 0, 0, 0);
1014 if (!(ddraw = create_ddraw()))
1015 {
1016 skip("Failed to create ddraw object, skipping test.\n");
1017 DestroyWindow(window);
1018 return;
1019 }
1020 if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
1021 {
1022 skip("Failed to create D3D device, skipping test.\n");
1023 IDirectDraw_Release(ddraw);
1024 DestroyWindow(window);
1025 return;
1026 }
1027
1028 background = create_diffuse_material(device, 1.0f, 0.0f, 0.0f, 1.0f);
1029 viewport = create_viewport(device, 0, 0, 640, 480);
1030 viewport_set_background(device, viewport, background);
1031
1032 memset(&exec_desc, 0, sizeof(exec_desc));
1033 exec_desc.dwSize = sizeof(exec_desc);
1034 exec_desc.dwFlags = D3DDEB_BUFSIZE | D3DDEB_CAPS;
1035 exec_desc.dwBufferSize = 1024;
1036 exec_desc.dwCaps = D3DDEBCAPS_SYSTEMMEMORY;
1037
1038 hr = IDirect3DDevice_CreateExecuteBuffer(device, &exec_desc, &execute_buffer, NULL);
1039 ok(SUCCEEDED(hr), "Failed to create execute buffer, hr %#x.\n", hr);
1040 hr = IDirect3DExecuteBuffer_Lock(execute_buffer, &exec_desc);
1041 ok(SUCCEEDED(hr), "Failed to lock execute buffer, hr %#x.\n", hr);
1042 memcpy(exec_desc.lpData, tquad, sizeof(tquad));
1043 ptr = ((BYTE *)exec_desc.lpData) + sizeof(tquad);
1044 emit_process_vertices(&ptr, 0, 4);
1045 emit_set_rs(&ptr, D3DRENDERSTATE_ZENABLE, D3DZB_FALSE);
1046 emit_tquad(&ptr, 0);
1047 emit_end(&ptr);
1048 inst_length = (BYTE *)ptr - (BYTE *)exec_desc.lpData;
1049 inst_length -= sizeof(tquad);
1050 hr = IDirect3DExecuteBuffer_Unlock(execute_buffer);
1051 ok(SUCCEEDED(hr), "Failed to unlock execute buffer, hr %#x.\n", hr);
1052
1053 memset(&exec_data, 0, sizeof(exec_data));
1054 exec_data.dwSize = sizeof(exec_data);
1055 exec_data.dwVertexCount = 4;
1056 exec_data.dwInstructionOffset = sizeof(tquad);
1057 exec_data.dwInstructionLength = inst_length;
1058 hr = IDirect3DExecuteBuffer_SetExecuteData(execute_buffer, &exec_data);
1059 ok(SUCCEEDED(hr), "Failed to set execute data, hr %#x.\n", hr);
1060
1061 hr = IDirect3DViewport_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET);
1062 ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
1063 hr = IDirect3DDevice_BeginScene(device);
1064 ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
1065 hr = IDirect3DDevice_Execute(device, execute_buffer, viewport, D3DEXECUTE_CLIPPED);
1066 ok(SUCCEEDED(hr), "Failed to execute exec buffer, hr %#x.\n", hr);
1067 hr = IDirect3DDevice_EndScene(device);
1068 ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
1069
1070 hr = IDirect3DDevice_QueryInterface(device, &IID_IDirectDrawSurface, (void **)&rt);
1071 ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
1072 for (i = 0; i < 4; ++i)
1073 {
1074 for (j = 0; j < 4; ++j)
1075 {
1076 x = 80 * ((2 * j) + 1);
1077 y = 60 * ((2 * i) + 1);
1078 color = get_surface_color(rt, x, y);
1079 ok(compare_color(color, 0x0000ff00, 1),
1080 "Expected color 0x0000ff00 at %u, %u, got 0x%08x.\n", x, y, color);
1081 }
1082 }
1083 IDirectDrawSurface_Release(rt);
1084
1085 destroy_viewport(device, viewport);
1086 IDirect3DExecuteBuffer_Release(execute_buffer);
1087 destroy_material(background);
1088 IDirect3DDevice_Release(device);
1089 IDirectDraw_Release(ddraw);
1090 DestroyWindow(window);
1091 }
1092
1093 static void test_ck_rgba(void)
1094 {
1095 static D3DRECT clear_rect = {{0}, {0}, {640}, {480}};
1096 static D3DTLVERTEX tquad[] =
1097 {
1098 {{ 0.0f}, {480.0f}, {0.25f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {0.0f}},
1099 {{ 0.0f}, { 0.0f}, {0.25f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {1.0f}},
1100 {{640.0f}, {480.0f}, {0.25f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {0.0f}},
1101 {{640.0f}, { 0.0f}, {0.25f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {1.0f}},
1102 {{ 0.0f}, {480.0f}, {0.75f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {0.0f}},
1103 {{ 0.0f}, { 0.0f}, {0.75f}, {1.0f}, {0xffffffff}, {0x00000000}, {0.0f}, {1.0f}},
1104 {{640.0f}, {480.0f}, {0.75f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {0.0f}},
1105 {{640.0f}, { 0.0f}, {0.75f}, {1.0f}, {0xffffffff}, {0x00000000}, {1.0f}, {1.0f}},
1106 };
1107 static const struct
1108 {
1109 D3DCOLOR fill_color;
1110 BOOL color_key;
1111 BOOL blend;
1112 D3DCOLOR result1;
1113 D3DCOLOR result2;
1114 }
1115 tests[] =
1116 {
1117 {0xff00ff00, TRUE, TRUE, 0x00ff0000, 0x000000ff},
1118 {0xff00ff00, TRUE, FALSE, 0x00ff0000, 0x000000ff},
1119 {0xff00ff00, FALSE, TRUE, 0x0000ff00, 0x0000ff00},
1120 {0xff00ff00, FALSE, FALSE, 0x0000ff00, 0x0000ff00},
1121 {0x7f00ff00, TRUE, TRUE, 0x00807f00, 0x00807f00},
1122 {0x7f00ff00, TRUE, FALSE, 0x0000ff00, 0x0000ff00},
1123 {0x7f00ff00, FALSE, TRUE, 0x00807f00, 0x00807f00},
1124 {0x7f00ff00, FALSE, FALSE, 0x0000ff00, 0x0000ff00},
1125 };
1126
1127 IDirect3DExecuteBuffer *execute_buffer;
1128 D3DTEXTUREHANDLE texture_handle;
1129 D3DEXECUTEBUFFERDESC exec_desc;
1130 IDirect3DMaterial *background;
1131 IDirectDrawSurface *surface;
1132 IDirect3DViewport *viewport;
1133 DDSURFACEDESC surface_desc;
1134 IDirect3DTexture *texture;
1135 IDirect3DDevice *device;
1136 IDirectDrawSurface *rt;
1137 IDirectDraw *ddraw;
1138 D3DCOLOR color;
1139 HWND window;
1140 DDBLTFX fx;
1141 HRESULT hr;
1142 UINT i;
1143
1144 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1145 0, 0, 640, 480, 0, 0, 0, 0);
1146 if (!(ddraw = create_ddraw()))
1147 {
1148 skip("Failed to create ddraw object, skipping test.\n");
1149 DestroyWindow(window);
1150 return;
1151 }
1152 if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
1153 {
1154 skip("Failed to create D3D device, skipping test.\n");
1155 DestroyWindow(window);
1156 return;
1157 }
1158
1159 background = create_diffuse_material(device, 1.0, 0.0f, 0.0f, 1.0f);
1160 viewport = create_viewport(device, 0, 0, 640, 480);
1161 viewport_set_background(device, viewport, background);
1162
1163 memset(&surface_desc, 0, sizeof(surface_desc));
1164 surface_desc.dwSize = sizeof(surface_desc);
1165 surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CKSRCBLT;
1166 surface_desc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1167 surface_desc.dwWidth = 256;
1168 surface_desc.dwHeight = 256;
1169 surface_desc.ddpfPixelFormat.dwSize = sizeof(surface_desc.ddpfPixelFormat);
1170 surface_desc.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
1171 U1(surface_desc.ddpfPixelFormat).dwRGBBitCount = 32;
1172 U2(surface_desc.ddpfPixelFormat).dwRBitMask = 0x00ff0000;
1173 U3(surface_desc.ddpfPixelFormat).dwGBitMask = 0x0000ff00;
1174 U4(surface_desc.ddpfPixelFormat).dwBBitMask = 0x000000ff;
1175 U5(surface_desc.ddpfPixelFormat).dwRGBAlphaBitMask = 0xff000000;
1176 surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue = 0xff00ff00;
1177 surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue = 0xff00ff00;
1178 hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &surface, NULL);
1179 ok(SUCCEEDED(hr), "Failed to create destination surface, hr %#x.\n", hr);
1180 hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirect3DTexture, (void **)&texture);
1181 ok(SUCCEEDED(hr), "Failed to get texture interface, hr %#x.\n", hr);
1182 hr = IDirect3DTexture_GetHandle(texture, device, &texture_handle);
1183 ok(SUCCEEDED(hr), "Failed to get texture handle, hr %#x.\n", hr);
1184 IDirect3DTexture_Release(texture);
1185
1186 memset(&exec_desc, 0, sizeof(exec_desc));
1187 exec_desc.dwSize = sizeof(exec_desc);
1188 exec_desc.dwFlags = D3DDEB_BUFSIZE | D3DDEB_CAPS;
1189 exec_desc.dwBufferSize = 1024;
1190 exec_desc.dwCaps = D3DDEBCAPS_SYSTEMMEMORY;
1191 hr = IDirect3DDevice_CreateExecuteBuffer(device, &exec_desc, &execute_buffer, NULL);
1192 ok(SUCCEEDED(hr), "Failed to create execute buffer, hr %#x.\n", hr);
1193
1194 hr = IDirect3DDevice_QueryInterface(device, &IID_IDirectDrawSurface, (void **)&rt);
1195 ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr);
1196
1197 for (i = 0; i < sizeof(tests) / sizeof(*tests); ++i)
1198 {
1199 UINT draw1_len, draw2_len;
1200 D3DEXECUTEDATA exec_data;
1201 void *ptr;
1202
1203 hr = IDirect3DExecuteBuffer_Lock(execute_buffer, &exec_desc);
1204 ok(SUCCEEDED(hr), "Failed to lock execute buffer, hr %#x.\n", hr);
1205 memcpy(exec_desc.lpData, tquad, sizeof(tquad));
1206 ptr = ((BYTE *)exec_desc.lpData) + sizeof(tquad);
1207 emit_process_vertices(&ptr, 0, 4);
1208 emit_set_rs(&ptr, D3DRENDERSTATE_TEXTUREHANDLE, texture_handle);
1209 emit_set_rs(&ptr, D3DRENDERSTATE_SRCBLEND, D3DBLEND_SRCALPHA);
1210 emit_set_rs(&ptr, D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA);
1211 emit_set_rs(&ptr, D3DRENDERSTATE_COLORKEYENABLE, tests[i].color_key);
1212 emit_set_rs(&ptr, D3DRENDERSTATE_ALPHABLENDENABLE, tests[i].blend);
1213 emit_tquad(&ptr, 0);
1214 emit_end(&ptr);
1215 draw1_len = (BYTE *)ptr - (BYTE *)exec_desc.lpData - sizeof(tquad);
1216 emit_process_vertices(&ptr, 4, 4);
1217 emit_tquad(&ptr, 0);
1218 emit_set_rs(&ptr, D3DRENDERSTATE_TEXTUREHANDLE, 0);
1219 emit_end(&ptr);
1220 draw2_len = (BYTE *)ptr - (BYTE *)exec_desc.lpData - draw1_len;
1221 hr = IDirect3DExecuteBuffer_Unlock(execute_buffer);
1222 ok(SUCCEEDED(hr), "Failed to unlock execute buffer, hr %#x.\n", hr);
1223
1224 memset(&fx, 0, sizeof(fx));
1225 fx.dwSize = sizeof(fx);
1226 U5(fx).dwFillColor = tests[i].fill_color;
1227 hr = IDirectDrawSurface_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
1228 ok(SUCCEEDED(hr), "Failed to fill texture, hr %#x.\n", hr);
1229
1230 memset(&exec_data, 0, sizeof(exec_data));
1231 exec_data.dwSize = sizeof(exec_data);
1232 exec_data.dwVertexCount = 8;
1233 exec_data.dwInstructionOffset = sizeof(tquad);
1234 exec_data.dwInstructionLength = draw1_len;
1235 hr = IDirect3DExecuteBuffer_SetExecuteData(execute_buffer, &exec_data);
1236 ok(SUCCEEDED(hr), "Failed to set execute data, hr %#x.\n", hr);
1237
1238 hr = IDirect3DViewport_Clear(viewport, 1, &clear_rect, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER);
1239 ok(SUCCEEDED(hr), "Failed to clear viewport, hr %#x.\n", hr);
1240 hr = IDirect3DDevice_BeginScene(device);
1241 ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
1242 hr = IDirect3DDevice_Execute(device, execute_buffer, viewport, D3DEXECUTE_CLIPPED);
1243 ok(SUCCEEDED(hr), "Failed to execute exec buffer, hr %#x.\n", hr);
1244 hr = IDirect3DDevice_EndScene(device);
1245 ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
1246
1247 color = get_surface_color(rt, 320, 240);
1248 if (i == 2 || i == 3)
1249 todo_wine ok(compare_color(color, tests[i].result1, 1), "Expected color 0x%08x for test %u, got 0x%08x.\n",
1250 tests[i].result1, i, color);
1251 else
1252 ok(compare_color(color, tests[i].result1, 1), "Expected color 0x%08x for test %u, got 0x%08x.\n",
1253 tests[i].result1, i, color);
1254
1255 U5(fx).dwFillColor = 0xff0000ff;
1256 hr = IDirectDrawSurface_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
1257 ok(SUCCEEDED(hr), "Failed to fill texture, hr %#x.\n", hr);
1258
1259 exec_data.dwInstructionOffset = sizeof(tquad) + draw1_len;
1260 exec_data.dwInstructionLength = draw2_len;
1261 hr = IDirect3DExecuteBuffer_SetExecuteData(execute_buffer, &exec_data);
1262 ok(SUCCEEDED(hr), "Failed to set execute data, hr %#x.\n", hr);
1263
1264 hr = IDirect3DDevice_BeginScene(device);
1265 ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr);
1266 hr = IDirect3DDevice_Execute(device, execute_buffer, viewport, D3DEXECUTE_CLIPPED);
1267 ok(SUCCEEDED(hr), "Failed to execute exec buffer, hr %#x.\n", hr);
1268 hr = IDirect3DDevice_EndScene(device);
1269 ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr);
1270
1271 /* This tests that fragments that are masked out by the color key are
1272 * discarded, instead of just fully transparent. */
1273 color = get_surface_color(rt, 320, 240);
1274 if (i == 2 || i == 3)
1275 todo_wine ok(compare_color(color, tests[i].result2, 1), "Expected color 0x%08x for test %u, got 0x%08x.\n",
1276 tests[i].result2, i, color);
1277 else
1278 ok(compare_color(color, tests[i].result2, 1), "Expected color 0x%08x for test %u, got 0x%08x.\n",
1279 tests[i].result2, i, color);
1280 }
1281
1282 IDirectDrawSurface_Release(rt);
1283 IDirect3DExecuteBuffer_Release(execute_buffer);
1284 IDirectDrawSurface_Release(surface);
1285 destroy_viewport(device, viewport);
1286 destroy_material(background);
1287 IDirect3DDevice_Release(device);
1288 IDirectDraw_Release(ddraw);
1289 DestroyWindow(window);
1290 }
1291
1292 struct qi_test
1293 {
1294 REFIID iid;
1295 REFIID refcount_iid;
1296 HRESULT hr;
1297 };
1298
1299 static void test_qi(const char *test_name, IUnknown *base_iface,
1300 REFIID refcount_iid, const struct qi_test *tests, UINT entry_count)
1301 {
1302 ULONG refcount, expected_refcount;
1303 IUnknown *iface1, *iface2;
1304 HRESULT hr;
1305 UINT i, j;
1306
1307 for (i = 0; i < entry_count; ++i)
1308 {
1309 hr = IUnknown_QueryInterface(base_iface, tests[i].iid, (void **)&iface1);
1310 ok(hr == tests[i].hr, "Got hr %#x for test \"%s\" %u.\n", hr, test_name, i);
1311 if (SUCCEEDED(hr))
1312 {
1313 for (j = 0; j < entry_count; ++j)
1314 {
1315 hr = IUnknown_QueryInterface(iface1, tests[j].iid, (void **)&iface2);
1316 ok(hr == tests[j].hr, "Got hr %#x for test \"%s\" %u, %u.\n", hr, test_name, i, j);
1317 if (SUCCEEDED(hr))
1318 {
1319 expected_refcount = 0;
1320 if (IsEqualGUID(refcount_iid, tests[j].refcount_iid))
1321 ++expected_refcount;
1322 if (IsEqualGUID(tests[i].refcount_iid, tests[j].refcount_iid))
1323 ++expected_refcount;
1324 refcount = IUnknown_Release(iface2);
1325 ok(refcount == expected_refcount, "Got refcount %u for test \"%s\" %u, %u, expected %u.\n",
1326 refcount, test_name, i, j, expected_refcount);
1327 }
1328 }
1329
1330 expected_refcount = 0;
1331 if (IsEqualGUID(refcount_iid, tests[i].refcount_iid))
1332 ++expected_refcount;
1333 refcount = IUnknown_Release(iface1);
1334 ok(refcount == expected_refcount, "Got refcount %u for test \"%s\" %u, expected %u.\n",
1335 refcount, test_name, i, expected_refcount);
1336 }
1337 }
1338 }
1339
1340 static void test_surface_qi(void)
1341 {
1342 static const struct qi_test tests[] =
1343 {
1344 {&IID_IDirect3DTexture2, &IID_IDirectDrawSurface, S_OK },
1345 {&IID_IDirect3DTexture, &IID_IDirectDrawSurface, S_OK },
1346 {&IID_IDirectDrawGammaControl, &IID_IDirectDrawGammaControl, S_OK },
1347 {&IID_IDirectDrawColorControl, NULL, E_NOINTERFACE},
1348 {&IID_IDirectDrawSurface7, &IID_IDirectDrawSurface7, S_OK },
1349 {&IID_IDirectDrawSurface4, &IID_IDirectDrawSurface4, S_OK },
1350 {&IID_IDirectDrawSurface3, &IID_IDirectDrawSurface3, S_OK },
1351 {&IID_IDirectDrawSurface2, &IID_IDirectDrawSurface2, S_OK },
1352 {&IID_IDirectDrawSurface, &IID_IDirectDrawSurface, S_OK },
1353 {&IID_IDirect3DDevice7, NULL, E_INVALIDARG },
1354 {&IID_IDirect3DDevice3, NULL, E_INVALIDARG },
1355 {&IID_IDirect3DDevice2, NULL, E_INVALIDARG },
1356 {&IID_IDirect3DDevice, NULL, E_INVALIDARG },
1357 {&IID_IDirect3D7, NULL, E_INVALIDARG },
1358 {&IID_IDirect3D3, NULL, E_INVALIDARG },
1359 {&IID_IDirect3D2, NULL, E_INVALIDARG },
1360 {&IID_IDirect3D, NULL, E_INVALIDARG },
1361 {&IID_IDirectDraw7, NULL, E_INVALIDARG },
1362 {&IID_IDirectDraw4, NULL, E_INVALIDARG },
1363 {&IID_IDirectDraw3, NULL, E_INVALIDARG },
1364 {&IID_IDirectDraw2, NULL, E_INVALIDARG },
1365 {&IID_IDirectDraw, NULL, E_INVALIDARG },
1366 {&IID_IDirect3DLight, NULL, E_INVALIDARG },
1367 {&IID_IDirect3DMaterial, NULL, E_INVALIDARG },
1368 {&IID_IDirect3DMaterial2, NULL, E_INVALIDARG },
1369 {&IID_IDirect3DMaterial3, NULL, E_INVALIDARG },
1370 {&IID_IDirect3DExecuteBuffer, NULL, E_INVALIDARG },
1371 {&IID_IDirect3DViewport, NULL, E_INVALIDARG },
1372 {&IID_IDirect3DViewport2, NULL, E_INVALIDARG },
1373 {&IID_IDirect3DViewport3, NULL, E_INVALIDARG },
1374 {&IID_IDirect3DVertexBuffer, NULL, E_INVALIDARG },
1375 {&IID_IDirect3DVertexBuffer7, NULL, E_INVALIDARG },
1376 {&IID_IDirectDrawPalette, NULL, E_INVALIDARG },
1377 {&IID_IDirectDrawClipper, NULL, E_INVALIDARG },
1378 {&IID_IUnknown, &IID_IDirectDrawSurface, S_OK },
1379 };
1380
1381 IDirectDrawSurface *surface;
1382 DDSURFACEDESC surface_desc;
1383 IDirect3DDevice *device;
1384 IDirectDraw *ddraw;
1385 HWND window;
1386 HRESULT hr;
1387
1388 if (!GetProcAddress(GetModuleHandleA("ddraw.dll"), "DirectDrawCreateEx"))
1389 {
1390 win_skip("DirectDrawCreateEx not available, skipping test.\n");
1391 return;
1392 }
1393
1394 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1395 0, 0, 640, 480, 0, 0, 0, 0);
1396 if (!(ddraw = create_ddraw()))
1397 {
1398 skip("Failed to create a ddraw object, skipping test.\n");
1399 return;
1400 }
1401 /* Try to create a D3D device to see if the ddraw implementation supports
1402 * D3D. 64-bit ddraw in particular doesn't seem to support D3D, and
1403 * doesn't support e.g. the IDirect3DTexture interfaces. */
1404 if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
1405 {
1406 skip("Failed to create D3D device, skipping test.\n");
1407 DestroyWindow(window);
1408 return;
1409 }
1410 IDirect3DDevice_Release(device);
1411
1412 memset(&surface_desc, 0, sizeof(surface_desc));
1413 surface_desc.dwSize = sizeof(surface_desc);
1414 surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
1415 surface_desc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1416 surface_desc.dwWidth = 512;
1417 surface_desc.dwHeight = 512;
1418 hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &surface, NULL);
1419 ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
1420
1421 test_qi("surface_qi", (IUnknown *)surface, &IID_IDirectDrawSurface, tests, sizeof(tests) / sizeof(*tests));
1422
1423 IDirectDrawSurface_Release(surface);
1424 IDirectDraw_Release(ddraw);
1425 DestroyWindow(window);
1426 }
1427
1428 static void test_device_qi(void)
1429 {
1430 static const struct qi_test tests[] =
1431 {
1432 {&IID_IDirect3DTexture2, &IID_IDirectDrawSurface, S_OK },
1433 {&IID_IDirect3DTexture, &IID_IDirectDrawSurface, S_OK },
1434 {&IID_IDirectDrawGammaControl, &IID_IDirectDrawGammaControl, S_OK },
1435 {&IID_IDirectDrawColorControl, NULL, E_NOINTERFACE},
1436 {&IID_IDirectDrawSurface7, &IID_IDirectDrawSurface7, S_OK },
1437 {&IID_IDirectDrawSurface4, &IID_IDirectDrawSurface4, S_OK },
1438 {&IID_IDirectDrawSurface3, &IID_IDirectDrawSurface3, S_OK },
1439 {&IID_IDirectDrawSurface2, &IID_IDirectDrawSurface2, S_OK },
1440 {&IID_IDirectDrawSurface, &IID_IDirectDrawSurface, S_OK },
1441 {&IID_IDirect3DDevice7, NULL, E_INVALIDARG },
1442 {&IID_IDirect3DDevice3, NULL, E_INVALIDARG },
1443 {&IID_IDirect3DDevice2, NULL, E_INVALIDARG },
1444 {&IID_IDirect3DDevice, NULL, E_INVALIDARG },
1445 {&IID_IDirect3DHALDevice, &IID_IDirectDrawSurface, S_OK },
1446 {&IID_IDirect3D7, NULL, E_INVALIDARG },
1447 {&IID_IDirect3D3, NULL, E_INVALIDARG },
1448 {&IID_IDirect3D2, NULL, E_INVALIDARG },
1449 {&IID_IDirect3D, NULL, E_INVALIDARG },
1450 {&IID_IDirectDraw7, NULL, E_INVALIDARG },
1451 {&IID_IDirectDraw4, NULL, E_INVALIDARG },
1452 {&IID_IDirectDraw3, NULL, E_INVALIDARG },
1453 {&IID_IDirectDraw2, NULL, E_INVALIDARG },
1454 {&IID_IDirectDraw, NULL, E_INVALIDARG },
1455 {&IID_IDirect3DLight, NULL, E_INVALIDARG },
1456 {&IID_IDirect3DMaterial, NULL, E_INVALIDARG },
1457 {&IID_IDirect3DMaterial2, NULL, E_INVALIDARG },
1458 {&IID_IDirect3DMaterial3, NULL, E_INVALIDARG },
1459 {&IID_IDirect3DExecuteBuffer, NULL, E_INVALIDARG },
1460 {&IID_IDirect3DViewport, NULL, E_INVALIDARG },
1461 {&IID_IDirect3DViewport2, NULL, E_INVALIDARG },
1462 {&IID_IDirect3DViewport3, NULL, E_INVALIDARG },
1463 {&IID_IDirect3DVertexBuffer, NULL, E_INVALIDARG },
1464 {&IID_IDirect3DVertexBuffer7, NULL, E_INVALIDARG },
1465 {&IID_IDirectDrawPalette, NULL, E_INVALIDARG },
1466 {&IID_IDirectDrawClipper, NULL, E_INVALIDARG },
1467 {&IID_IUnknown, &IID_IDirectDrawSurface, S_OK },
1468 };
1469
1470
1471 IDirect3DDevice *device;
1472 IDirectDraw *ddraw;
1473 HWND window;
1474
1475 if (!GetProcAddress(GetModuleHandleA("ddraw.dll"), "DirectDrawCreateEx"))
1476 {
1477 win_skip("DirectDrawCreateEx not available, skipping test.\n");
1478 return;
1479 }
1480
1481 window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
1482 0, 0, 640, 480, 0, 0, 0, 0);
1483 if (!(ddraw = create_ddraw()))
1484 {
1485 skip("Failed to create ddraw object, skipping test.\n");
1486 DestroyWindow(window);
1487 return;
1488 }
1489 if (!(device = create_device(ddraw, window, DDSCL_NORMAL)))
1490 {
1491 skip("Failed to create D3D device, skipping test.\n");
1492 DestroyWindow(window);
1493 return;
1494 }
1495
1496 test_qi("device_qi", (IUnknown *)device, &IID_IDirectDrawSurface, tests, sizeof(tests) / sizeof(*tests));
1497
1498 IDirect3DDevice_Release(device);
1499 IDirectDraw_Release(ddraw);
1500 DestroyWindow(window);
1501 }
1502
1503 START_TEST(ddraw1)
1504 {
1505 test_coop_level_create_device_window();
1506 test_clipper_blt();
1507 test_coop_level_d3d_state();
1508 test_surface_interface_mismatch();
1509 test_coop_level_threaded();
1510 test_viewport_interfaces();
1511 test_zenable();
1512 test_ck_rgba();
1513 test_surface_qi();
1514 test_device_qi();
1515 }
Maarten's multimedia branch