?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32/tests: Reorganize the DPI tests.
[wine.git] / dlls / ddraw / ddraw.c
blob32f01722630dd6e6e5a06f10c3a4eaa5c2c1173f
1 /*
2 * Copyright 1997-2000 Marcus Meissner
3 * Copyright 1998-2000 Lionel Ulmer
4 * Copyright 2000-2001 TransGaming Technologies Inc.
5 * Copyright 2006 Stefan Dösinger
6 * Copyright 2008 Denver Gingerich
7 * Copyright 2007-2008, 2011, 2013 Stefan Dösinger for CodeWeavers
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include "ddraw_private.h"
28
29 #include "wine/exception.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
32
33 static const struct ddraw *exclusive_ddraw;
34 static HWND exclusive_window;
35
36 /* Device identifier. Don't relay it to WineD3D */
37 static const DDDEVICEIDENTIFIER2 deviceidentifier =
38 {
39 "vga.dll", /* default 2D driver */
40 "DirectDraw HAL",
41 { { 0x00010001, 0x00010001 } },
42 0, 0, 0, 0,
43 /* a8373c10-7ac4-4deb-849a-009844d08b2d */
44 {0xa8373c10,0x7ac4,0x4deb, {0x84,0x9a,0x00,0x98,0x44,0xd0,0x8b,0x2d}},
45 0
46 };
47
48 static struct enum_device_entry
49 {
50 char interface_name[100];
51 char device_name[100];
52 const GUID *device_guid;
53 } device_list7[] =
54 {
55 /* T&L HAL device */
56 {
57 "WINE Direct3D7 Hardware Transform and Lighting acceleration using WineD3D",
58 "Wine D3D7 T&L HAL",
59 &IID_IDirect3DTnLHalDevice,
60 },
61
62 /* HAL device */
63 {
64 "WINE Direct3D7 Hardware acceleration using WineD3D",
65 "Direct3D HAL",
66 &IID_IDirect3DHALDevice,
67 },
68
69 /* RGB device */
70 {
71 "WINE Direct3D7 RGB Software Emulation using WineD3D",
72 "Wine D3D7 RGB",
73 &IID_IDirect3DRGBDevice,
74 },
75 };
76
77 static void STDMETHODCALLTYPE ddraw_null_wined3d_object_destroyed(void *parent) {}
78
79 const struct wined3d_parent_ops ddraw_null_wined3d_parent_ops =
80 {
81 ddraw_null_wined3d_object_destroyed,
82 };
83
84 static inline struct ddraw *impl_from_IDirectDraw(IDirectDraw *iface)
85 {
86 return CONTAINING_RECORD(iface, struct ddraw, IDirectDraw_iface);
87 }
88
89 static inline struct ddraw *impl_from_IDirectDraw2(IDirectDraw2 *iface)
90 {
91 return CONTAINING_RECORD(iface, struct ddraw, IDirectDraw2_iface);
92 }
93
94 static inline struct ddraw *impl_from_IDirectDraw4(IDirectDraw4 *iface)
95 {
96 return CONTAINING_RECORD(iface, struct ddraw, IDirectDraw4_iface);
97 }
98
99 static inline struct ddraw *impl_from_IDirectDraw7(IDirectDraw7 *iface)
100 {
101 return CONTAINING_RECORD(iface, struct ddraw, IDirectDraw7_iface);
102 }
103
104 static inline struct ddraw *impl_from_IDirect3D(IDirect3D *iface)
105 {
106 return CONTAINING_RECORD(iface, struct ddraw, IDirect3D_iface);
107 }
108
109 static inline struct ddraw *impl_from_IDirect3D2(IDirect3D2 *iface)
110 {
111 return CONTAINING_RECORD(iface, struct ddraw, IDirect3D2_iface);
112 }
113
114 static inline struct ddraw *impl_from_IDirect3D3(IDirect3D3 *iface)
115 {
116 return CONTAINING_RECORD(iface, struct ddraw, IDirect3D3_iface);
117 }
118
119 static inline struct ddraw *impl_from_IDirect3D7(IDirect3D7 *iface)
120 {
121 return CONTAINING_RECORD(iface, struct ddraw, IDirect3D7_iface);
122 }
123
124 static HRESULT WINAPI ddraw7_QueryInterface(IDirectDraw7 *iface, REFIID riid, void **out)
125 {
126 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
127
128 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
129
130 if (!riid)
131 {
132 *out = NULL;
133 return DDERR_INVALIDPARAMS;
134 }
135
136 /* The refcount unit test revealed that an IDirect3D7 interface can only
137 * be queried from a DirectDraw object that was created as an IDirectDraw7
138 * interface. The older interfaces can query any IDirect3D version except
139 * 7, because they are all initially created as IDirectDraw. This isn't
140 * really crucial behavior, and messy to implement with the common
141 * creation function, so it has been left out here. */
142 if (IsEqualGUID(&IID_IDirectDraw7, riid)
143 || IsEqualGUID(&IID_IUnknown, riid))
144 {
145 *out = &ddraw->IDirectDraw7_iface;
146 TRACE("Returning IDirectDraw7 interface %p.\n", *out);
147 }
148 else if (IsEqualGUID(&IID_IDirectDraw4, riid))
149 {
150 *out = &ddraw->IDirectDraw4_iface;
151 TRACE("Returning IDirectDraw4 interface %p.\n", *out);
152 }
153 else if (IsEqualGUID(&IID_IDirectDraw2, riid))
154 {
155 *out = &ddraw->IDirectDraw2_iface;
156 TRACE("Returning IDirectDraw2 interface %p.\n", *out);
157 }
158 else if (IsEqualGUID(&IID_IDirectDraw, riid))
159 {
160 *out = &ddraw->IDirectDraw_iface;
161 TRACE("Returning IDirectDraw interface %p.\n", *out);
162 }
163 else if (IsEqualGUID(&IID_IDirect3D7, riid))
164 {
165 ddraw->d3dversion = 7;
166 *out = &ddraw->IDirect3D7_iface;
167 TRACE("Returning Direct3D7 interface %p.\n", *out);
168 }
169 else if (IsEqualGUID(&IID_IDirect3D3, riid))
170 {
171 ddraw->d3dversion = 3;
172 *out = &ddraw->IDirect3D3_iface;
173 TRACE("Returning Direct3D3 interface %p.\n", *out);
174 }
175 else if (IsEqualGUID(&IID_IDirect3D2, riid))
176 {
177 ddraw->d3dversion = 2;
178 *out = &ddraw->IDirect3D2_iface;
179 TRACE("Returning Direct3D2 interface %p.\n", *out);
180 }
181 else if (IsEqualGUID(&IID_IDirect3D, riid))
182 {
183 ddraw->d3dversion = 1;
184 *out = &ddraw->IDirect3D_iface;
185 TRACE("Returning Direct3D interface %p.\n", *out);
186 }
187 /* Unknown interface */
188 else
189 {
190 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
191 *out = NULL;
192 return E_NOINTERFACE;
193 }
194
195 IUnknown_AddRef((IUnknown *)*out);
196 return S_OK;
197 }
198
199 static HRESULT WINAPI ddraw4_QueryInterface(IDirectDraw4 *iface, REFIID riid, void **object)
200 {
201 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
202
203 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
204
205 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
206 }
207
208 static HRESULT WINAPI ddraw2_QueryInterface(IDirectDraw2 *iface, REFIID riid, void **object)
209 {
210 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
211
212 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
213
214 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
215 }
216
217 static HRESULT WINAPI ddraw1_QueryInterface(IDirectDraw *iface, REFIID riid, void **object)
218 {
219 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
220
221 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
222
223 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
224 }
225
226 static HRESULT WINAPI d3d7_QueryInterface(IDirect3D7 *iface, REFIID riid, void **object)
227 {
228 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
229
230 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
231
232 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
233 }
234
235 static HRESULT WINAPI d3d3_QueryInterface(IDirect3D3 *iface, REFIID riid, void **object)
236 {
237 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
238
239 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
240
241 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
242 }
243
244 static HRESULT WINAPI d3d2_QueryInterface(IDirect3D2 *iface, REFIID riid, void **object)
245 {
246 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
247
248 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
249
250 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
251 }
252
253 static HRESULT WINAPI d3d1_QueryInterface(IDirect3D *iface, REFIID riid, void **object)
254 {
255 struct ddraw *ddraw = impl_from_IDirect3D(iface);
256
257 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
258
259 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
260 }
261
262 /*****************************************************************************
263 * IDirectDraw7::AddRef
264 *
265 * Increases the interfaces refcount, basically
266 *
267 * DDraw refcounting is a bit tricky. The different DirectDraw interface
268 * versions have individual refcounts, but the IDirect3D interfaces do not.
269 * All interfaces are from one object, that means calling QueryInterface on an
270 * IDirectDraw7 interface for an IDirectDraw4 interface does not create a new
271 * ddraw object.
272 *
273 * That means all AddRef and Release implementations of IDirectDrawX work
274 * with their own counter, and IDirect3DX::AddRef thunk to IDirectDraw (1),
275 * except of IDirect3D7 which thunks to IDirectDraw7
276 *
277 * Returns: The new refcount
278 *
279 *****************************************************************************/
280 static ULONG WINAPI ddraw7_AddRef(IDirectDraw7 *iface)
281 {
282 struct ddraw *This = impl_from_IDirectDraw7(iface);
283 ULONG ref = InterlockedIncrement(&This->ref7);
284
285 TRACE("%p increasing refcount to %u.\n", This, ref);
286
287 if(ref == 1) InterlockedIncrement(&This->numIfaces);
288
289 return ref;
290 }
291
292 static ULONG WINAPI ddraw4_AddRef(IDirectDraw4 *iface)
293 {
294 struct ddraw *This = impl_from_IDirectDraw4(iface);
295 ULONG ref = InterlockedIncrement(&This->ref4);
296
297 TRACE("%p increasing refcount to %u.\n", This, ref);
298
299 if (ref == 1) InterlockedIncrement(&This->numIfaces);
300
301 return ref;
302 }
303
304 static ULONG WINAPI ddraw2_AddRef(IDirectDraw2 *iface)
305 {
306 struct ddraw *This = impl_from_IDirectDraw2(iface);
307 ULONG ref = InterlockedIncrement(&This->ref2);
308
309 TRACE("%p increasing refcount to %u.\n", This, ref);
310
311 if (ref == 1) InterlockedIncrement(&This->numIfaces);
312
313 return ref;
314 }
315
316 static ULONG WINAPI ddraw1_AddRef(IDirectDraw *iface)
317 {
318 struct ddraw *This = impl_from_IDirectDraw(iface);
319 ULONG ref = InterlockedIncrement(&This->ref1);
320
321 TRACE("%p increasing refcount to %u.\n", This, ref);
322
323 if (ref == 1) InterlockedIncrement(&This->numIfaces);
324
325 return ref;
326 }
327
328 static ULONG WINAPI d3d7_AddRef(IDirect3D7 *iface)
329 {
330 struct ddraw *This = impl_from_IDirect3D7(iface);
331
332 TRACE("iface %p.\n", iface);
333
334 return ddraw7_AddRef(&This->IDirectDraw7_iface);
335 }
336
337 static ULONG WINAPI d3d3_AddRef(IDirect3D3 *iface)
338 {
339 struct ddraw *This = impl_from_IDirect3D3(iface);
340
341 TRACE("iface %p.\n", iface);
342
343 return ddraw1_AddRef(&This->IDirectDraw_iface);
344 }
345
346 static ULONG WINAPI d3d2_AddRef(IDirect3D2 *iface)
347 {
348 struct ddraw *This = impl_from_IDirect3D2(iface);
349
350 TRACE("iface %p.\n", iface);
351
352 return ddraw1_AddRef(&This->IDirectDraw_iface);
353 }
354
355 static ULONG WINAPI d3d1_AddRef(IDirect3D *iface)
356 {
357 struct ddraw *This = impl_from_IDirect3D(iface);
358
359 TRACE("iface %p.\n", iface);
360
361 return ddraw1_AddRef(&This->IDirectDraw_iface);
362 }
363
364 static void ddraw_destroy_swapchain(struct ddraw *ddraw)
365 {
366 TRACE("Destroying the swapchain.\n");
367
368 wined3d_swapchain_decref(ddraw->wined3d_swapchain);
369 ddraw->wined3d_swapchain = NULL;
370
371 if (!(ddraw->flags & DDRAW_NO3D))
372 {
373 UINT i;
374
375 for (i = 0; i < ddraw->numConvertedDecls; ++i)
376 {
377 wined3d_vertex_declaration_decref(ddraw->decls[i].decl);
378 }
379 heap_free(ddraw->decls);
380 ddraw->numConvertedDecls = 0;
381
382 if (FAILED(wined3d_device_uninit_3d(ddraw->wined3d_device)))
383 {
384 ERR("Failed to uninit 3D.\n");
385 }
386 else
387 {
388 /* Free the d3d window if one was created. */
389 if (ddraw->d3d_window && ddraw->d3d_window != ddraw->dest_window)
390 {
391 TRACE("Destroying the hidden render window %p.\n", ddraw->d3d_window);
392 DestroyWindow(ddraw->d3d_window);
393 ddraw->d3d_window = 0;
394 }
395 }
396
397 ddraw->flags &= ~DDRAW_D3D_INITIALIZED;
398 }
399 else
400 {
401 wined3d_device_uninit_gdi(ddraw->wined3d_device);
402 }
403
404 ddraw_set_swapchain_window(ddraw, NULL);
405
406 TRACE("Swapchain destroyed.\n");
407 }
408
409 /*****************************************************************************
410 * ddraw_destroy
411 *
412 * Destroys a ddraw object if all refcounts are 0. This is to share code
413 * between the IDirectDrawX::Release functions
414 *
415 * Params:
416 * This: DirectDraw object to destroy
417 *
418 *****************************************************************************/
419 static void ddraw_destroy(struct ddraw *This)
420 {
421 IDirectDraw7_SetCooperativeLevel(&This->IDirectDraw7_iface, NULL, DDSCL_NORMAL);
422 IDirectDraw7_RestoreDisplayMode(&This->IDirectDraw7_iface);
423
424 /* Destroy the device window if we created one */
425 if(This->devicewindow != 0)
426 {
427 TRACE(" (%p) Destroying the device window %p\n", This, This->devicewindow);
428 DestroyWindow(This->devicewindow);
429 This->devicewindow = 0;
430 }
431
432 wined3d_mutex_lock();
433 list_remove(&This->ddraw_list_entry);
434 wined3d_mutex_unlock();
435
436 if (This->wined3d_swapchain)
437 ddraw_destroy_swapchain(This);
438 wined3d_device_decref(This->wined3d_device);
439 wined3d_decref(This->wined3d);
440
441 if (This->d3ddevice)
442 This->d3ddevice->ddraw = NULL;
443
444 /* Now free the object */
445 heap_free(This);
446 }
447
448 /*****************************************************************************
449 * IDirectDraw7::Release
450 *
451 * Decreases the refcount. If the refcount falls to 0, the object is destroyed
452 *
453 * Returns: The new refcount
454 *****************************************************************************/
455 static ULONG WINAPI ddraw7_Release(IDirectDraw7 *iface)
456 {
457 struct ddraw *This = impl_from_IDirectDraw7(iface);
458 ULONG ref = InterlockedDecrement(&This->ref7);
459
460 TRACE("%p decreasing refcount to %u.\n", This, ref);
461
462 if (!ref && !InterlockedDecrement(&This->numIfaces))
463 ddraw_destroy(This);
464
465 return ref;
466 }
467
468 static ULONG WINAPI ddraw4_Release(IDirectDraw4 *iface)
469 {
470 struct ddraw *This = impl_from_IDirectDraw4(iface);
471 ULONG ref = InterlockedDecrement(&This->ref4);
472
473 TRACE("%p decreasing refcount to %u.\n", This, ref);
474
475 if (!ref && !InterlockedDecrement(&This->numIfaces))
476 ddraw_destroy(This);
477
478 return ref;
479 }
480
481 static ULONG WINAPI ddraw2_Release(IDirectDraw2 *iface)
482 {
483 struct ddraw *This = impl_from_IDirectDraw2(iface);
484 ULONG ref = InterlockedDecrement(&This->ref2);
485
486 TRACE("%p decreasing refcount to %u.\n", This, ref);
487
488 if (!ref && !InterlockedDecrement(&This->numIfaces))
489 ddraw_destroy(This);
490
491 return ref;
492 }
493
494 static ULONG WINAPI ddraw1_Release(IDirectDraw *iface)
495 {
496 struct ddraw *This = impl_from_IDirectDraw(iface);
497 ULONG ref = InterlockedDecrement(&This->ref1);
498
499 TRACE("%p decreasing refcount to %u.\n", This, ref);
500
501 if (!ref && !InterlockedDecrement(&This->numIfaces))
502 ddraw_destroy(This);
503
504 return ref;
505 }
506
507 static ULONG WINAPI d3d7_Release(IDirect3D7 *iface)
508 {
509 struct ddraw *This = impl_from_IDirect3D7(iface);
510
511 TRACE("iface %p.\n", iface);
512
513 return ddraw7_Release(&This->IDirectDraw7_iface);
514 }
515
516 static ULONG WINAPI d3d3_Release(IDirect3D3 *iface)
517 {
518 struct ddraw *This = impl_from_IDirect3D3(iface);
519
520 TRACE("iface %p.\n", iface);
521
522 return ddraw1_Release(&This->IDirectDraw_iface);
523 }
524
525 static ULONG WINAPI d3d2_Release(IDirect3D2 *iface)
526 {
527 struct ddraw *This = impl_from_IDirect3D2(iface);
528
529 TRACE("iface %p.\n", iface);
530
531 return ddraw1_Release(&This->IDirectDraw_iface);
532 }
533
534 static ULONG WINAPI d3d1_Release(IDirect3D *iface)
535 {
536 struct ddraw *This = impl_from_IDirect3D(iface);
537
538 TRACE("iface %p.\n", iface);
539
540 return ddraw1_Release(&This->IDirectDraw_iface);
541 }
542
543 /*****************************************************************************
544 * IDirectDraw methods
545 *****************************************************************************/
546
547 static HRESULT ddraw_set_focus_window(struct ddraw *ddraw, HWND window)
548 {
549 /* FIXME: This looks wrong, exclusive mode should imply a destination
550 * window. */
551 if ((ddraw->cooperative_level & DDSCL_EXCLUSIVE) && ddraw->dest_window)
552 {
553 TRACE("Setting DDSCL_SETFOCUSWINDOW with an already set window, returning DDERR_HWNDALREADYSET.\n");
554 return DDERR_HWNDALREADYSET;
555 }
556
557 ddraw->focuswindow = window;
558
559 return DD_OK;
560 }
561
562 static HRESULT ddraw_attach_d3d_device(struct ddraw *ddraw,
563 struct wined3d_swapchain_desc *swapchain_desc)
564 {
565 HWND window = swapchain_desc->device_window;
566 HRESULT hr;
567
568 TRACE("ddraw %p.\n", ddraw);
569
570 if (!window || window == GetDesktopWindow())
571 {
572 window = CreateWindowExA(0, DDRAW_WINDOW_CLASS_NAME, "Hidden D3D Window",
573 WS_DISABLED, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
574 NULL, NULL, NULL, NULL);
575 if (!window)
576 {
577 ERR("Failed to create window, last error %#x.\n", GetLastError());
578 return E_FAIL;
579 }
580
581 ShowWindow(window, SW_HIDE); /* Just to be sure */
582 WARN("No window for the Direct3DDevice, created hidden window %p.\n", window);
583
584 swapchain_desc->device_window = window;
585 }
586 else
587 {
588 TRACE("Using existing window %p for Direct3D rendering.\n", window);
589 }
590 ddraw->d3d_window = window;
591
592 /* Set this NOW, otherwise creating the depth stencil surface will cause a
593 * recursive loop until ram or emulated video memory is full. */
594 ddraw->flags |= DDRAW_D3D_INITIALIZED;
595 hr = wined3d_device_init_3d(ddraw->wined3d_device, swapchain_desc);
596 if (FAILED(hr))
597 {
598 ddraw->flags &= ~DDRAW_D3D_INITIALIZED;
599 return hr;
600 }
601
602 ddraw->declArraySize = 2;
603 if (!(ddraw->decls = heap_alloc_zero(ddraw->declArraySize * sizeof(*ddraw->decls))))
604 {
605 ERR("Error allocating an array for the converted vertex decls.\n");
606 ddraw->declArraySize = 0;
607 hr = wined3d_device_uninit_3d(ddraw->wined3d_device);
608 return E_OUTOFMEMORY;
609 }
610
611 TRACE("Successfully initialized 3D.\n");
612
613 return DD_OK;
614 }
615
616 static HRESULT ddraw_create_swapchain(struct ddraw *ddraw, HWND window, BOOL windowed)
617 {
618 struct wined3d_swapchain_desc swapchain_desc;
619 struct wined3d_display_mode mode;
620 HRESULT hr = WINED3D_OK;
621
622 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
623 {
624 ERR("Failed to get display mode.\n");
625 return hr;
626 }
627
628 memset(&swapchain_desc, 0, sizeof(swapchain_desc));
629 swapchain_desc.backbuffer_width = mode.width;
630 swapchain_desc.backbuffer_height = mode.height;
631 swapchain_desc.backbuffer_format = mode.format_id;
632 swapchain_desc.backbuffer_usage = 0;
633 swapchain_desc.backbuffer_count = 1;
634 swapchain_desc.swap_effect = WINED3D_SWAP_EFFECT_DISCARD;
635 swapchain_desc.device_window = window;
636 swapchain_desc.windowed = windowed;
637 swapchain_desc.flags = WINED3D_SWAPCHAIN_ALLOW_MODE_SWITCH;
638
639 if (!(ddraw->flags & DDRAW_NO3D))
640 hr = ddraw_attach_d3d_device(ddraw, &swapchain_desc);
641 else
642 hr = wined3d_device_init_gdi(ddraw->wined3d_device, &swapchain_desc);
643
644 if (FAILED(hr))
645 {
646 ERR("Failed to create swapchain, hr %#x.\n", hr);
647 return hr;
648 }
649
650 if (!(ddraw->wined3d_swapchain = wined3d_device_get_swapchain(ddraw->wined3d_device, 0)))
651 {
652 ERR("Failed to get swapchain.\n");
653 return DDERR_INVALIDPARAMS;
654 }
655
656 wined3d_swapchain_incref(ddraw->wined3d_swapchain);
657 ddraw_set_swapchain_window(ddraw, window);
658
659 if (ddraw->primary && ddraw->primary->palette)
660 wined3d_swapchain_set_palette(ddraw->wined3d_swapchain, ddraw->primary->palette->wined3d_palette);
661
662 return DD_OK;
663 }
664
665 /*****************************************************************************
666 * IDirectDraw7::RestoreDisplayMode
667 *
668 * Restores the display mode to what it was at creation time. Basically.
669 *
670 * Returns
671 * DD_OK on success
672 * DDERR_NOEXCLUSIVE mode if the device isn't in fullscreen mode
673 *
674 *****************************************************************************/
675 static HRESULT WINAPI ddraw7_RestoreDisplayMode(IDirectDraw7 *iface)
676 {
677 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
678 HRESULT hr;
679
680 TRACE("iface %p.\n", iface);
681
682 wined3d_mutex_lock();
683
684 if (!(ddraw->flags & DDRAW_RESTORE_MODE))
685 {
686 wined3d_mutex_unlock();
687 return DD_OK;
688 }
689
690 if (exclusive_ddraw && exclusive_ddraw != ddraw)
691 {
692 wined3d_mutex_unlock();
693 return DDERR_NOEXCLUSIVEMODE;
694 }
695
696 if (SUCCEEDED(hr = wined3d_set_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, NULL)))
697 ddraw->flags &= ~DDRAW_RESTORE_MODE;
698
699 InterlockedCompareExchange(&ddraw->device_state, DDRAW_DEVICE_STATE_NOT_RESTORED, DDRAW_DEVICE_STATE_OK);
700
701 wined3d_mutex_unlock();
702
703 return hr;
704 }
705
706 static HRESULT WINAPI ddraw4_RestoreDisplayMode(IDirectDraw4 *iface)
707 {
708 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
709
710 TRACE("iface %p.\n", iface);
711
712 return ddraw7_RestoreDisplayMode(&ddraw->IDirectDraw7_iface);
713 }
714
715 static HRESULT WINAPI ddraw2_RestoreDisplayMode(IDirectDraw2 *iface)
716 {
717 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
718
719 TRACE("iface %p.\n", iface);
720
721 return ddraw7_RestoreDisplayMode(&ddraw->IDirectDraw7_iface);
722 }
723
724 static HRESULT WINAPI ddraw1_RestoreDisplayMode(IDirectDraw *iface)
725 {
726 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
727
728 TRACE("iface %p.\n", iface);
729
730 return ddraw7_RestoreDisplayMode(&ddraw->IDirectDraw7_iface);
731 }
732
733 /*****************************************************************************
734 * IDirectDraw7::SetCooperativeLevel
735 *
736 * Sets the cooperative level for the DirectDraw object, and the window
737 * assigned to it. The cooperative level determines the general behavior
738 * of the DirectDraw application
739 *
740 * Warning: This is quite tricky, as it's not really documented which
741 * cooperative levels can be combined with each other. If a game fails
742 * after this function, try to check the cooperative levels passed on
743 * Windows, and if it returns something different.
744 *
745 * If you think that this function caused the failure because it writes a
746 * fixme, be sure to run again with a +ddraw trace.
747 *
748 * What is known about cooperative levels (See the ddraw modes test):
749 * DDSCL_EXCLUSIVE requires DDSCL_FULLSCREEN.
750 * DDSCL_NORMAL is not compatible with DDSCL_EXCLUSIVE.
751 * Unlike what msdn claims, DDSCL_NORMAL | DDSCL_FULLSCREEN is allowed.
752 * DDSCL_SETFOCUSWINDOW can be passed only in DDSCL_NORMAL mode, but after that
753 * DDSCL_EXCLUSIVE can be activated.
754 * DDSCL_SETFOCUSWINDOW may only be used with DDSCL_NOWINDOWCHANGES or
755 * DDSCL_CREATEDEVICEWINDOW.
756 *
757 * Handled flags: DDSCL_NORMAL, DDSCL_FULLSCREEN, DDSCL_EXCLUSIVE,
758 * DDSCL_CREATEDEVICEWINDOW, DDSCL_SETDEVICEWINDOW
759 * DDSCL_SETFOCUSWINDOW (partially),
760 * DDSCL_MULTITHREADED (work in progress)
761 * DDSCL_FPUPRESERVE (see device.c)
762 *
763 * Unsure about this: DDSCL_FPUSETUP
764 *
765 * These don't seem very important for wine:
766 * DDSCL_ALLOWREBOOT, DDSCL_NOWINDOWCHANGES, DDSCL_ALLOWMODEX
767 *
768 * Returns:
769 * DD_OK if the cooperative level was set successfully
770 * DDERR_INVALIDPARAMS if the passed cooperative level combination is invalid
771 * DDERR_HWNDALREADYSET if DDSCL_SETFOCUSWINDOW is passed in exclusive mode
772 * (Probably others too, have to investigate)
773 *
774 *****************************************************************************/
775 static HRESULT ddraw_set_cooperative_level(struct ddraw *ddraw, HWND window,
776 DWORD cooplevel, BOOL restore_mode_on_normal)
777 {
778 struct wined3d_rendertarget_view *rtv = NULL, *dsv = NULL;
779 struct wined3d_stateblock *stateblock;
780 BOOL restore_state = FALSE;
781 HRESULT hr;
782
783 TRACE("ddraw %p, window %p, flags %#x, restore_mode_on_normal %x.\n", ddraw, window, cooplevel,
784 restore_mode_on_normal);
785 DDRAW_dump_cooperativelevel(cooplevel);
786
787 wined3d_mutex_lock();
788
789 if (ddraw->flags & DDRAW_SCL_RECURSIVE)
790 {
791 WARN("Recursive call, returning DD_OK.\n");
792 hr = DD_OK;
793 goto done;
794 }
795 ddraw->flags |= DDRAW_SCL_RECURSIVE;
796
797 /* Tests suggest that we need one of them: */
798 if(!(cooplevel & (DDSCL_SETFOCUSWINDOW |
799 DDSCL_NORMAL |
800 DDSCL_EXCLUSIVE )))
801 {
802 TRACE("Incorrect cooplevel flags, returning DDERR_INVALIDPARAMS\n");
803 hr = DDERR_INVALIDPARAMS;
804 goto done;
805 }
806
807 if ((cooplevel & DDSCL_CREATEDEVICEWINDOW) && !(cooplevel & DDSCL_EXCLUSIVE))
808 {
809 WARN("DDSCL_CREATEDEVICEWINDOW requires DDSCL_EXCLUSIVE.\n");
810 hr = DDERR_INVALIDPARAMS;
811 goto done;
812 }
813
814 /* Handle those levels first which set various hwnds */
815 if ((cooplevel & DDSCL_SETFOCUSWINDOW) && !(cooplevel & DDSCL_CREATEDEVICEWINDOW))
816 {
817 /* This isn't compatible with a lot of flags */
818 if (cooplevel & (DDSCL_MULTITHREADED
819 | DDSCL_FPUSETUP
820 | DDSCL_FPUPRESERVE
821 | DDSCL_ALLOWREBOOT
822 | DDSCL_ALLOWMODEX
823 | DDSCL_SETDEVICEWINDOW
824 | DDSCL_NORMAL
825 | DDSCL_EXCLUSIVE
826 | DDSCL_FULLSCREEN))
827 {
828 WARN("Called with incompatible flags, returning DDERR_INVALIDPARAMS.\n");
829 hr = DDERR_INVALIDPARAMS;
830 goto done;
831 }
832
833 hr = ddraw_set_focus_window(ddraw, window);
834 goto done;
835 }
836
837 if (cooplevel & DDSCL_EXCLUSIVE)
838 {
839 if (!(cooplevel & DDSCL_FULLSCREEN) || !(window || (cooplevel & DDSCL_CREATEDEVICEWINDOW)))
840 {
841 WARN("DDSCL_EXCLUSIVE requires DDSCL_FULLSCREEN and a window.\n");
842 hr = DDERR_INVALIDPARAMS;
843 goto done;
844 }
845
846 if (cooplevel & DDSCL_CREATEDEVICEWINDOW)
847 {
848 HWND device_window;
849
850 if (!ddraw->focuswindow && !(cooplevel & DDSCL_SETFOCUSWINDOW))
851 {
852 WARN("No focus window set.\n");
853 hr = DDERR_NOFOCUSWINDOW;
854 goto done;
855 }
856
857 device_window = CreateWindowExA(0, DDRAW_WINDOW_CLASS_NAME, "DirectDrawDeviceWnd",
858 WS_POPUP, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
859 NULL, NULL, NULL, NULL);
860 if (!device_window)
861 {
862 ERR("Failed to create window, last error %#x.\n", GetLastError());
863 hr = E_FAIL;
864 goto done;
865 }
866
867 ShowWindow(device_window, SW_SHOW);
868 TRACE("Created a device window %p.\n", device_window);
869
870 /* Native apparently leaks the created device window if setting the
871 * focus window below fails. */
872 ddraw->cooperative_level |= DDSCL_CREATEDEVICEWINDOW;
873 ddraw->devicewindow = device_window;
874
875 if (cooplevel & DDSCL_SETFOCUSWINDOW)
876 {
877 if (!window)
878 {
879 hr = DDERR_NOHWND;
880 goto done;
881 }
882
883 if (FAILED(hr = ddraw_set_focus_window(ddraw, window)))
884 goto done;
885 }
886
887 window = device_window;
888 }
889 }
890 else
891 {
892 if (ddraw->cooperative_level & DDSCL_CREATEDEVICEWINDOW)
893 DestroyWindow(ddraw->devicewindow);
894 ddraw->devicewindow = NULL;
895 ddraw->focuswindow = NULL;
896 }
897
898 if ((cooplevel & DDSCL_FULLSCREEN) != (ddraw->cooperative_level & DDSCL_FULLSCREEN) || window != ddraw->dest_window)
899 {
900 if (ddraw->cooperative_level & DDSCL_FULLSCREEN)
901 wined3d_device_restore_fullscreen_window(ddraw->wined3d_device, ddraw->dest_window, NULL);
902
903 if (cooplevel & DDSCL_FULLSCREEN)
904 {
905 struct wined3d_display_mode display_mode;
906
907 wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &display_mode, NULL);
908 wined3d_device_setup_fullscreen_window(ddraw->wined3d_device, window,
909 display_mode.width, display_mode.height);
910 }
911 }
912
913 if ((cooplevel & DDSCL_EXCLUSIVE) && exclusive_window != window)
914 {
915 ddraw->device_state = DDRAW_DEVICE_STATE_NOT_RESTORED;
916 exclusive_window = window;
917 }
918
919 if (cooplevel & DDSCL_MULTITHREADED && !(ddraw->cooperative_level & DDSCL_MULTITHREADED))
920 wined3d_device_set_multithreaded(ddraw->wined3d_device);
921
922 if (ddraw->wined3d_swapchain)
923 {
924 if (!(ddraw->flags & DDRAW_NO3D))
925 {
926 restore_state = TRUE;
927
928 if (FAILED(hr = wined3d_stateblock_create(ddraw->wined3d_device, WINED3D_SBT_ALL, &stateblock)))
929 {
930 ERR("Failed to create stateblock, hr %#x.\n", hr);
931 goto done;
932 }
933
934 wined3d_stateblock_capture(stateblock);
935 rtv = wined3d_device_get_rendertarget_view(ddraw->wined3d_device, 0);
936 /* Rendering to ddraw->wined3d_frontbuffer. */
937 if (rtv && !wined3d_rendertarget_view_get_sub_resource_parent(rtv))
938 rtv = NULL;
939 else if (rtv)
940 wined3d_rendertarget_view_incref(rtv);
941
942 if ((dsv = wined3d_device_get_depth_stencil_view(ddraw->wined3d_device)))
943 wined3d_rendertarget_view_incref(dsv);
944 }
945
946 ddraw_destroy_swapchain(ddraw);
947 }
948
949 if (FAILED(hr = ddraw_create_swapchain(ddraw, window, !(cooplevel & DDSCL_FULLSCREEN))))
950 ERR("Failed to create swapchain, hr %#x.\n", hr);
951
952 if (restore_state)
953 {
954 if (dsv)
955 {
956 wined3d_device_set_depth_stencil_view(ddraw->wined3d_device, dsv);
957 wined3d_rendertarget_view_decref(dsv);
958 }
959
960 if (rtv)
961 {
962 wined3d_device_set_rendertarget_view(ddraw->wined3d_device, 0, rtv, FALSE);
963 wined3d_rendertarget_view_decref(rtv);
964 }
965
966 wined3d_stateblock_apply(stateblock);
967 wined3d_stateblock_decref(stateblock);
968 }
969
970 if (!(cooplevel & DDSCL_EXCLUSIVE) && (ddraw->cooperative_level & DDSCL_EXCLUSIVE)
971 && restore_mode_on_normal)
972 {
973 hr = ddraw7_RestoreDisplayMode(&ddraw->IDirectDraw7_iface);
974 if (FAILED(hr))
975 ERR("RestoreDisplayMode failed\n");
976 }
977
978 if ((ddraw->cooperative_level & DDSCL_EXCLUSIVE)
979 && (window != ddraw->dest_window || !(cooplevel & DDSCL_EXCLUSIVE)))
980 wined3d_device_release_focus_window(ddraw->wined3d_device);
981
982 if ((cooplevel & DDSCL_EXCLUSIVE)
983 && (window != ddraw->dest_window || !(ddraw->cooperative_level & DDSCL_EXCLUSIVE)))
984 {
985 hr = wined3d_device_acquire_focus_window(ddraw->wined3d_device, window);
986 if (FAILED(hr))
987 {
988 ERR("Failed to acquire focus window, hr %#x.\n", hr);
989 goto done;
990 }
991 }
992
993 /* Unhandled flags */
994 if (cooplevel & DDSCL_ALLOWREBOOT)
995 WARN("Unhandled flag DDSCL_ALLOWREBOOT, harmless\n");
996 if (cooplevel & DDSCL_ALLOWMODEX)
997 WARN("Unhandled flag DDSCL_ALLOWMODEX, harmless\n");
998 if (cooplevel & DDSCL_FPUSETUP)
999 WARN("Unhandled flag DDSCL_FPUSETUP, harmless\n");
1000
1001 if (cooplevel & DDSCL_EXCLUSIVE)
1002 exclusive_ddraw = ddraw;
1003 else if (exclusive_ddraw == ddraw)
1004 exclusive_ddraw = NULL;
1005
1006 /* Store the cooperative_level */
1007 ddraw->cooperative_level = cooplevel;
1008 ddraw->dest_window = window;
1009
1010 TRACE("SetCooperativeLevel returning DD_OK\n");
1011 hr = DD_OK;
1012 done:
1013 ddraw->flags &= ~DDRAW_SCL_RECURSIVE;
1014 wined3d_mutex_unlock();
1015
1016 return hr;
1017 }
1018
1019 static HRESULT WINAPI ddraw7_SetCooperativeLevel(IDirectDraw7 *iface, HWND window, DWORD flags)
1020 {
1021 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1022
1023 TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1024
1025 return ddraw_set_cooperative_level(ddraw, window, flags, !(ddraw->flags & DDRAW_SCL_DDRAW1));
1026 }
1027
1028 static HRESULT WINAPI ddraw4_SetCooperativeLevel(IDirectDraw4 *iface, HWND window, DWORD flags)
1029 {
1030 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1031
1032 TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1033
1034 return ddraw_set_cooperative_level(ddraw, window, flags, !(ddraw->flags & DDRAW_SCL_DDRAW1));
1035 }
1036
1037 static HRESULT WINAPI ddraw2_SetCooperativeLevel(IDirectDraw2 *iface, HWND window, DWORD flags)
1038 {
1039 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1040
1041 TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1042
1043 return ddraw_set_cooperative_level(ddraw, window, flags, !(ddraw->flags & DDRAW_SCL_DDRAW1));
1044 }
1045
1046 static HRESULT WINAPI ddraw1_SetCooperativeLevel(IDirectDraw *iface, HWND window, DWORD flags)
1047 {
1048 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1049 HRESULT hr;
1050
1051 TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1052
1053 hr = ddraw_set_cooperative_level(ddraw, window, flags, FALSE);
1054 if (SUCCEEDED(hr))
1055 ddraw->flags |= DDRAW_SCL_DDRAW1;
1056 return hr;
1057 }
1058
1059 /*****************************************************************************
1060 * IDirectDraw7::SetDisplayMode
1061 *
1062 * Sets the display screen resolution, color depth and refresh frequency
1063 * when in fullscreen mode (in theory).
1064 * Possible return values listed in the SDK suggest that this method fails
1065 * when not in fullscreen mode, but this is wrong. Windows 2000 happily sets
1066 * the display mode in DDSCL_NORMAL mode without an hwnd specified.
1067 * It seems to be valid to pass 0 for With and Height, this has to be tested
1068 * It could mean that the current video mode should be left as-is. (But why
1069 * call it then?)
1070 *
1071 * Params:
1072 * Height, Width: Screen dimension
1073 * BPP: Color depth in Bits per pixel
1074 * Refreshrate: Screen refresh rate
1075 * Flags: Other stuff
1076 *
1077 * Returns
1078 * DD_OK on success
1079 *
1080 *****************************************************************************/
1081 static HRESULT WINAPI ddraw7_SetDisplayMode(IDirectDraw7 *iface, DWORD width, DWORD height,
1082 DWORD bpp, DWORD refresh_rate, DWORD flags)
1083 {
1084 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1085 struct wined3d_display_mode mode;
1086 enum wined3d_format_id format;
1087 HRESULT hr;
1088
1089 TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
1090 iface, width, height, bpp, refresh_rate, flags);
1091
1092 if (force_refresh_rate != 0)
1093 {
1094 TRACE("ForceRefreshRate overriding passed-in refresh rate (%u Hz) to %u Hz\n",
1095 refresh_rate, force_refresh_rate);
1096 refresh_rate = force_refresh_rate;
1097 }
1098
1099 wined3d_mutex_lock();
1100
1101 if (exclusive_ddraw && exclusive_ddraw != ddraw)
1102 {
1103 wined3d_mutex_unlock();
1104 return DDERR_NOEXCLUSIVEMODE;
1105 }
1106
1107 if (!width || !height)
1108 {
1109 /* It looks like Need for Speed Porsche Unleashed expects DD_OK here. */
1110 wined3d_mutex_unlock();
1111 return DD_OK;
1112 }
1113
1114 switch (bpp)
1115 {
1116 case 8: format = WINED3DFMT_P8_UINT; break;
1117 case 15: format = WINED3DFMT_B5G5R5X1_UNORM; break;
1118 case 16: format = WINED3DFMT_B5G6R5_UNORM; break;
1119 case 24: format = WINED3DFMT_B8G8R8_UNORM; break;
1120 case 32: format = WINED3DFMT_B8G8R8X8_UNORM; break;
1121 default: format = WINED3DFMT_UNKNOWN; break;
1122 }
1123
1124 mode.width = width;
1125 mode.height = height;
1126 mode.refresh_rate = refresh_rate;
1127 mode.format_id = format;
1128 mode.scanline_ordering = WINED3D_SCANLINE_ORDERING_UNKNOWN;
1129
1130 /* TODO: The possible return values from msdn suggest that the screen mode
1131 * can't be changed if a surface is locked or some drawing is in progress. */
1132 if (SUCCEEDED(hr = wined3d_set_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode)))
1133 {
1134 if (ddraw->primary)
1135 {
1136 DDSURFACEDESC2 *surface_desc = &ddraw->primary->surface_desc;
1137
1138 if (FAILED(hr = wined3d_swapchain_resize_buffers(ddraw->wined3d_swapchain, 0,
1139 surface_desc->dwWidth, surface_desc->dwHeight, mode.format_id, WINED3D_MULTISAMPLE_NONE, 0)))
1140 ERR("Failed to resize buffers, hr %#x.\n", hr);
1141 else
1142 ddrawformat_from_wined3dformat(&ddraw->primary->surface_desc.u4.ddpfPixelFormat, mode.format_id);
1143 }
1144 ddraw->flags |= DDRAW_RESTORE_MODE;
1145 }
1146
1147 InterlockedCompareExchange(&ddraw->device_state, DDRAW_DEVICE_STATE_NOT_RESTORED, DDRAW_DEVICE_STATE_OK);
1148
1149 wined3d_mutex_unlock();
1150
1151 switch (hr)
1152 {
1153 case WINED3DERR_NOTAVAILABLE: return DDERR_UNSUPPORTED;
1154 default: return hr;
1155 }
1156 }
1157
1158 static HRESULT WINAPI ddraw4_SetDisplayMode(IDirectDraw4 *iface, DWORD width, DWORD height,
1159 DWORD bpp, DWORD refresh_rate, DWORD flags)
1160 {
1161 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1162
1163 TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
1164 iface, width, height, bpp, refresh_rate, flags);
1165
1166 return ddraw7_SetDisplayMode(&ddraw->IDirectDraw7_iface, width, height, bpp, refresh_rate, flags);
1167 }
1168
1169 static HRESULT WINAPI ddraw2_SetDisplayMode(IDirectDraw2 *iface,
1170 DWORD width, DWORD height, DWORD bpp, DWORD refresh_rate, DWORD flags)
1171 {
1172 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1173
1174 TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
1175 iface, width, height, bpp, refresh_rate, flags);
1176
1177 return ddraw7_SetDisplayMode(&ddraw->IDirectDraw7_iface, width, height, bpp, refresh_rate, flags);
1178 }
1179
1180 static HRESULT WINAPI ddraw1_SetDisplayMode(IDirectDraw *iface, DWORD width, DWORD height, DWORD bpp)
1181 {
1182 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1183
1184 TRACE("iface %p, width %u, height %u, bpp %u.\n", iface, width, height, bpp);
1185
1186 return ddraw7_SetDisplayMode(&ddraw->IDirectDraw7_iface, width, height, bpp, 0, 0);
1187 }
1188
1189 void ddraw_d3dcaps1_from_7(D3DDEVICEDESC *caps1, D3DDEVICEDESC7 *caps7)
1190 {
1191 memset(caps1, 0, sizeof(*caps1));
1192 caps1->dwSize = sizeof(*caps1);
1193 caps1->dwFlags = D3DDD_COLORMODEL
1194 | D3DDD_DEVCAPS
1195 | D3DDD_TRANSFORMCAPS
1196 | D3DDD_BCLIPPING
1197 | D3DDD_LIGHTINGCAPS
1198 | D3DDD_LINECAPS
1199 | D3DDD_TRICAPS
1200 | D3DDD_DEVICERENDERBITDEPTH
1201 | D3DDD_DEVICEZBUFFERBITDEPTH
1202 | D3DDD_MAXBUFFERSIZE
1203 | D3DDD_MAXVERTEXCOUNT;
1204 caps1->dcmColorModel = D3DCOLOR_RGB;
1205 caps1->dwDevCaps = caps7->dwDevCaps;
1206 caps1->dtcTransformCaps.dwSize = sizeof(caps1->dtcTransformCaps);
1207 caps1->dtcTransformCaps.dwCaps = D3DTRANSFORMCAPS_CLIP;
1208 caps1->bClipping = TRUE;
1209 caps1->dlcLightingCaps.dwSize = sizeof(caps1->dlcLightingCaps);
1210 caps1->dlcLightingCaps.dwCaps = D3DLIGHTCAPS_DIRECTIONAL
1211 | D3DLIGHTCAPS_PARALLELPOINT
1212 | D3DLIGHTCAPS_POINT
1213 | D3DLIGHTCAPS_SPOT;
1214 caps1->dlcLightingCaps.dwLightingModel = D3DLIGHTINGMODEL_RGB;
1215 caps1->dlcLightingCaps.dwNumLights = caps7->dwMaxActiveLights;
1216 caps1->dpcLineCaps = caps7->dpcLineCaps;
1217 caps1->dpcTriCaps = caps7->dpcTriCaps;
1218 caps1->dwDeviceRenderBitDepth = caps7->dwDeviceRenderBitDepth;
1219 caps1->dwDeviceZBufferBitDepth = caps7->dwDeviceZBufferBitDepth;
1220 caps1->dwMaxBufferSize = 0;
1221 caps1->dwMaxVertexCount = 65536;
1222 caps1->dwMinTextureWidth = caps7->dwMinTextureWidth;
1223 caps1->dwMinTextureHeight = caps7->dwMinTextureHeight;
1224 caps1->dwMaxTextureWidth = caps7->dwMaxTextureWidth;
1225 caps1->dwMaxTextureHeight = caps7->dwMaxTextureHeight;
1226 caps1->dwMinStippleWidth = 1;
1227 caps1->dwMinStippleHeight = 1;
1228 caps1->dwMaxStippleWidth = 32;
1229 caps1->dwMaxStippleHeight = 32;
1230 caps1->dwMaxTextureRepeat = caps7->dwMaxTextureRepeat;
1231 caps1->dwMaxTextureAspectRatio = caps7->dwMaxTextureAspectRatio;
1232 caps1->dwMaxAnisotropy = caps7->dwMaxAnisotropy;
1233 caps1->dvGuardBandLeft = caps7->dvGuardBandLeft;
1234 caps1->dvGuardBandTop = caps7->dvGuardBandTop;
1235 caps1->dvGuardBandRight = caps7->dvGuardBandRight;
1236 caps1->dvGuardBandBottom = caps7->dvGuardBandBottom;
1237 caps1->dvExtentsAdjust = caps7->dvExtentsAdjust;
1238 caps1->dwStencilCaps = caps7->dwStencilCaps;
1239 caps1->dwFVFCaps = caps7->dwFVFCaps;
1240 caps1->dwTextureOpCaps = caps7->dwTextureOpCaps;
1241 caps1->wMaxTextureBlendStages = caps7->wMaxTextureBlendStages;
1242 caps1->wMaxSimultaneousTextures = caps7->wMaxSimultaneousTextures;
1243 }
1244
1245 HRESULT ddraw_get_d3dcaps(const struct ddraw *ddraw, D3DDEVICEDESC7 *caps)
1246 {
1247 WINED3DCAPS wined3d_caps;
1248 HRESULT hr;
1249
1250 TRACE("ddraw %p, caps %p.\n", ddraw, caps);
1251
1252 memset(&wined3d_caps, 0, sizeof(wined3d_caps));
1253
1254 wined3d_mutex_lock();
1255 hr = wined3d_get_device_caps(ddraw->wined3d, 0, WINED3D_DEVICE_TYPE_HAL, &wined3d_caps);
1256 wined3d_mutex_unlock();
1257 if (FAILED(hr))
1258 {
1259 WARN("Failed to get device caps, hr %#x.\n", hr);
1260 return hr;
1261 }
1262
1263 caps->dwDevCaps = wined3d_caps.DevCaps;
1264 caps->dpcLineCaps.dwMiscCaps = wined3d_caps.PrimitiveMiscCaps;
1265 caps->dpcLineCaps.dwRasterCaps = wined3d_caps.RasterCaps;
1266 caps->dpcLineCaps.dwZCmpCaps = wined3d_caps.ZCmpCaps;
1267 caps->dpcLineCaps.dwSrcBlendCaps = wined3d_caps.SrcBlendCaps;
1268 caps->dpcLineCaps.dwDestBlendCaps = wined3d_caps.DestBlendCaps;
1269 caps->dpcLineCaps.dwAlphaCmpCaps = wined3d_caps.AlphaCmpCaps;
1270 caps->dpcLineCaps.dwShadeCaps = wined3d_caps.ShadeCaps;
1271 caps->dpcLineCaps.dwTextureCaps = wined3d_caps.TextureCaps;
1272 caps->dpcLineCaps.dwTextureFilterCaps = wined3d_caps.TextureFilterCaps;
1273 caps->dpcLineCaps.dwTextureAddressCaps = wined3d_caps.TextureAddressCaps;
1274
1275 caps->dwMaxTextureWidth = wined3d_caps.MaxTextureWidth;
1276 caps->dwMaxTextureHeight = wined3d_caps.MaxTextureHeight;
1277
1278 caps->dwMaxTextureRepeat = wined3d_caps.MaxTextureRepeat;
1279 caps->dwMaxTextureAspectRatio = wined3d_caps.MaxTextureAspectRatio;
1280 caps->dwMaxAnisotropy = wined3d_caps.MaxAnisotropy;
1281 caps->dvMaxVertexW = wined3d_caps.MaxVertexW;
1282
1283 caps->dvGuardBandLeft = wined3d_caps.GuardBandLeft;
1284 caps->dvGuardBandTop = wined3d_caps.GuardBandTop;
1285 caps->dvGuardBandRight = wined3d_caps.GuardBandRight;
1286 caps->dvGuardBandBottom = wined3d_caps.GuardBandBottom;
1287
1288 caps->dvExtentsAdjust = wined3d_caps.ExtentsAdjust;
1289 caps->dwStencilCaps = wined3d_caps.StencilCaps;
1290
1291 caps->dwFVFCaps = wined3d_caps.FVFCaps;
1292 caps->dwTextureOpCaps = wined3d_caps.TextureOpCaps;
1293
1294 caps->dwVertexProcessingCaps = wined3d_caps.VertexProcessingCaps;
1295 caps->dwMaxActiveLights = wined3d_caps.MaxActiveLights;
1296
1297 /* Remove all non-d3d7 caps */
1298 caps->dwDevCaps &= (
1299 D3DDEVCAPS_FLOATTLVERTEX | D3DDEVCAPS_SORTINCREASINGZ | D3DDEVCAPS_SORTDECREASINGZ |
1300 D3DDEVCAPS_SORTEXACT | D3DDEVCAPS_EXECUTESYSTEMMEMORY | D3DDEVCAPS_EXECUTEVIDEOMEMORY |
1301 D3DDEVCAPS_TLVERTEXSYSTEMMEMORY | D3DDEVCAPS_TLVERTEXVIDEOMEMORY | D3DDEVCAPS_TEXTURESYSTEMMEMORY |
1302 D3DDEVCAPS_TEXTUREVIDEOMEMORY | D3DDEVCAPS_DRAWPRIMTLVERTEX | D3DDEVCAPS_CANRENDERAFTERFLIP |
1303 D3DDEVCAPS_TEXTURENONLOCALVIDMEM | D3DDEVCAPS_DRAWPRIMITIVES2 | D3DDEVCAPS_SEPARATETEXTUREMEMORIES |
1304 D3DDEVCAPS_DRAWPRIMITIVES2EX | D3DDEVCAPS_HWTRANSFORMANDLIGHT | D3DDEVCAPS_CANBLTSYSTONONLOCAL |
1305 D3DDEVCAPS_HWRASTERIZATION);
1306
1307 caps->dwStencilCaps &= (
1308 D3DSTENCILCAPS_KEEP | D3DSTENCILCAPS_ZERO | D3DSTENCILCAPS_REPLACE |
1309 D3DSTENCILCAPS_INCRSAT | D3DSTENCILCAPS_DECRSAT | D3DSTENCILCAPS_INVERT |
1310 D3DSTENCILCAPS_INCR | D3DSTENCILCAPS_DECR);
1311
1312 /* FVF caps ?*/
1313
1314 caps->dwTextureOpCaps &= (
1315 D3DTEXOPCAPS_DISABLE | D3DTEXOPCAPS_SELECTARG1 | D3DTEXOPCAPS_SELECTARG2 |
1316 D3DTEXOPCAPS_MODULATE | D3DTEXOPCAPS_MODULATE2X | D3DTEXOPCAPS_MODULATE4X |
1317 D3DTEXOPCAPS_ADD | D3DTEXOPCAPS_ADDSIGNED | D3DTEXOPCAPS_ADDSIGNED2X |
1318 D3DTEXOPCAPS_SUBTRACT | D3DTEXOPCAPS_ADDSMOOTH | D3DTEXOPCAPS_BLENDTEXTUREALPHA |
1319 D3DTEXOPCAPS_BLENDFACTORALPHA | D3DTEXOPCAPS_BLENDTEXTUREALPHAPM | D3DTEXOPCAPS_BLENDCURRENTALPHA |
1320 D3DTEXOPCAPS_PREMODULATE | D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
1321 D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA | D3DTEXOPCAPS_BUMPENVMAP |
1322 D3DTEXOPCAPS_BUMPENVMAPLUMINANCE | D3DTEXOPCAPS_DOTPRODUCT3);
1323
1324 caps->dwVertexProcessingCaps &= (
1325 D3DVTXPCAPS_TEXGEN | D3DVTXPCAPS_MATERIALSOURCE7 | D3DVTXPCAPS_VERTEXFOG |
1326 D3DVTXPCAPS_DIRECTIONALLIGHTS | D3DVTXPCAPS_POSITIONALLIGHTS | D3DVTXPCAPS_LOCALVIEWER);
1327
1328 caps->dpcLineCaps.dwMiscCaps &= (
1329 D3DPMISCCAPS_MASKPLANES | D3DPMISCCAPS_MASKZ | D3DPMISCCAPS_LINEPATTERNREP |
1330 D3DPMISCCAPS_CONFORMANT | D3DPMISCCAPS_CULLNONE | D3DPMISCCAPS_CULLCW |
1331 D3DPMISCCAPS_CULLCCW);
1332
1333 caps->dpcLineCaps.dwRasterCaps &= (
1334 D3DPRASTERCAPS_DITHER | D3DPRASTERCAPS_ROP2 | D3DPRASTERCAPS_XOR |
1335 D3DPRASTERCAPS_PAT | D3DPRASTERCAPS_ZTEST | D3DPRASTERCAPS_SUBPIXEL |
1336 D3DPRASTERCAPS_SUBPIXELX | D3DPRASTERCAPS_FOGVERTEX | D3DPRASTERCAPS_FOGTABLE |
1337 D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT | D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT |
1338 D3DPRASTERCAPS_ANTIALIASEDGES | D3DPRASTERCAPS_MIPMAPLODBIAS | D3DPRASTERCAPS_ZBIAS |
1339 D3DPRASTERCAPS_ZBUFFERLESSHSR | D3DPRASTERCAPS_FOGRANGE | D3DPRASTERCAPS_ANISOTROPY |
1340 D3DPRASTERCAPS_WBUFFER | D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT | D3DPRASTERCAPS_WFOG |
1341 D3DPRASTERCAPS_ZFOG);
1342
1343 caps->dpcLineCaps.dwZCmpCaps &= (
1344 D3DPCMPCAPS_NEVER | D3DPCMPCAPS_LESS | D3DPCMPCAPS_EQUAL |
1345 D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_NOTEQUAL |
1346 D3DPCMPCAPS_GREATEREQUAL | D3DPCMPCAPS_ALWAYS);
1347
1348 caps->dpcLineCaps.dwSrcBlendCaps &= (
1349 D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR |
1350 D3DPBLENDCAPS_INVSRCCOLOR | D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA |
1351 D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_DESTCOLOR |
1352 D3DPBLENDCAPS_INVDESTCOLOR | D3DPBLENDCAPS_SRCALPHASAT | D3DPBLENDCAPS_BOTHSRCALPHA |
1353 D3DPBLENDCAPS_BOTHINVSRCALPHA);
1354
1355 caps->dpcLineCaps.dwDestBlendCaps &= (
1356 D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR |
1357 D3DPBLENDCAPS_INVSRCCOLOR | D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA |
1358 D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_DESTCOLOR |
1359 D3DPBLENDCAPS_INVDESTCOLOR | D3DPBLENDCAPS_SRCALPHASAT | D3DPBLENDCAPS_BOTHSRCALPHA |
1360 D3DPBLENDCAPS_BOTHINVSRCALPHA);
1361
1362 caps->dpcLineCaps.dwAlphaCmpCaps &= (
1363 D3DPCMPCAPS_NEVER | D3DPCMPCAPS_LESS | D3DPCMPCAPS_EQUAL |
1364 D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_NOTEQUAL |
1365 D3DPCMPCAPS_GREATEREQUAL | D3DPCMPCAPS_ALWAYS);
1366
1367 caps->dpcLineCaps.dwShadeCaps &= (
1368 D3DPSHADECAPS_COLORFLATMONO | D3DPSHADECAPS_COLORFLATRGB | D3DPSHADECAPS_COLORGOURAUDMONO |
1369 D3DPSHADECAPS_COLORGOURAUDRGB | D3DPSHADECAPS_COLORPHONGMONO | D3DPSHADECAPS_COLORPHONGRGB |
1370 D3DPSHADECAPS_SPECULARFLATMONO | D3DPSHADECAPS_SPECULARFLATRGB | D3DPSHADECAPS_SPECULARGOURAUDMONO |
1371 D3DPSHADECAPS_SPECULARGOURAUDRGB | D3DPSHADECAPS_SPECULARPHONGMONO | D3DPSHADECAPS_SPECULARPHONGRGB |
1372 D3DPSHADECAPS_ALPHAFLATBLEND | D3DPSHADECAPS_ALPHAFLATSTIPPLED | D3DPSHADECAPS_ALPHAGOURAUDBLEND |
1373 D3DPSHADECAPS_ALPHAGOURAUDSTIPPLED | D3DPSHADECAPS_ALPHAPHONGBLEND | D3DPSHADECAPS_ALPHAPHONGSTIPPLED |
1374 D3DPSHADECAPS_FOGFLAT | D3DPSHADECAPS_FOGGOURAUD | D3DPSHADECAPS_FOGPHONG);
1375
1376 caps->dpcLineCaps.dwTextureCaps &= (
1377 D3DPTEXTURECAPS_PERSPECTIVE | D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_ALPHA |
1378 D3DPTEXTURECAPS_TRANSPARENCY | D3DPTEXTURECAPS_BORDER | D3DPTEXTURECAPS_SQUAREONLY |
1379 D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE | D3DPTEXTURECAPS_ALPHAPALETTE| D3DPTEXTURECAPS_NONPOW2CONDITIONAL |
1380 D3DPTEXTURECAPS_PROJECTED | D3DPTEXTURECAPS_CUBEMAP | D3DPTEXTURECAPS_COLORKEYBLEND);
1381
1382 caps->dpcLineCaps.dwTextureFilterCaps &= (
1383 D3DPTFILTERCAPS_NEAREST | D3DPTFILTERCAPS_LINEAR | D3DPTFILTERCAPS_MIPNEAREST |
1384 D3DPTFILTERCAPS_MIPLINEAR | D3DPTFILTERCAPS_LINEARMIPNEAREST | D3DPTFILTERCAPS_LINEARMIPLINEAR |
1385 D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MINFLINEAR | D3DPTFILTERCAPS_MINFANISOTROPIC |
1386 D3DPTFILTERCAPS_MIPFPOINT | D3DPTFILTERCAPS_MIPFLINEAR | D3DPTFILTERCAPS_MAGFPOINT |
1387 D3DPTFILTERCAPS_MAGFLINEAR | D3DPTFILTERCAPS_MAGFANISOTROPIC | D3DPTFILTERCAPS_MAGFAFLATCUBIC |
1388 D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC);
1389
1390 caps->dpcLineCaps.dwTextureAddressCaps &= (
1391 D3DPTADDRESSCAPS_WRAP | D3DPTADDRESSCAPS_MIRROR | D3DPTADDRESSCAPS_CLAMP |
1392 D3DPTADDRESSCAPS_BORDER | D3DPTADDRESSCAPS_INDEPENDENTUV);
1393
1394 if (!(caps->dpcLineCaps.dwTextureCaps & D3DPTEXTURECAPS_POW2))
1395 {
1396 /* DirectX7 always has the np2 flag set, no matter what the card
1397 * supports. Some old games (Rollcage) check the caps incorrectly.
1398 * If wined3d supports nonpow2 textures it also has np2 conditional
1399 * support. */
1400 caps->dpcLineCaps.dwTextureCaps |= D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL;
1401 }
1402
1403 /* Fill the missing members, and do some fixup */
1404 caps->dpcLineCaps.dwSize = sizeof(caps->dpcLineCaps);
1405 caps->dpcLineCaps.dwTextureBlendCaps = D3DPTBLENDCAPS_ADD
1406 | D3DPTBLENDCAPS_MODULATEMASK
1407 | D3DPTBLENDCAPS_COPY
1408 | D3DPTBLENDCAPS_DECAL
1409 | D3DPTBLENDCAPS_DECALALPHA
1410 | D3DPTBLENDCAPS_DECALMASK
1411 | D3DPTBLENDCAPS_MODULATE
1412 | D3DPTBLENDCAPS_MODULATEALPHA;
1413 caps->dpcLineCaps.dwStippleWidth = 32;
1414 caps->dpcLineCaps.dwStippleHeight = 32;
1415 /* Use the same for the TriCaps */
1416 caps->dpcTriCaps = caps->dpcLineCaps;
1417
1418 caps->dwDeviceRenderBitDepth = DDBD_16 | DDBD_24 | DDBD_32;
1419 caps->dwDeviceZBufferBitDepth = DDBD_16 | DDBD_24;
1420 caps->dwMinTextureWidth = 1;
1421 caps->dwMinTextureHeight = 1;
1422
1423 /* Convert DWORDs safely to WORDs */
1424 caps->wMaxTextureBlendStages = min(wined3d_caps.MaxTextureBlendStages, 0xffff);
1425 caps->wMaxSimultaneousTextures = min(wined3d_caps.MaxSimultaneousTextures, 0xffff);
1426 caps->wMaxUserClipPlanes = min(wined3d_caps.MaxUserClipPlanes, D3DMAXUSERCLIPPLANES);
1427 caps->wMaxVertexBlendMatrices = min(wined3d_caps.MaxVertexBlendMatrices, 0xffff);
1428
1429 caps->deviceGUID = IID_IDirect3DTnLHalDevice;
1430
1431 caps->dwReserved1 = 0;
1432 caps->dwReserved2 = 0;
1433 caps->dwReserved3 = 0;
1434 caps->dwReserved4 = 0;
1435
1436 return DD_OK;
1437 }
1438
1439 /*****************************************************************************
1440 * IDirectDraw7::GetCaps
1441 *
1442 * Returns the drives capabilities
1443 *
1444 * Used for version 1, 2, 4 and 7
1445 *
1446 * Params:
1447 * DriverCaps: Structure to write the Hardware accelerated caps to
1448 * HelCaps: Structure to write the emulation caps to
1449 *
1450 * Returns
1451 * This implementation returns DD_OK only
1452 *
1453 *****************************************************************************/
1454 static HRESULT WINAPI ddraw7_GetCaps(IDirectDraw7 *iface, DDCAPS *DriverCaps, DDCAPS *HELCaps)
1455 {
1456 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1457 DDCAPS caps;
1458 WINED3DCAPS winecaps;
1459 HRESULT hr;
1460 DDSCAPS2 ddscaps = {0, 0, 0, {0}};
1461
1462 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, DriverCaps, HELCaps);
1463
1464 /* One structure must be != NULL */
1465 if (!DriverCaps && !HELCaps)
1466 {
1467 WARN("Invalid parameters.\n");
1468 return DDERR_INVALIDPARAMS;
1469 }
1470
1471 memset(&caps, 0, sizeof(caps));
1472 memset(&winecaps, 0, sizeof(winecaps));
1473 caps.dwSize = sizeof(caps);
1474
1475 wined3d_mutex_lock();
1476 hr = wined3d_device_get_device_caps(ddraw->wined3d_device, &winecaps);
1477 if (FAILED(hr))
1478 {
1479 WARN("Failed to get device caps, %#x.\n", hr);
1480 wined3d_mutex_unlock();
1481 return hr;
1482 }
1483
1484 hr = IDirectDraw7_GetAvailableVidMem(iface, &ddscaps, &caps.dwVidMemTotal, &caps.dwVidMemFree);
1485 if (FAILED(hr))
1486 {
1487 WARN("IDirectDraw7::GetAvailableVidMem failed\n");
1488 wined3d_mutex_unlock();
1489 return hr;
1490 }
1491
1492 hr = IDirectDraw7_GetFourCCCodes(iface, &caps.dwNumFourCCCodes, NULL);
1493 wined3d_mutex_unlock();
1494 if (FAILED(hr))
1495 {
1496 WARN("IDirectDraw7::GetFourCCCodes failed\n");
1497 return hr;
1498 }
1499
1500 caps.dwCaps = winecaps.ddraw_caps.caps;
1501 caps.dwCaps2 = winecaps.ddraw_caps.caps2;
1502 caps.dwCKeyCaps = winecaps.ddraw_caps.color_key_caps;
1503 caps.dwFXCaps = winecaps.ddraw_caps.fx_caps;
1504 caps.dwPalCaps = DDPCAPS_8BIT | DDPCAPS_PRIMARYSURFACE;
1505 caps.ddsCaps.dwCaps = winecaps.ddraw_caps.dds_caps;
1506 caps.dwSVBCaps = winecaps.ddraw_caps.svb_caps;
1507 caps.dwSVBCKeyCaps = winecaps.ddraw_caps.svb_color_key_caps;
1508 caps.dwSVBFXCaps = winecaps.ddraw_caps.svb_fx_caps;
1509 caps.dwVSBCaps = winecaps.ddraw_caps.vsb_caps;
1510 caps.dwVSBCKeyCaps = winecaps.ddraw_caps.vsb_color_key_caps;
1511 caps.dwVSBFXCaps = winecaps.ddraw_caps.vsb_fx_caps;
1512 caps.dwSSBCaps = winecaps.ddraw_caps.ssb_caps;
1513 caps.dwSSBCKeyCaps = winecaps.ddraw_caps.ssb_color_key_caps;
1514 caps.dwSSBFXCaps = winecaps.ddraw_caps.ssb_fx_caps;
1515
1516 caps.dwCaps |= DDCAPS_ALIGNSTRIDE;
1517 caps.dwAlignStrideAlign = DDRAW_STRIDE_ALIGNMENT;
1518
1519 if(DriverCaps)
1520 {
1521 DD_STRUCT_COPY_BYSIZE(DriverCaps, &caps);
1522 if (TRACE_ON(ddraw))
1523 {
1524 TRACE("Driver Caps :\n");
1525 DDRAW_dump_DDCAPS(DriverCaps);
1526 }
1527
1528 }
1529 if(HELCaps)
1530 {
1531 DD_STRUCT_COPY_BYSIZE(HELCaps, &caps);
1532 if (TRACE_ON(ddraw))
1533 {
1534 TRACE("HEL Caps :\n");
1535 DDRAW_dump_DDCAPS(HELCaps);
1536 }
1537 }
1538
1539 return DD_OK;
1540 }
1541
1542 static HRESULT WINAPI ddraw4_GetCaps(IDirectDraw4 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1543 {
1544 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1545
1546 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1547
1548 return ddraw7_GetCaps(&ddraw->IDirectDraw7_iface, driver_caps, hel_caps);
1549 }
1550
1551 static HRESULT WINAPI ddraw2_GetCaps(IDirectDraw2 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1552 {
1553 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1554
1555 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1556
1557 return ddraw7_GetCaps(&ddraw->IDirectDraw7_iface, driver_caps, hel_caps);
1558 }
1559
1560 static HRESULT WINAPI ddraw1_GetCaps(IDirectDraw *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1561 {
1562 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1563
1564 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1565
1566 return ddraw7_GetCaps(&ddraw->IDirectDraw7_iface, driver_caps, hel_caps);
1567 }
1568
1569 /*****************************************************************************
1570 * IDirectDraw7::Compact
1571 *
1572 * No idea what it does, MSDN says it's not implemented.
1573 *
1574 * Returns
1575 * DD_OK, but this is unchecked
1576 *
1577 *****************************************************************************/
1578 static HRESULT WINAPI ddraw7_Compact(IDirectDraw7 *iface)
1579 {
1580 TRACE("iface %p.\n", iface);
1581
1582 return DD_OK;
1583 }
1584
1585 static HRESULT WINAPI ddraw4_Compact(IDirectDraw4 *iface)
1586 {
1587 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1588
1589 TRACE("iface %p.\n", iface);
1590
1591 return ddraw7_Compact(&ddraw->IDirectDraw7_iface);
1592 }
1593
1594 static HRESULT WINAPI ddraw2_Compact(IDirectDraw2 *iface)
1595 {
1596 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1597
1598 TRACE("iface %p.\n", iface);
1599
1600 return ddraw7_Compact(&ddraw->IDirectDraw7_iface);
1601 }
1602
1603 static HRESULT WINAPI ddraw1_Compact(IDirectDraw *iface)
1604 {
1605 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1606
1607 TRACE("iface %p.\n", iface);
1608
1609 return ddraw7_Compact(&ddraw->IDirectDraw7_iface);
1610 }
1611
1612 /*****************************************************************************
1613 * IDirectDraw7::GetDisplayMode
1614 *
1615 * Returns information about the current display mode
1616 *
1617 * Exists in versions 1, 2, 4 and 7
1618 *
1619 * Params:
1620 * DDSD: Address of a surface description structure to write the info to
1621 *
1622 * Returns
1623 * DD_OK
1624 *
1625 *****************************************************************************/
1626 static HRESULT WINAPI ddraw7_GetDisplayMode(IDirectDraw7 *iface, DDSURFACEDESC2 *DDSD)
1627 {
1628 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1629 struct wined3d_display_mode mode;
1630 HRESULT hr;
1631
1632 TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
1633
1634 /* This seems sane */
1635 if (!DDSD || (DDSD->dwSize != sizeof(DDSURFACEDESC) && DDSD->dwSize != sizeof(DDSURFACEDESC2)))
1636 return DDERR_INVALIDPARAMS;
1637
1638 wined3d_mutex_lock();
1639
1640 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
1641 {
1642 ERR("Failed to get display mode, hr %#x.\n", hr);
1643 wined3d_mutex_unlock();
1644 return hr;
1645 }
1646
1647 memset(DDSD, 0, DDSD->dwSize);
1648 DDSD->dwSize = sizeof(*DDSD);
1649 DDSD->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
1650 DDSD->dwWidth = mode.width;
1651 DDSD->dwHeight = mode.height;
1652 DDSD->u2.dwRefreshRate = 60;
1653 DDSD->ddsCaps.dwCaps = 0;
1654 DDSD->u4.ddpfPixelFormat.dwSize = sizeof(DDSD->u4.ddpfPixelFormat);
1655 ddrawformat_from_wined3dformat(&DDSD->u4.ddpfPixelFormat, mode.format_id);
1656 DDSD->u1.lPitch = mode.width * DDSD->u4.ddpfPixelFormat.u1.dwRGBBitCount / 8;
1657
1658 if(TRACE_ON(ddraw))
1659 {
1660 TRACE("Returning surface desc :\n");
1661 DDRAW_dump_surface_desc(DDSD);
1662 }
1663
1664 wined3d_mutex_unlock();
1665
1666 return DD_OK;
1667 }
1668
1669 static HRESULT WINAPI ddraw4_GetDisplayMode(IDirectDraw4 *iface, DDSURFACEDESC2 *surface_desc)
1670 {
1671 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1672
1673 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1674
1675 return ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, surface_desc);
1676 }
1677
1678 static HRESULT WINAPI ddraw2_GetDisplayMode(IDirectDraw2 *iface, DDSURFACEDESC *surface_desc)
1679 {
1680 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1681 HRESULT hr;
1682
1683 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1684
1685 hr = ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
1686 if (SUCCEEDED(hr)) surface_desc->dwSize = sizeof(*surface_desc);
1687 return hr;
1688 }
1689
1690 static HRESULT WINAPI ddraw1_GetDisplayMode(IDirectDraw *iface, DDSURFACEDESC *surface_desc)
1691 {
1692 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1693 HRESULT hr;
1694
1695 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1696
1697 hr = ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
1698 if (SUCCEEDED(hr)) surface_desc->dwSize = sizeof(*surface_desc);
1699 return hr;
1700 }
1701
1702 /*****************************************************************************
1703 * IDirectDraw7::GetFourCCCodes
1704 *
1705 * Returns an array of supported FourCC codes.
1706 *
1707 * Exists in versions 1, 2, 4 and 7
1708 *
1709 * Params:
1710 * NumCodes: Contains the number of Codes that Codes can carry. Returns the number
1711 * of enumerated codes
1712 * Codes: Pointer to an array of DWORDs where the supported codes are written
1713 * to
1714 *
1715 * Returns
1716 * Always returns DD_OK, as it's a stub for now
1717 *
1718 *****************************************************************************/
1719 static HRESULT WINAPI ddraw7_GetFourCCCodes(IDirectDraw7 *iface, DWORD *NumCodes, DWORD *Codes)
1720 {
1721 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1722 static const enum wined3d_format_id formats[] =
1723 {
1724 WINED3DFMT_YUY2, WINED3DFMT_UYVY, WINED3DFMT_YV12,
1725 WINED3DFMT_DXT1, WINED3DFMT_DXT2, WINED3DFMT_DXT3, WINED3DFMT_DXT4, WINED3DFMT_DXT5,
1726 WINED3DFMT_ATI2N, WINED3DFMT_NVHU, WINED3DFMT_NVHS
1727 };
1728 struct wined3d_display_mode mode;
1729 DWORD count = 0, i, outsize;
1730 HRESULT hr;
1731
1732 TRACE("iface %p, codes_count %p, codes %p.\n", iface, NumCodes, Codes);
1733
1734 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
1735 {
1736 ERR("Failed to get display mode, hr %#x.\n", hr);
1737 return hr;
1738 }
1739
1740 outsize = NumCodes && Codes ? *NumCodes : 0;
1741
1742 for (i = 0; i < ARRAY_SIZE(formats); ++i)
1743 {
1744 if (SUCCEEDED(wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, WINED3D_DEVICE_TYPE_HAL,
1745 mode.format_id, 0, WINED3D_RTYPE_TEXTURE_2D, formats[i])))
1746 {
1747 if (count < outsize)
1748 Codes[count] = formats[i];
1749 ++count;
1750 }
1751 }
1752 if(NumCodes) {
1753 TRACE("Returning %u FourCC codes\n", count);
1754 *NumCodes = count;
1755 }
1756
1757 return DD_OK;
1758 }
1759
1760 static HRESULT WINAPI ddraw4_GetFourCCCodes(IDirectDraw4 *iface, DWORD *codes_count, DWORD *codes)
1761 {
1762 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1763
1764 TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1765
1766 return ddraw7_GetFourCCCodes(&ddraw->IDirectDraw7_iface, codes_count, codes);
1767 }
1768
1769 static HRESULT WINAPI ddraw2_GetFourCCCodes(IDirectDraw2 *iface, DWORD *codes_count, DWORD *codes)
1770 {
1771 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1772
1773 TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1774
1775 return ddraw7_GetFourCCCodes(&ddraw->IDirectDraw7_iface, codes_count, codes);
1776 }
1777
1778 static HRESULT WINAPI ddraw1_GetFourCCCodes(IDirectDraw *iface, DWORD *codes_count, DWORD *codes)
1779 {
1780 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1781
1782 TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1783
1784 return ddraw7_GetFourCCCodes(&ddraw->IDirectDraw7_iface, codes_count, codes);
1785 }
1786
1787 static HRESULT WINAPI ddraw7_GetMonitorFrequency(IDirectDraw7 *iface, DWORD *frequency)
1788 {
1789 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1790 struct wined3d_display_mode mode;
1791 HRESULT hr;
1792
1793 TRACE("iface %p, frequency %p.\n", iface, frequency);
1794
1795 wined3d_mutex_lock();
1796 hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL);
1797 wined3d_mutex_unlock();
1798 if (FAILED(hr))
1799 {
1800 WARN("Failed to get display mode, hr %#x.\n", hr);
1801 return hr;
1802 }
1803
1804 *frequency = mode.refresh_rate;
1805
1806 return DD_OK;
1807 }
1808
1809 static HRESULT WINAPI ddraw4_GetMonitorFrequency(IDirectDraw4 *iface, DWORD *frequency)
1810 {
1811 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1812
1813 TRACE("iface %p, frequency %p.\n", iface, frequency);
1814
1815 return ddraw7_GetMonitorFrequency(&ddraw->IDirectDraw7_iface, frequency);
1816 }
1817
1818 static HRESULT WINAPI ddraw2_GetMonitorFrequency(IDirectDraw2 *iface, DWORD *frequency)
1819 {
1820 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1821
1822 TRACE("iface %p, frequency %p.\n", iface, frequency);
1823
1824 return ddraw7_GetMonitorFrequency(&ddraw->IDirectDraw7_iface, frequency);
1825 }
1826
1827 static HRESULT WINAPI ddraw1_GetMonitorFrequency(IDirectDraw *iface, DWORD *frequency)
1828 {
1829 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1830
1831 TRACE("iface %p, frequency %p.\n", iface, frequency);
1832
1833 return ddraw7_GetMonitorFrequency(&ddraw->IDirectDraw7_iface, frequency);
1834 }
1835
1836 static HRESULT WINAPI ddraw7_GetVerticalBlankStatus(IDirectDraw7 *iface, BOOL *status)
1837 {
1838 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1839 struct wined3d_raster_status raster_status;
1840 HRESULT hr;
1841
1842 TRACE("iface %p, status %p.\n", iface, status);
1843
1844 if(!status)
1845 return DDERR_INVALIDPARAMS;
1846
1847 wined3d_mutex_lock();
1848 hr = wined3d_get_adapter_raster_status(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &raster_status);
1849 wined3d_mutex_unlock();
1850 if (FAILED(hr))
1851 {
1852 WARN("Failed to get raster status, hr %#x.\n", hr);
1853 return hr;
1854 }
1855
1856 *status = raster_status.in_vblank;
1857
1858 return DD_OK;
1859 }
1860
1861 static HRESULT WINAPI ddraw4_GetVerticalBlankStatus(IDirectDraw4 *iface, BOOL *status)
1862 {
1863 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1864
1865 TRACE("iface %p, status %p.\n", iface, status);
1866
1867 return ddraw7_GetVerticalBlankStatus(&ddraw->IDirectDraw7_iface, status);
1868 }
1869
1870 static HRESULT WINAPI ddraw2_GetVerticalBlankStatus(IDirectDraw2 *iface, BOOL *status)
1871 {
1872 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1873
1874 TRACE("iface %p, status %p.\n", iface, status);
1875
1876 return ddraw7_GetVerticalBlankStatus(&ddraw->IDirectDraw7_iface, status);
1877 }
1878
1879 static HRESULT WINAPI ddraw1_GetVerticalBlankStatus(IDirectDraw *iface, BOOL *status)
1880 {
1881 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1882
1883 TRACE("iface %p, status %p.\n", iface, status);
1884
1885 return ddraw7_GetVerticalBlankStatus(&ddraw->IDirectDraw7_iface, status);
1886 }
1887
1888 /*****************************************************************************
1889 * IDirectDraw7::GetAvailableVidMem
1890 *
1891 * Returns the total and free video memory
1892 *
1893 * Params:
1894 * caps: Specifies the memory type asked for
1895 * total: Pointer to a DWORD to be filled with the total memory
1896 * free: Pointer to a DWORD to be filled with the free memory
1897 *
1898 * Returns
1899 * DD_OK on success
1900 * DDERR_INVALIDPARAMS if free and total are NULL
1901 *
1902 *****************************************************************************/
1903 static HRESULT WINAPI ddraw7_GetAvailableVidMem(IDirectDraw7 *iface, DDSCAPS2 *caps, DWORD *total,
1904 DWORD *free)
1905 {
1906 unsigned int framebuffer_size, total_vidmem, free_vidmem;
1907 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1908 struct wined3d_display_mode mode;
1909 HRESULT hr = DD_OK;
1910
1911 TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1912
1913 if (!total && !free)
1914 return DDERR_INVALIDPARAMS;
1915
1916 if (TRACE_ON(ddraw))
1917 {
1918 TRACE("Asked for memory with description: ");
1919 DDRAW_dump_DDSCAPS2(caps);
1920 }
1921 wined3d_mutex_lock();
1922
1923 /* Todo: System memory vs local video memory vs non-local video memory
1924 * The MSDN also mentions differences between texture memory and other
1925 * resources, but that's not important
1926 */
1927
1928 /* Some applications (e.g. 3DMark 2000) assume that the reported amount of
1929 * video memory doesn't include the memory used by the default framebuffer.
1930 */
1931 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
1932 {
1933 WARN("Failed to get display mode, hr %#x.\n", hr);
1934 wined3d_mutex_unlock();
1935 return hr;
1936 }
1937 framebuffer_size = wined3d_calculate_format_pitch(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
1938 mode.format_id, mode.width);
1939 framebuffer_size *= mode.height;
1940
1941 if (free)
1942 {
1943 free_vidmem = wined3d_device_get_available_texture_mem(ddraw->wined3d_device);
1944 *free = framebuffer_size > free_vidmem ? 0 : free_vidmem - framebuffer_size;
1945 TRACE("Free video memory %#x.\n", *free);
1946 }
1947
1948 if (total)
1949 {
1950 struct wined3d_adapter_identifier desc = {0};
1951
1952 hr = wined3d_get_adapter_identifier(ddraw->wined3d, WINED3DADAPTER_DEFAULT, 0, &desc);
1953 total_vidmem = min(UINT_MAX, desc.video_memory);
1954 *total = framebuffer_size > total_vidmem ? 0 : total_vidmem - framebuffer_size;
1955 TRACE("Total video memory %#x.\n", *total);
1956 }
1957
1958 wined3d_mutex_unlock();
1959
1960 return hr;
1961 }
1962
1963 static HRESULT WINAPI ddraw4_GetAvailableVidMem(IDirectDraw4 *iface,
1964 DDSCAPS2 *caps, DWORD *total, DWORD *free)
1965 {
1966 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1967
1968 TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1969
1970 return ddraw7_GetAvailableVidMem(&ddraw->IDirectDraw7_iface, caps, total, free);
1971 }
1972
1973 static HRESULT WINAPI ddraw2_GetAvailableVidMem(IDirectDraw2 *iface,
1974 DDSCAPS *caps, DWORD *total, DWORD *free)
1975 {
1976 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1977 DDSCAPS2 caps2;
1978
1979 TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1980
1981 DDRAW_Convert_DDSCAPS_1_To_2(caps, &caps2);
1982 return ddraw7_GetAvailableVidMem(&ddraw->IDirectDraw7_iface, &caps2, total, free);
1983 }
1984
1985 /*****************************************************************************
1986 * IDirectDraw7::Initialize
1987 *
1988 * Initializes a DirectDraw interface.
1989 *
1990 * Params:
1991 * GUID: Interface identifier. Well, don't know what this is really good
1992 * for
1993 *
1994 * Returns
1995 * Returns DD_OK on the first call,
1996 * DDERR_ALREADYINITIALIZED on repeated calls
1997 *
1998 *****************************************************************************/
1999 static HRESULT WINAPI ddraw7_Initialize(IDirectDraw7 *iface, GUID *guid)
2000 {
2001 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2002
2003 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
2004
2005 if (ddraw->flags & DDRAW_INITIALIZED)
2006 return DDERR_ALREADYINITIALIZED;
2007
2008 /* FIXME: To properly take the GUID into account we should call
2009 * ddraw_init() here instead of in DDRAW_Create(). */
2010 if (guid)
2011 FIXME("Ignoring guid %s.\n", debugstr_guid(guid));
2012
2013 ddraw->flags |= DDRAW_INITIALIZED;
2014 return DD_OK;
2015 }
2016
2017 static HRESULT WINAPI ddraw4_Initialize(IDirectDraw4 *iface, GUID *guid)
2018 {
2019 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2020
2021 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
2022
2023 return ddraw7_Initialize(&ddraw->IDirectDraw7_iface, guid);
2024 }
2025
2026 static HRESULT WINAPI ddraw2_Initialize(IDirectDraw2 *iface, GUID *guid)
2027 {
2028 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2029
2030 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
2031
2032 return ddraw7_Initialize(&ddraw->IDirectDraw7_iface, guid);
2033 }
2034
2035 static HRESULT WINAPI ddraw1_Initialize(IDirectDraw *iface, GUID *guid)
2036 {
2037 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2038
2039 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
2040
2041 return ddraw7_Initialize(&ddraw->IDirectDraw7_iface, guid);
2042 }
2043
2044 static HRESULT WINAPI d3d1_Initialize(IDirect3D *iface, REFIID riid)
2045 {
2046 TRACE("iface %p, riid %s.\n", iface, debugstr_guid(riid));
2047
2048 return DDERR_ALREADYINITIALIZED;
2049 }
2050
2051 /*****************************************************************************
2052 * IDirectDraw7::FlipToGDISurface
2053 *
2054 * "Makes the surface that the GDI writes to the primary surface"
2055 * Looks like some windows specific thing we don't have to care about.
2056 * According to MSDN it permits GDI dialog boxes in FULLSCREEN mode. Good to
2057 * show error boxes ;)
2058 * Well, just return DD_OK.
2059 *
2060 * Returns:
2061 * Always returns DD_OK
2062 *
2063 *****************************************************************************/
2064 static HRESULT WINAPI ddraw7_FlipToGDISurface(IDirectDraw7 *iface)
2065 {
2066 FIXME("iface %p stub!\n", iface);
2067
2068 return DD_OK;
2069 }
2070
2071 static HRESULT WINAPI ddraw4_FlipToGDISurface(IDirectDraw4 *iface)
2072 {
2073 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2074
2075 TRACE("iface %p.\n", iface);
2076
2077 return ddraw7_FlipToGDISurface(&ddraw->IDirectDraw7_iface);
2078 }
2079
2080 static HRESULT WINAPI ddraw2_FlipToGDISurface(IDirectDraw2 *iface)
2081 {
2082 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2083
2084 TRACE("iface %p.\n", iface);
2085
2086 return ddraw7_FlipToGDISurface(&ddraw->IDirectDraw7_iface);
2087 }
2088
2089 static HRESULT WINAPI ddraw1_FlipToGDISurface(IDirectDraw *iface)
2090 {
2091 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2092
2093 TRACE("iface %p.\n", iface);
2094
2095 return ddraw7_FlipToGDISurface(&ddraw->IDirectDraw7_iface);
2096 }
2097
2098 /*****************************************************************************
2099 * IDirectDraw7::WaitForVerticalBlank
2100 *
2101 * This method allows applications to get in sync with the vertical blank
2102 * interval.
2103 * The wormhole demo in the DirectX 7 sdk uses this call, and it doesn't
2104 * redraw the screen, most likely because of this stub
2105 *
2106 * Parameters:
2107 * Flags: one of DDWAITVB_BLOCKBEGIN, DDWAITVB_BLOCKBEGINEVENT
2108 * or DDWAITVB_BLOCKEND
2109 * h: Not used, according to MSDN
2110 *
2111 * Returns:
2112 * Always returns DD_OK
2113 *
2114 *****************************************************************************/
2115 static HRESULT WINAPI ddraw7_WaitForVerticalBlank(IDirectDraw7 *iface, DWORD Flags, HANDLE event)
2116 {
2117 static BOOL hide;
2118
2119 TRACE("iface %p, flags %#x, event %p.\n", iface, Flags, event);
2120
2121 /* This function is called often, so print the fixme only once */
2122 if(!hide)
2123 {
2124 FIXME("iface %p, flags %#x, event %p stub!\n", iface, Flags, event);
2125 hide = TRUE;
2126 }
2127
2128 /* MSDN says DDWAITVB_BLOCKBEGINEVENT is not supported */
2129 if(Flags & DDWAITVB_BLOCKBEGINEVENT)
2130 return DDERR_UNSUPPORTED; /* unchecked */
2131
2132 return DD_OK;
2133 }
2134
2135 static HRESULT WINAPI ddraw4_WaitForVerticalBlank(IDirectDraw4 *iface, DWORD flags, HANDLE event)
2136 {
2137 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2138
2139 TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
2140
2141 return ddraw7_WaitForVerticalBlank(&ddraw->IDirectDraw7_iface, flags, event);
2142 }
2143
2144 static HRESULT WINAPI ddraw2_WaitForVerticalBlank(IDirectDraw2 *iface, DWORD flags, HANDLE event)
2145 {
2146 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2147
2148 TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
2149
2150 return ddraw7_WaitForVerticalBlank(&ddraw->IDirectDraw7_iface, flags, event);
2151 }
2152
2153 static HRESULT WINAPI ddraw1_WaitForVerticalBlank(IDirectDraw *iface, DWORD flags, HANDLE event)
2154 {
2155 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2156
2157 TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
2158
2159 return ddraw7_WaitForVerticalBlank(&ddraw->IDirectDraw7_iface, flags, event);
2160 }
2161
2162 static HRESULT WINAPI ddraw7_GetScanLine(IDirectDraw7 *iface, DWORD *Scanline)
2163 {
2164 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2165 struct wined3d_raster_status raster_status;
2166 HRESULT hr;
2167
2168 TRACE("iface %p, line %p.\n", iface, Scanline);
2169
2170 wined3d_mutex_lock();
2171 hr = wined3d_get_adapter_raster_status(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &raster_status);
2172 wined3d_mutex_unlock();
2173 if (FAILED(hr))
2174 {
2175 WARN("Failed to get raster status, hr %#x.\n", hr);
2176 return hr;
2177 }
2178
2179 *Scanline = raster_status.scan_line;
2180
2181 if (raster_status.in_vblank)
2182 return DDERR_VERTICALBLANKINPROGRESS;
2183
2184 return DD_OK;
2185 }
2186
2187 static HRESULT WINAPI ddraw4_GetScanLine(IDirectDraw4 *iface, DWORD *line)
2188 {
2189 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2190
2191 TRACE("iface %p, line %p.\n", iface, line);
2192
2193 return ddraw7_GetScanLine(&ddraw->IDirectDraw7_iface, line);
2194 }
2195
2196 static HRESULT WINAPI ddraw2_GetScanLine(IDirectDraw2 *iface, DWORD *line)
2197 {
2198 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2199
2200 TRACE("iface %p, line %p.\n", iface, line);
2201
2202 return ddraw7_GetScanLine(&ddraw->IDirectDraw7_iface, line);
2203 }
2204
2205 static HRESULT WINAPI ddraw1_GetScanLine(IDirectDraw *iface, DWORD *line)
2206 {
2207 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2208
2209 TRACE("iface %p, line %p.\n", iface, line);
2210
2211 return ddraw7_GetScanLine(&ddraw->IDirectDraw7_iface, line);
2212 }
2213
2214 static HRESULT WINAPI ddraw7_TestCooperativeLevel(IDirectDraw7 *iface)
2215 {
2216 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2217
2218 TRACE("iface %p.\n", iface);
2219
2220 return ddraw->device_state == DDRAW_DEVICE_STATE_LOST ? DDERR_NOEXCLUSIVEMODE : DD_OK;
2221 }
2222
2223 static HRESULT WINAPI ddraw4_TestCooperativeLevel(IDirectDraw4 *iface)
2224 {
2225 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2226
2227 TRACE("iface %p.\n", iface);
2228
2229 return ddraw7_TestCooperativeLevel(&ddraw->IDirectDraw7_iface);
2230 }
2231
2232 /*****************************************************************************
2233 * IDirectDraw7::GetGDISurface
2234 *
2235 * Returns the surface that GDI is treating as the primary surface.
2236 * For Wine this is the front buffer
2237 *
2238 * Params:
2239 * GDISurface: Address to write the surface pointer to
2240 *
2241 * Returns:
2242 * DD_OK if the surface was found
2243 * DDERR_NOTFOUND if the GDI surface wasn't found
2244 *
2245 *****************************************************************************/
2246 static HRESULT WINAPI ddraw7_GetGDISurface(IDirectDraw7 *iface, IDirectDrawSurface7 **GDISurface)
2247 {
2248 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2249
2250 TRACE("iface %p, surface %p.\n", iface, GDISurface);
2251
2252 wined3d_mutex_lock();
2253
2254 if (!(*GDISurface = &ddraw->primary->IDirectDrawSurface7_iface))
2255 {
2256 WARN("Primary not created yet.\n");
2257 wined3d_mutex_unlock();
2258 return DDERR_NOTFOUND;
2259 }
2260 IDirectDrawSurface7_AddRef(*GDISurface);
2261
2262 wined3d_mutex_unlock();
2263
2264 return DD_OK;
2265 }
2266
2267 static HRESULT WINAPI ddraw4_GetGDISurface(IDirectDraw4 *iface, IDirectDrawSurface4 **surface)
2268 {
2269 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2270 struct ddraw_surface *surface_impl;
2271 IDirectDrawSurface7 *surface7;
2272 HRESULT hr;
2273
2274 TRACE("iface %p, surface %p.\n", iface, surface);
2275
2276 hr = ddraw7_GetGDISurface(&ddraw->IDirectDraw7_iface, &surface7);
2277 if (FAILED(hr))
2278 {
2279 *surface = NULL;
2280 return hr;
2281 }
2282 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2283 *surface = &surface_impl->IDirectDrawSurface4_iface;
2284 IDirectDrawSurface4_AddRef(*surface);
2285 IDirectDrawSurface7_Release(surface7);
2286
2287 return hr;
2288 }
2289
2290 static HRESULT WINAPI ddraw2_GetGDISurface(IDirectDraw2 *iface, IDirectDrawSurface **surface)
2291 {
2292 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2293 struct ddraw_surface *surface_impl;
2294 IDirectDrawSurface7 *surface7;
2295 HRESULT hr;
2296
2297 TRACE("iface %p, surface %p.\n", iface, surface);
2298
2299 hr = ddraw7_GetGDISurface(&ddraw->IDirectDraw7_iface, &surface7);
2300 if (FAILED(hr))
2301 {
2302 *surface = NULL;
2303 return hr;
2304 }
2305 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2306 *surface = &surface_impl->IDirectDrawSurface_iface;
2307 IDirectDrawSurface_AddRef(*surface);
2308 IDirectDrawSurface7_Release(surface7);
2309
2310 return hr;
2311 }
2312
2313 static HRESULT WINAPI ddraw1_GetGDISurface(IDirectDraw *iface, IDirectDrawSurface **surface)
2314 {
2315 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2316 struct ddraw_surface *surface_impl;
2317 IDirectDrawSurface7 *surface7;
2318 HRESULT hr;
2319
2320 TRACE("iface %p, surface %p.\n", iface, surface);
2321
2322 hr = ddraw7_GetGDISurface(&ddraw->IDirectDraw7_iface, &surface7);
2323 if (FAILED(hr))
2324 {
2325 *surface = NULL;
2326 return hr;
2327 }
2328 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2329 *surface = &surface_impl->IDirectDrawSurface_iface;
2330 IDirectDrawSurface_AddRef(*surface);
2331 IDirectDrawSurface7_Release(surface7);
2332
2333 return hr;
2334 }
2335
2336 struct displaymodescallback_context
2337 {
2338 LPDDENUMMODESCALLBACK func;
2339 void *context;
2340 };
2341
2342 static HRESULT CALLBACK EnumDisplayModesCallbackThunk(DDSURFACEDESC2 *surface_desc, void *context)
2343 {
2344 struct displaymodescallback_context *cbcontext = context;
2345 DDSURFACEDESC desc;
2346
2347 DDSD2_to_DDSD(surface_desc, &desc);
2348 return cbcontext->func(&desc, cbcontext->context);
2349 }
2350
2351 /*****************************************************************************
2352 * IDirectDraw7::EnumDisplayModes
2353 *
2354 * Enumerates the supported Display modes. The modes can be filtered with
2355 * the DDSD parameter.
2356 *
2357 * Params:
2358 * Flags: can be DDEDM_REFRESHRATES and DDEDM_STANDARDVGAMODES. For old ddraw
2359 * versions (3 and older?) this is reserved and must be 0.
2360 * DDSD: Surface description to filter the modes
2361 * Context: Pointer passed back to the callback function
2362 * cb: Application-provided callback function
2363 *
2364 * Returns:
2365 * DD_OK on success
2366 * DDERR_INVALIDPARAMS if the callback wasn't set
2367 *
2368 *****************************************************************************/
2369 static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags,
2370 DDSURFACEDESC2 *DDSD, void *Context, LPDDENUMMODESCALLBACK2 cb)
2371 {
2372 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2373 struct wined3d_display_mode *enum_modes = NULL;
2374 struct wined3d_display_mode mode;
2375 unsigned int modenum, fmt;
2376 DDSURFACEDESC2 callback_sd;
2377 unsigned enum_mode_count = 0, enum_mode_array_size = 16;
2378 DDPIXELFORMAT pixelformat;
2379
2380 static const enum wined3d_format_id checkFormatList[] =
2381 {
2382 WINED3DFMT_B8G8R8X8_UNORM,
2383 WINED3DFMT_B5G6R5_UNORM,
2384 WINED3DFMT_P8_UINT,
2385 };
2386
2387 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2388 iface, Flags, DDSD, Context, cb);
2389
2390 if (!cb)
2391 return DDERR_INVALIDPARAMS;
2392
2393 if (!(enum_modes = heap_alloc(enum_mode_array_size * sizeof(*enum_modes))))
2394 return DDERR_OUTOFMEMORY;
2395
2396 wined3d_mutex_lock();
2397
2398 pixelformat.dwSize = sizeof(pixelformat);
2399 for(fmt = 0; fmt < ARRAY_SIZE(checkFormatList); fmt++)
2400 {
2401 modenum = 0;
2402 while (wined3d_enum_adapter_modes(ddraw->wined3d, WINED3DADAPTER_DEFAULT, checkFormatList[fmt],
2403 WINED3D_SCANLINE_ORDERING_UNKNOWN, modenum++, &mode) == WINED3D_OK)
2404 {
2405 BOOL found = FALSE;
2406 unsigned i;
2407
2408 ddrawformat_from_wined3dformat(&pixelformat, mode.format_id);
2409 if (DDSD)
2410 {
2411 if (DDSD->dwFlags & DDSD_WIDTH && mode.width != DDSD->dwWidth)
2412 continue;
2413 if (DDSD->dwFlags & DDSD_HEIGHT && mode.height != DDSD->dwHeight)
2414 continue;
2415 if (DDSD->dwFlags & DDSD_REFRESHRATE && mode.refresh_rate != DDSD->u2.dwRefreshRate)
2416 continue;
2417 if (DDSD->dwFlags & DDSD_PIXELFORMAT
2418 && pixelformat.u1.dwRGBBitCount != DDSD->u4.ddpfPixelFormat.u1.dwRGBBitCount)
2419 continue;
2420 }
2421
2422 /* DX docs state EnumDisplayMode should return only unique modes */
2423 for (i = 0; i < enum_mode_count; i++)
2424 {
2425 if (enum_modes[i].width == mode.width && enum_modes[i].height == mode.height
2426 && enum_modes[i].format_id == mode.format_id
2427 && (enum_modes[i].refresh_rate == mode.refresh_rate || !(Flags & DDEDM_REFRESHRATES)))
2428 {
2429 found = TRUE;
2430 break;
2431 }
2432 }
2433 if(found) continue;
2434
2435 memset(&callback_sd, 0, sizeof(callback_sd));
2436 callback_sd.dwSize = sizeof(callback_sd);
2437 callback_sd.u4.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
2438
2439 callback_sd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|DDSD_PITCH|DDSD_REFRESHRATE;
2440 if (Flags & DDEDM_REFRESHRATES)
2441 callback_sd.u2.dwRefreshRate = mode.refresh_rate;
2442
2443 callback_sd.dwWidth = mode.width;
2444 callback_sd.dwHeight = mode.height;
2445
2446 callback_sd.u4.ddpfPixelFormat=pixelformat;
2447
2448 /* Calc pitch and DWORD align like MSDN says */
2449 callback_sd.u1.lPitch = (callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount / 8) * mode.width;
2450 callback_sd.u1.lPitch = (callback_sd.u1.lPitch + 3) & ~3;
2451
2452 TRACE("Enumerating %dx%dx%d @%d\n", callback_sd.dwWidth, callback_sd.dwHeight, callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount,
2453 callback_sd.u2.dwRefreshRate);
2454
2455 if(cb(&callback_sd, Context) == DDENUMRET_CANCEL)
2456 {
2457 TRACE("Application asked to terminate the enumeration\n");
2458 heap_free(enum_modes);
2459 wined3d_mutex_unlock();
2460 return DD_OK;
2461 }
2462
2463 if (enum_mode_count == enum_mode_array_size)
2464 {
2465 struct wined3d_display_mode *new_enum_modes;
2466
2467 enum_mode_array_size *= 2;
2468 if (!(new_enum_modes = heap_realloc(enum_modes, enum_mode_array_size * sizeof(*new_enum_modes))))
2469 {
2470 heap_free(enum_modes);
2471 wined3d_mutex_unlock();
2472 return DDERR_OUTOFMEMORY;
2473 }
2474
2475 enum_modes = new_enum_modes;
2476 }
2477 enum_modes[enum_mode_count++] = mode;
2478 }
2479 }
2480
2481 TRACE("End of enumeration\n");
2482 heap_free(enum_modes);
2483 wined3d_mutex_unlock();
2484
2485 return DD_OK;
2486 }
2487
2488 static HRESULT WINAPI ddraw4_EnumDisplayModes(IDirectDraw4 *iface, DWORD flags,
2489 DDSURFACEDESC2 *surface_desc, void *context, LPDDENUMMODESCALLBACK2 callback)
2490 {
2491 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2492
2493 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2494 iface, flags, surface_desc, context, callback);
2495
2496 return ddraw7_EnumDisplayModes(&ddraw->IDirectDraw7_iface, flags, surface_desc, context, callback);
2497 }
2498
2499 static HRESULT WINAPI ddraw2_EnumDisplayModes(IDirectDraw2 *iface, DWORD flags,
2500 DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2501 {
2502 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2503 struct displaymodescallback_context cbcontext;
2504 DDSURFACEDESC2 surface_desc2;
2505
2506 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2507 iface, flags, surface_desc, context, callback);
2508
2509 cbcontext.func = callback;
2510 cbcontext.context = context;
2511
2512 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
2513 return ddraw7_EnumDisplayModes(&ddraw->IDirectDraw7_iface, flags,
2514 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumDisplayModesCallbackThunk);
2515 }
2516
2517 static HRESULT WINAPI ddraw1_EnumDisplayModes(IDirectDraw *iface, DWORD flags,
2518 DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2519 {
2520 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2521 struct displaymodescallback_context cbcontext;
2522 DDSURFACEDESC2 surface_desc2;
2523
2524 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2525 iface, flags, surface_desc, context, callback);
2526
2527 cbcontext.func = callback;
2528 cbcontext.context = context;
2529
2530 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
2531 return ddraw7_EnumDisplayModes(&ddraw->IDirectDraw7_iface, flags,
2532 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumDisplayModesCallbackThunk);
2533 }
2534
2535 /*****************************************************************************
2536 * IDirectDraw7::EvaluateMode
2537 *
2538 * Used with IDirectDraw7::StartModeTest to test video modes.
2539 * EvaluateMode is used to pass or fail a mode, and continue with the next
2540 * mode
2541 *
2542 * Params:
2543 * Flags: DDEM_MODEPASSED or DDEM_MODEFAILED
2544 * Timeout: Returns the amount of seconds left before the mode would have
2545 * been failed automatically
2546 *
2547 * Returns:
2548 * This implementation always DD_OK, because it's a stub
2549 *
2550 *****************************************************************************/
2551 static HRESULT WINAPI ddraw7_EvaluateMode(IDirectDraw7 *iface, DWORD Flags, DWORD *Timeout)
2552 {
2553 FIXME("iface %p, flags %#x, timeout %p stub!\n", iface, Flags, Timeout);
2554
2555 /* When implementing this, implement it in WineD3D */
2556
2557 return DD_OK;
2558 }
2559
2560 /*****************************************************************************
2561 * IDirectDraw7::GetDeviceIdentifier
2562 *
2563 * Returns the device identifier, which gives information about the driver
2564 * Our device identifier is defined at the beginning of this file.
2565 *
2566 * Params:
2567 * DDDI: Address for the returned structure
2568 * Flags: Can be DDGDI_GETHOSTIDENTIFIER
2569 *
2570 * Returns:
2571 * On success it returns DD_OK
2572 * DDERR_INVALIDPARAMS if DDDI is NULL
2573 *
2574 *****************************************************************************/
2575 static HRESULT WINAPI ddraw7_GetDeviceIdentifier(IDirectDraw7 *iface,
2576 DDDEVICEIDENTIFIER2 *DDDI, DWORD Flags)
2577 {
2578 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2579 struct wined3d_adapter_identifier adapter_id;
2580 HRESULT hr = S_OK;
2581
2582 TRACE("iface %p, device_identifier %p, flags %#x.\n", iface, DDDI, Flags);
2583
2584 if (!DDDI)
2585 return DDERR_INVALIDPARAMS;
2586
2587 if (Flags & DDGDI_GETHOSTIDENTIFIER)
2588 {
2589 /* The DDGDI_GETHOSTIDENTIFIER returns the information about the 2D
2590 * host adapter, if there's a secondary 3D adapter. This doesn't apply
2591 * to any modern hardware, nor is it interesting for Wine, so ignore it.
2592 * Size of DDDEVICEIDENTIFIER2 may be aligned to 8 bytes and thus 4
2593 * bytes too long. So only copy the relevant part of the structure
2594 */
2595
2596 memcpy(DDDI, &deviceidentifier, FIELD_OFFSET(DDDEVICEIDENTIFIER2, dwWHQLLevel) + sizeof(DWORD));
2597 return DD_OK;
2598 }
2599
2600 /* Drakan: Order of the Flame expects accurate D3D device information from ddraw */
2601 adapter_id.driver = DDDI->szDriver;
2602 adapter_id.driver_size = sizeof(DDDI->szDriver);
2603 adapter_id.description = DDDI->szDescription;
2604 adapter_id.description_size = sizeof(DDDI->szDescription);
2605 adapter_id.device_name_size = 0;
2606 wined3d_mutex_lock();
2607 hr = wined3d_get_adapter_identifier(ddraw->wined3d, WINED3DADAPTER_DEFAULT, 0x0, &adapter_id);
2608 wined3d_mutex_unlock();
2609 if (FAILED(hr)) return hr;
2610
2611 DDDI->liDriverVersion = adapter_id.driver_version;
2612 DDDI->dwVendorId = adapter_id.vendor_id;
2613 DDDI->dwDeviceId = adapter_id.device_id;
2614 DDDI->dwSubSysId = adapter_id.subsystem_id;
2615 DDDI->dwRevision = adapter_id.revision;
2616 DDDI->guidDeviceIdentifier = adapter_id.device_identifier;
2617 DDDI->dwWHQLLevel = adapter_id.whql_level;
2618 return DD_OK;
2619 }
2620
2621 static HRESULT WINAPI ddraw4_GetDeviceIdentifier(IDirectDraw4 *iface,
2622 DDDEVICEIDENTIFIER *identifier, DWORD flags)
2623 {
2624 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2625 DDDEVICEIDENTIFIER2 identifier2;
2626 HRESULT hr;
2627
2628 TRACE("iface %p, identifier %p, flags %#x.\n", iface, identifier, flags);
2629
2630 hr = ddraw7_GetDeviceIdentifier(&ddraw->IDirectDraw7_iface, &identifier2, flags);
2631 DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1(&identifier2, identifier);
2632
2633 return hr;
2634 }
2635
2636 /*****************************************************************************
2637 * IDirectDraw7::GetSurfaceFromDC
2638 *
2639 * Returns the Surface for a GDI device context handle.
2640 * Is this related to IDirectDrawSurface::GetDC ???
2641 *
2642 * Params:
2643 * hdc: hdc to return the surface for
2644 * Surface: Address to write the surface pointer to
2645 *
2646 * Returns:
2647 * Always returns DD_OK because it's a stub
2648 *
2649 *****************************************************************************/
2650 static HRESULT WINAPI ddraw7_GetSurfaceFromDC(IDirectDraw7 *iface,
2651 HDC dc, IDirectDrawSurface7 **surface)
2652 {
2653 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2654 struct ddraw_surface *surface_impl;
2655
2656 TRACE("iface %p, dc %p, surface %p.\n", iface, dc, surface);
2657
2658 if (!surface)
2659 return E_INVALIDARG;
2660
2661 if (!dc)
2662 goto done;
2663
2664 wined3d_mutex_lock();
2665 LIST_FOR_EACH_ENTRY(surface_impl, &ddraw->surface_list, struct ddraw_surface, surface_list_entry)
2666 {
2667 if (surface_impl->dc != dc)
2668 continue;
2669
2670 TRACE("Found surface %p for dc %p.\n", surface_impl, dc);
2671 *surface = &surface_impl->IDirectDrawSurface7_iface;
2672 IDirectDrawSurface7_AddRef(*surface);
2673 wined3d_mutex_unlock();
2674 return DD_OK;
2675 }
2676 wined3d_mutex_unlock();
2677
2678 done:
2679 TRACE("No surface found for dc %p.\n", dc);
2680 *surface = NULL;
2681 return DDERR_NOTFOUND;
2682 }
2683
2684 static HRESULT WINAPI ddraw4_GetSurfaceFromDC(IDirectDraw4 *iface, HDC dc,
2685 IDirectDrawSurface4 **surface)
2686 {
2687 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2688 struct ddraw_surface *surface_impl;
2689 IDirectDrawSurface7 *surface7;
2690 HRESULT hr;
2691
2692 TRACE("iface %p, dc %p, surface %p.\n", iface, dc, surface);
2693
2694 if (!surface) return E_INVALIDARG;
2695
2696 hr = ddraw7_GetSurfaceFromDC(&ddraw->IDirectDraw7_iface, dc, &surface7);
2697 if (FAILED(hr))
2698 {
2699 *surface = NULL;
2700 return hr;
2701 }
2702 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2703 /* Tests say this is true */
2704 *surface = (IDirectDrawSurface4 *)&surface_impl->IDirectDrawSurface_iface;
2705 IDirectDrawSurface_AddRef(&surface_impl->IDirectDrawSurface_iface);
2706 IDirectDrawSurface7_Release(surface7);
2707
2708 return hr;
2709 }
2710
2711 static HRESULT CALLBACK restore_callback(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *desc, void *context)
2712 {
2713 IDirectDrawSurface_Restore(surface);
2714 IDirectDrawSurface_Release(surface);
2715
2716 return DDENUMRET_OK;
2717 }
2718
2719 static HRESULT WINAPI ddraw7_RestoreAllSurfaces(IDirectDraw7 *iface)
2720 {
2721 TRACE("iface %p.\n", iface);
2722
2723 return IDirectDraw7_EnumSurfaces(iface, DDENUMSURFACES_ALL | DDENUMSURFACES_DOESEXIST,
2724 NULL, NULL, restore_callback);
2725 }
2726
2727 static HRESULT WINAPI ddraw4_RestoreAllSurfaces(IDirectDraw4 *iface)
2728 {
2729 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2730
2731 TRACE("iface %p.\n", iface);
2732
2733 return ddraw7_RestoreAllSurfaces(&ddraw->IDirectDraw7_iface);
2734 }
2735
2736 /*****************************************************************************
2737 * IDirectDraw7::StartModeTest
2738 *
2739 * Tests the specified video modes to update the system registry with
2740 * refresh rate information. StartModeTest starts the mode test,
2741 * EvaluateMode is used to fail or pass a mode. If EvaluateMode
2742 * isn't called within 15 seconds, the mode is failed automatically
2743 *
2744 * As refresh rates are handled by the X server, I don't think this
2745 * Method is important
2746 *
2747 * Params:
2748 * Modes: An array of mode specifications
2749 * NumModes: The number of modes in Modes
2750 * Flags: Some flags...
2751 *
2752 * Returns:
2753 * Returns DDERR_TESTFINISHED if flags contains DDSMT_ISTESTREQUIRED,
2754 * if no modes are passed, DDERR_INVALIDPARAMS is returned,
2755 * otherwise DD_OK
2756 *
2757 *****************************************************************************/
2758 static HRESULT WINAPI ddraw7_StartModeTest(IDirectDraw7 *iface, SIZE *Modes, DWORD NumModes, DWORD Flags)
2759 {
2760 FIXME("iface %p, modes %p, mode_count %u, flags %#x partial stub!\n",
2761 iface, Modes, NumModes, Flags);
2762
2763 /* This looks sane */
2764 if( (!Modes) || (NumModes == 0) ) return DDERR_INVALIDPARAMS;
2765
2766 /* DDSMT_ISTESTREQUIRED asks if a mode test is necessary.
2767 * As it is not, DDERR_TESTFINISHED is returned
2768 * (hopefully that's correct
2769 *
2770 if(Flags & DDSMT_ISTESTREQUIRED) return DDERR_TESTFINISHED;
2771 * well, that value doesn't (yet) exist in the wine headers, so ignore it
2772 */
2773
2774 return DD_OK;
2775 }
2776
2777 static HRESULT WINAPI ddraw7_CreateSurface(IDirectDraw7 *iface, DDSURFACEDESC2 *surface_desc,
2778 IDirectDrawSurface7 **surface, IUnknown *outer_unknown)
2779 {
2780 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2781 struct ddraw_surface *impl;
2782 HRESULT hr;
2783
2784 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2785 iface, surface_desc, surface, outer_unknown);
2786
2787 wined3d_mutex_lock();
2788
2789 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
2790 {
2791 WARN("Cooperative level not set.\n");
2792 wined3d_mutex_unlock();
2793 return DDERR_NOCOOPERATIVELEVELSET;
2794 }
2795
2796 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC2))
2797 {
2798 WARN("Application supplied invalid surface descriptor\n");
2799 wined3d_mutex_unlock();
2800 return DDERR_INVALIDPARAMS;
2801 }
2802
2803 __TRY
2804 {
2805 *surface = NULL;
2806 }
2807 __EXCEPT_PAGE_FAULT
2808 {
2809 WARN("Surface pointer %p is invalid.\n", surface);
2810 wined3d_mutex_unlock();
2811 return DDERR_INVALIDPARAMS;
2812 }
2813 __ENDTRY;
2814
2815 if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
2816 {
2817 if (TRACE_ON(ddraw))
2818 {
2819 TRACE(" (%p) Requesting surface desc :\n", iface);
2820 DDRAW_dump_surface_desc(surface_desc);
2821 }
2822
2823 WARN("Application tried to create an explicit front or back buffer\n");
2824 wined3d_mutex_unlock();
2825 return DDERR_INVALIDCAPS;
2826 }
2827
2828 hr = ddraw_surface_create(ddraw, surface_desc, &impl, outer_unknown, 7);
2829 wined3d_mutex_unlock();
2830 if (FAILED(hr))
2831 return hr;
2832
2833 *surface = &impl->IDirectDrawSurface7_iface;
2834 IDirectDraw7_AddRef(iface);
2835 impl->ifaceToRelease = (IUnknown *)iface;
2836
2837 return hr;
2838 }
2839
2840 static HRESULT WINAPI ddraw4_CreateSurface(IDirectDraw4 *iface,
2841 DDSURFACEDESC2 *surface_desc, IDirectDrawSurface4 **surface, IUnknown *outer_unknown)
2842 {
2843 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2844 struct ddraw_surface *impl;
2845 HRESULT hr;
2846
2847 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2848 iface, surface_desc, surface, outer_unknown);
2849
2850 wined3d_mutex_lock();
2851
2852 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
2853 {
2854 WARN("Cooperative level not set.\n");
2855 wined3d_mutex_unlock();
2856 return DDERR_NOCOOPERATIVELEVELSET;
2857 }
2858
2859 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC2))
2860 {
2861 WARN("Application supplied invalid surface descriptor\n");
2862 wined3d_mutex_unlock();
2863 return DDERR_INVALIDPARAMS;
2864 }
2865
2866 __TRY
2867 {
2868 *surface = NULL;
2869 }
2870 __EXCEPT_PAGE_FAULT
2871 {
2872 WARN("Surface pointer %p is invalid.\n", surface);
2873 wined3d_mutex_unlock();
2874 return DDERR_INVALIDPARAMS;
2875 }
2876 __ENDTRY;
2877
2878 if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
2879 {
2880 if (TRACE_ON(ddraw))
2881 {
2882 TRACE(" (%p) Requesting surface desc :\n", iface);
2883 DDRAW_dump_surface_desc(surface_desc);
2884 }
2885
2886 WARN("Application tried to create an explicit front or back buffer\n");
2887 wined3d_mutex_unlock();
2888 return DDERR_INVALIDCAPS;
2889 }
2890
2891 hr = ddraw_surface_create(ddraw, surface_desc, &impl, outer_unknown, 4);
2892 wined3d_mutex_unlock();
2893 if (FAILED(hr))
2894 return hr;
2895
2896 *surface = &impl->IDirectDrawSurface4_iface;
2897 IDirectDraw4_AddRef(iface);
2898 impl->ifaceToRelease = (IUnknown *)iface;
2899
2900 return hr;
2901 }
2902
2903 static HRESULT WINAPI ddraw2_CreateSurface(IDirectDraw2 *iface,
2904 DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
2905 {
2906 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2907 struct ddraw_surface *impl;
2908 HRESULT hr;
2909 DDSURFACEDESC2 surface_desc2;
2910
2911 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2912 iface, surface_desc, surface, outer_unknown);
2913
2914 wined3d_mutex_lock();
2915
2916 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
2917 {
2918 WARN("Cooperative level not set.\n");
2919 wined3d_mutex_unlock();
2920 return DDERR_NOCOOPERATIVELEVELSET;
2921 }
2922
2923 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
2924 {
2925 WARN("Application supplied invalid surface descriptor\n");
2926 wined3d_mutex_unlock();
2927 return DDERR_INVALIDPARAMS;
2928 }
2929
2930 __TRY
2931 {
2932 *surface = NULL;
2933 }
2934 __EXCEPT_PAGE_FAULT
2935 {
2936 WARN("Surface pointer %p is invalid.\n", surface);
2937 wined3d_mutex_unlock();
2938 return DDERR_INVALIDPARAMS;
2939 }
2940 __ENDTRY;
2941
2942 DDSD_to_DDSD2(surface_desc, &surface_desc2);
2943 if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
2944 {
2945 if (TRACE_ON(ddraw))
2946 {
2947 TRACE(" (%p) Requesting surface desc :\n", iface);
2948 DDRAW_dump_surface_desc((DDSURFACEDESC2 *)surface_desc);
2949 }
2950
2951 WARN("Application tried to create an explicit front or back buffer\n");
2952 wined3d_mutex_unlock();
2953 return DDERR_INVALIDCAPS;
2954 }
2955
2956 hr = ddraw_surface_create(ddraw, &surface_desc2, &impl, outer_unknown, 2);
2957 wined3d_mutex_unlock();
2958 if (FAILED(hr))
2959 return hr;
2960
2961 *surface = &impl->IDirectDrawSurface_iface;
2962 impl->ifaceToRelease = NULL;
2963
2964 return hr;
2965 }
2966
2967 static HRESULT WINAPI ddraw1_CreateSurface(IDirectDraw *iface,
2968 DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
2969 {
2970 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2971 struct ddraw_surface *impl;
2972 HRESULT hr;
2973 DDSURFACEDESC2 surface_desc2;
2974
2975 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2976 iface, surface_desc, surface, outer_unknown);
2977
2978 wined3d_mutex_lock();
2979
2980 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
2981 {
2982 WARN("Cooperative level not set.\n");
2983 wined3d_mutex_unlock();
2984 return DDERR_NOCOOPERATIVELEVELSET;
2985 }
2986
2987 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
2988 {
2989 WARN("Application supplied invalid surface descriptor\n");
2990 wined3d_mutex_unlock();
2991 return DDERR_INVALIDPARAMS;
2992 }
2993
2994 __TRY
2995 {
2996 *surface = NULL;
2997 }
2998 __EXCEPT_PAGE_FAULT
2999 {
3000 WARN("Surface pointer %p is invalid.\n", surface);
3001 wined3d_mutex_unlock();
3002 return DDERR_INVALIDPARAMS;
3003 }
3004 __ENDTRY;
3005
3006 if ((surface_desc->ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_BACKBUFFER))
3007 == (DDSCAPS_PRIMARYSURFACE | DDSCAPS_BACKBUFFER)
3008 || (surface_desc->ddsCaps.dwCaps & (DDSCAPS_FLIP | DDSCAPS_FRONTBUFFER))
3009 == ((DDSCAPS_FLIP | DDSCAPS_FRONTBUFFER)))
3010 {
3011 WARN("Application tried to create an explicit front or back buffer.\n");
3012 wined3d_mutex_unlock();
3013 return DDERR_INVALIDCAPS;
3014 }
3015
3016 DDSD_to_DDSD2(surface_desc, &surface_desc2);
3017 hr = ddraw_surface_create(ddraw, &surface_desc2, &impl, outer_unknown, 1);
3018 wined3d_mutex_unlock();
3019 if (FAILED(hr))
3020 return hr;
3021
3022 *surface = &impl->IDirectDrawSurface_iface;
3023 impl->ifaceToRelease = NULL;
3024
3025 return hr;
3026 }
3027
3028 static BOOL
3029 Main_DirectDraw_DDPIXELFORMAT_Match(const DDPIXELFORMAT *requested,
3030 const DDPIXELFORMAT *provided)
3031 {
3032 /* Some flags must be present in both or neither for a match. */
3033 static const DWORD must_match = DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2
3034 | DDPF_PALETTEINDEXED4 | DDPF_PALETTEINDEXED8 | DDPF_FOURCC
3035 | DDPF_ZBUFFER | DDPF_STENCILBUFFER;
3036
3037 if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
3038 return FALSE;
3039
3040 if ((requested->dwFlags & must_match) != (provided->dwFlags & must_match))
3041 return FALSE;
3042
3043 if (requested->dwFlags & DDPF_FOURCC)
3044 if (requested->dwFourCC != provided->dwFourCC)
3045 return FALSE;
3046
3047 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_ALPHA
3048 |DDPF_LUMINANCE|DDPF_BUMPDUDV))
3049 if (requested->u1.dwRGBBitCount != provided->u1.dwRGBBitCount)
3050 return FALSE;
3051
3052 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
3053 |DDPF_LUMINANCE|DDPF_BUMPDUDV))
3054 if (requested->u2.dwRBitMask != provided->u2.dwRBitMask)
3055 return FALSE;
3056
3057 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_BUMPDUDV))
3058 if (requested->u3.dwGBitMask != provided->u3.dwGBitMask)
3059 return FALSE;
3060
3061 /* I could be wrong about the bumpmapping. MSDN docs are vague. */
3062 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
3063 |DDPF_BUMPDUDV))
3064 if (requested->u4.dwBBitMask != provided->u4.dwBBitMask)
3065 return FALSE;
3066
3067 if (requested->dwFlags & (DDPF_ALPHAPIXELS|DDPF_ZPIXELS))
3068 if (requested->u5.dwRGBAlphaBitMask != provided->u5.dwRGBAlphaBitMask)
3069 return FALSE;
3070
3071 return TRUE;
3072 }
3073
3074 static BOOL ddraw_match_surface_desc(const DDSURFACEDESC2 *requested, const DDSURFACEDESC2 *provided)
3075 {
3076 struct compare_info
3077 {
3078 DWORD flag;
3079 ptrdiff_t offset;
3080 size_t size;
3081 };
3082
3083 #define CMP(FLAG, FIELD) \
3084 { DDSD_##FLAG, offsetof(DDSURFACEDESC2, FIELD), \
3085 sizeof(((DDSURFACEDESC2 *)(NULL))->FIELD) }
3086
3087 static const struct compare_info compare[] =
3088 {
3089 CMP(ALPHABITDEPTH, dwAlphaBitDepth),
3090 CMP(BACKBUFFERCOUNT, u5.dwBackBufferCount),
3091 CMP(CAPS, ddsCaps),
3092 CMP(CKDESTBLT, ddckCKDestBlt),
3093 CMP(CKDESTOVERLAY, u3 /* ddckCKDestOverlay */),
3094 CMP(CKSRCBLT, ddckCKSrcBlt),
3095 CMP(CKSRCOVERLAY, ddckCKSrcOverlay),
3096 CMP(HEIGHT, dwHeight),
3097 CMP(LINEARSIZE, u1 /* dwLinearSize */),
3098 CMP(LPSURFACE, lpSurface),
3099 CMP(MIPMAPCOUNT, u2 /* dwMipMapCount */),
3100 CMP(PITCH, u1 /* lPitch */),
3101 /* PIXELFORMAT: manual */
3102 CMP(REFRESHRATE, u2 /* dwRefreshRate */),
3103 CMP(TEXTURESTAGE, dwTextureStage),
3104 CMP(WIDTH, dwWidth),
3105 /* ZBUFFERBITDEPTH: "obsolete" */
3106 };
3107
3108 #undef CMP
3109
3110 unsigned int i;
3111
3112 if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
3113 return FALSE;
3114
3115 for (i=0; i < ARRAY_SIZE(compare); i++)
3116 {
3117 if (requested->dwFlags & compare[i].flag
3118 && memcmp((const char *)provided + compare[i].offset,
3119 (const char *)requested + compare[i].offset,
3120 compare[i].size) != 0)
3121 return FALSE;
3122 }
3123
3124 if (requested->dwFlags & DDSD_PIXELFORMAT)
3125 {
3126 if (!Main_DirectDraw_DDPIXELFORMAT_Match(&requested->u4.ddpfPixelFormat,
3127 &provided->u4.ddpfPixelFormat))
3128 return FALSE;
3129 }
3130
3131 return TRUE;
3132 }
3133
3134 struct surfacescallback2_context
3135 {
3136 LPDDENUMSURFACESCALLBACK2 func;
3137 void *context;
3138 };
3139
3140 struct surfacescallback_context
3141 {
3142 LPDDENUMSURFACESCALLBACK func;
3143 void *context;
3144 };
3145
3146 static HRESULT CALLBACK EnumSurfacesCallback2Thunk(IDirectDrawSurface7 *surface,
3147 DDSURFACEDESC2 *surface_desc, void *context)
3148 {
3149 struct ddraw_surface *surface_impl = impl_from_IDirectDrawSurface7(surface);
3150 struct surfacescallback2_context *cbcontext = context;
3151
3152 IDirectDrawSurface4_AddRef(&surface_impl->IDirectDrawSurface4_iface);
3153 IDirectDrawSurface7_Release(surface);
3154
3155 return cbcontext->func(&surface_impl->IDirectDrawSurface4_iface,
3156 surface_desc, cbcontext->context);
3157 }
3158
3159 static HRESULT CALLBACK EnumSurfacesCallbackThunk(IDirectDrawSurface7 *surface,
3160 DDSURFACEDESC2 *surface_desc, void *context)
3161 {
3162 struct ddraw_surface *surface_impl = impl_from_IDirectDrawSurface7(surface);
3163 struct surfacescallback_context *cbcontext = context;
3164
3165 IDirectDrawSurface_AddRef(&surface_impl->IDirectDrawSurface_iface);
3166 IDirectDrawSurface7_Release(surface);
3167
3168 return cbcontext->func(&surface_impl->IDirectDrawSurface_iface,
3169 (DDSURFACEDESC *)surface_desc, cbcontext->context);
3170 }
3171
3172 /*****************************************************************************
3173 * IDirectDraw7::EnumSurfaces
3174 *
3175 * Loops through all surfaces attached to this device and calls the
3176 * application callback. This can't be relayed to WineD3DDevice,
3177 * because some WineD3DSurfaces' parents are IParent objects
3178 *
3179 * Params:
3180 * Flags: Some filtering flags. See IDirectDrawImpl_EnumSurfacesCallback
3181 * DDSD: Description to filter for
3182 * Context: Application-provided pointer, it's passed unmodified to the
3183 * Callback function
3184 * Callback: Address to call for each surface
3185 *
3186 * Returns:
3187 * DDERR_INVALIDPARAMS if the callback is NULL
3188 * DD_OK on success
3189 *
3190 *****************************************************************************/
3191 static HRESULT WINAPI ddraw7_EnumSurfaces(IDirectDraw7 *iface, DWORD Flags,
3192 DDSURFACEDESC2 *DDSD, void *Context, LPDDENUMSURFACESCALLBACK7 Callback)
3193 {
3194 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
3195 struct ddraw_surface *surf;
3196 BOOL all, nomatch;
3197 DDSURFACEDESC2 desc;
3198 struct list *entry, *entry2;
3199
3200 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3201 iface, Flags, DDSD, Context, Callback);
3202
3203 all = Flags & DDENUMSURFACES_ALL;
3204 nomatch = Flags & DDENUMSURFACES_NOMATCH;
3205
3206 if (!Callback)
3207 return DDERR_INVALIDPARAMS;
3208
3209 wined3d_mutex_lock();
3210
3211 /* Use the _SAFE enumeration, the app may destroy enumerated surfaces */
3212 LIST_FOR_EACH_SAFE(entry, entry2, &ddraw->surface_list)
3213 {
3214 surf = LIST_ENTRY(entry, struct ddraw_surface, surface_list_entry);
3215
3216 if (!surf->iface_count)
3217 {
3218 WARN("Not enumerating surface %p because it doesn't have any references.\n", surf);
3219 continue;
3220 }
3221
3222 if (all || (nomatch != ddraw_match_surface_desc(DDSD, &surf->surface_desc)))
3223 {
3224 TRACE("Enumerating surface %p.\n", surf);
3225 desc = surf->surface_desc;
3226 IDirectDrawSurface7_AddRef(&surf->IDirectDrawSurface7_iface);
3227 if (Callback(&surf->IDirectDrawSurface7_iface, &desc, Context) != DDENUMRET_OK)
3228 {
3229 wined3d_mutex_unlock();
3230 return DD_OK;
3231 }
3232 }
3233 }
3234
3235 wined3d_mutex_unlock();
3236
3237 return DD_OK;
3238 }
3239
3240 static HRESULT WINAPI ddraw4_EnumSurfaces(IDirectDraw4 *iface, DWORD flags,
3241 DDSURFACEDESC2 *surface_desc, void *context, LPDDENUMSURFACESCALLBACK2 callback)
3242 {
3243 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3244 struct surfacescallback2_context cbcontext;
3245
3246 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3247 iface, flags, surface_desc, context, callback);
3248
3249 cbcontext.func = callback;
3250 cbcontext.context = context;
3251
3252 return ddraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, flags, surface_desc,
3253 &cbcontext, EnumSurfacesCallback2Thunk);
3254 }
3255
3256 static HRESULT WINAPI ddraw2_EnumSurfaces(IDirectDraw2 *iface, DWORD flags,
3257 DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3258 {
3259 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3260 struct surfacescallback_context cbcontext;
3261 DDSURFACEDESC2 surface_desc2;
3262
3263 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3264 iface, flags, surface_desc, context, callback);
3265
3266 cbcontext.func = callback;
3267 cbcontext.context = context;
3268
3269 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3270 return ddraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, flags,
3271 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumSurfacesCallbackThunk);
3272 }
3273
3274 static HRESULT WINAPI ddraw1_EnumSurfaces(IDirectDraw *iface, DWORD flags,
3275 DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3276 {
3277 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3278 struct surfacescallback_context cbcontext;
3279 DDSURFACEDESC2 surface_desc2;
3280
3281 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3282 iface, flags, surface_desc, context, callback);
3283
3284 cbcontext.func = callback;
3285 cbcontext.context = context;
3286
3287 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3288 return ddraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, flags,
3289 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumSurfacesCallbackThunk);
3290 }
3291
3292 /*****************************************************************************
3293 * DirectDrawCreateClipper (DDRAW.@)
3294 *
3295 * Creates a new IDirectDrawClipper object.
3296 *
3297 * Params:
3298 * Clipper: Address to write the interface pointer to
3299 * UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3300 * NULL
3301 *
3302 * Returns:
3303 * CLASS_E_NOAGGREGATION if UnkOuter != NULL
3304 * E_OUTOFMEMORY if allocating the object failed
3305 *
3306 *****************************************************************************/
3307 HRESULT WINAPI DirectDrawCreateClipper(DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3308 {
3309 struct ddraw_clipper *object;
3310 HRESULT hr;
3311
3312 TRACE("flags %#x, clipper %p, outer_unknown %p.\n",
3313 flags, clipper, outer_unknown);
3314
3315 if (outer_unknown)
3316 return CLASS_E_NOAGGREGATION;
3317
3318 wined3d_mutex_lock();
3319
3320 if (!(object = heap_alloc_zero(sizeof(*object))))
3321 {
3322 wined3d_mutex_unlock();
3323 return E_OUTOFMEMORY;
3324 }
3325
3326 hr = ddraw_clipper_init(object);
3327 if (FAILED(hr))
3328 {
3329 WARN("Failed to initialize clipper, hr %#x.\n", hr);
3330 heap_free(object);
3331 wined3d_mutex_unlock();
3332 return hr;
3333 }
3334
3335 TRACE("Created clipper %p.\n", object);
3336 *clipper = &object->IDirectDrawClipper_iface;
3337 wined3d_mutex_unlock();
3338
3339 return DD_OK;
3340 }
3341
3342 /*****************************************************************************
3343 * IDirectDraw7::CreateClipper
3344 *
3345 * Creates a DDraw clipper. See DirectDrawCreateClipper for details
3346 *
3347 *****************************************************************************/
3348 static HRESULT WINAPI ddraw7_CreateClipper(IDirectDraw7 *iface, DWORD Flags,
3349 IDirectDrawClipper **Clipper, IUnknown *UnkOuter)
3350 {
3351 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3352 iface, Flags, Clipper, UnkOuter);
3353
3354 return DirectDrawCreateClipper(Flags, Clipper, UnkOuter);
3355 }
3356
3357 static HRESULT WINAPI ddraw4_CreateClipper(IDirectDraw4 *iface, DWORD flags,
3358 IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3359 {
3360 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3361
3362 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3363 iface, flags, clipper, outer_unknown);
3364
3365 return ddraw7_CreateClipper(&ddraw->IDirectDraw7_iface, flags, clipper, outer_unknown);
3366 }
3367
3368 static HRESULT WINAPI ddraw2_CreateClipper(IDirectDraw2 *iface,
3369 DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3370 {
3371 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3372
3373 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3374 iface, flags, clipper, outer_unknown);
3375
3376 return ddraw7_CreateClipper(&ddraw->IDirectDraw7_iface, flags, clipper, outer_unknown);
3377 }
3378
3379 static HRESULT WINAPI ddraw1_CreateClipper(IDirectDraw *iface,
3380 DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3381 {
3382 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3383
3384 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3385 iface, flags, clipper, outer_unknown);
3386
3387 return ddraw7_CreateClipper(&ddraw->IDirectDraw7_iface, flags, clipper, outer_unknown);
3388 }
3389
3390 /*****************************************************************************
3391 * IDirectDraw7::CreatePalette
3392 *
3393 * Creates a new IDirectDrawPalette object
3394 *
3395 * Params:
3396 * Flags: The flags for the new clipper
3397 * ColorTable: Color table to assign to the new clipper
3398 * Palette: Address to write the interface pointer to
3399 * UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3400 * NULL
3401 *
3402 * Returns:
3403 * CLASS_E_NOAGGREGATION if UnkOuter != NULL
3404 * E_OUTOFMEMORY if allocating the object failed
3405 *
3406 *****************************************************************************/
3407 static HRESULT WINAPI ddraw7_CreatePalette(IDirectDraw7 *iface, DWORD Flags,
3408 PALETTEENTRY *ColorTable, IDirectDrawPalette **Palette, IUnknown *pUnkOuter)
3409 {
3410 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
3411 struct ddraw_palette *object;
3412 HRESULT hr;
3413
3414 TRACE("iface %p, flags %#x, color_table %p, palette %p, outer_unknown %p.\n",
3415 iface, Flags, ColorTable, Palette, pUnkOuter);
3416
3417 if (pUnkOuter)
3418 return CLASS_E_NOAGGREGATION;
3419
3420 wined3d_mutex_lock();
3421
3422 /* The refcount test shows that a cooplevel is required for this */
3423 if (!ddraw->cooperative_level)
3424 {
3425 WARN("No cooperative level set, returning DDERR_NOCOOPERATIVELEVELSET\n");
3426 wined3d_mutex_unlock();
3427 return DDERR_NOCOOPERATIVELEVELSET;
3428 }
3429
3430 if (!(object = heap_alloc(sizeof(*object))))
3431 {
3432 ERR("Out of memory when allocating memory for a palette implementation\n");
3433 wined3d_mutex_unlock();
3434 return E_OUTOFMEMORY;
3435 }
3436
3437 hr = ddraw_palette_init(object, ddraw, Flags, ColorTable);
3438 if (FAILED(hr))
3439 {
3440 WARN("Failed to initialize palette, hr %#x.\n", hr);
3441 heap_free(object);
3442 wined3d_mutex_unlock();
3443 return hr;
3444 }
3445
3446 TRACE("Created palette %p.\n", object);
3447 *Palette = &object->IDirectDrawPalette_iface;
3448 wined3d_mutex_unlock();
3449
3450 return DD_OK;
3451 }
3452
3453 static HRESULT WINAPI ddraw4_CreatePalette(IDirectDraw4 *iface, DWORD flags, PALETTEENTRY *entries,
3454 IDirectDrawPalette **palette, IUnknown *outer_unknown)
3455 {
3456 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3457 HRESULT hr;
3458
3459 TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3460 iface, flags, entries, palette, outer_unknown);
3461
3462 hr = ddraw7_CreatePalette(&ddraw->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3463 if (SUCCEEDED(hr) && *palette)
3464 {
3465 struct ddraw_palette *impl = impl_from_IDirectDrawPalette(*palette);
3466 IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
3467 IDirectDraw4_AddRef(iface);
3468 impl->ifaceToRelease = (IUnknown *)iface;
3469 }
3470 return hr;
3471 }
3472
3473 static HRESULT WINAPI ddraw2_CreatePalette(IDirectDraw2 *iface, DWORD flags,
3474 PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3475 {
3476 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3477 HRESULT hr;
3478
3479 TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3480 iface, flags, entries, palette, outer_unknown);
3481
3482 hr = ddraw7_CreatePalette(&ddraw->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3483 if (SUCCEEDED(hr) && *palette)
3484 {
3485 struct ddraw_palette *impl = impl_from_IDirectDrawPalette(*palette);
3486 IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
3487 impl->ifaceToRelease = NULL;
3488 }
3489
3490 return hr;
3491 }
3492
3493 static HRESULT WINAPI ddraw1_CreatePalette(IDirectDraw *iface, DWORD flags,
3494 PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3495 {
3496 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3497 HRESULT hr;
3498
3499 TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3500 iface, flags, entries, palette, outer_unknown);
3501
3502 hr = ddraw7_CreatePalette(&ddraw->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3503 if (SUCCEEDED(hr) && *palette)
3504 {
3505 struct ddraw_palette *impl = impl_from_IDirectDrawPalette(*palette);
3506 IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
3507 impl->ifaceToRelease = NULL;
3508 }
3509
3510 return hr;
3511 }
3512
3513 /*****************************************************************************
3514 * IDirectDraw7::DuplicateSurface
3515 *
3516 * Duplicates a surface. The surface memory points to the same memory as
3517 * the original surface, and it's released when the last surface referencing
3518 * it is released. I guess that's beyond Wine's surface management right now
3519 * (Idea: create a new DDraw surface with the same WineD3DSurface. I need a
3520 * test application to implement this)
3521 *
3522 * Params:
3523 * Src: Address of the source surface
3524 * Dest: Address to write the new surface pointer to
3525 *
3526 * Returns:
3527 * See IDirectDraw7::CreateSurface
3528 *
3529 *****************************************************************************/
3530 static HRESULT WINAPI ddraw7_DuplicateSurface(IDirectDraw7 *iface,
3531 IDirectDrawSurface7 *Src, IDirectDrawSurface7 **Dest)
3532 {
3533 struct ddraw_surface *src_surface = unsafe_impl_from_IDirectDrawSurface7(Src);
3534
3535 FIXME("iface %p, src %p, dst %p partial stub!\n", iface, Src, Dest);
3536
3537 /* For now, simply create a new, independent surface */
3538 return IDirectDraw7_CreateSurface(iface, &src_surface->surface_desc, Dest, NULL);
3539 }
3540
3541 static HRESULT WINAPI ddraw4_DuplicateSurface(IDirectDraw4 *iface, IDirectDrawSurface4 *src,
3542 IDirectDrawSurface4 **dst)
3543 {
3544 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface4(src);
3545 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3546 struct ddraw_surface *dst_impl;
3547 IDirectDrawSurface7 *dst7;
3548 HRESULT hr;
3549
3550 TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3551
3552 hr = ddraw7_DuplicateSurface(&ddraw->IDirectDraw7_iface,
3553 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3554 if (FAILED(hr))
3555 {
3556 *dst = NULL;
3557 return hr;
3558 }
3559 dst_impl = impl_from_IDirectDrawSurface7(dst7);
3560 *dst = &dst_impl->IDirectDrawSurface4_iface;
3561 IDirectDrawSurface4_AddRef(*dst);
3562 IDirectDrawSurface7_Release(dst7);
3563
3564 return hr;
3565 }
3566
3567 static HRESULT WINAPI ddraw2_DuplicateSurface(IDirectDraw2 *iface,
3568 IDirectDrawSurface *src, IDirectDrawSurface **dst)
3569 {
3570 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface(src);
3571 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3572 struct ddraw_surface *dst_impl;
3573 IDirectDrawSurface7 *dst7;
3574 HRESULT hr;
3575
3576 TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3577
3578 hr = ddraw7_DuplicateSurface(&ddraw->IDirectDraw7_iface,
3579 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3580 if (FAILED(hr))
3581 return hr;
3582 dst_impl = impl_from_IDirectDrawSurface7(dst7);
3583 *dst = &dst_impl->IDirectDrawSurface_iface;
3584 IDirectDrawSurface_AddRef(*dst);
3585 IDirectDrawSurface7_Release(dst7);
3586
3587 return hr;
3588 }
3589
3590 static HRESULT WINAPI ddraw1_DuplicateSurface(IDirectDraw *iface, IDirectDrawSurface *src,
3591 IDirectDrawSurface **dst)
3592 {
3593 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface(src);
3594 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3595 struct ddraw_surface *dst_impl;
3596 IDirectDrawSurface7 *dst7;
3597 HRESULT hr;
3598
3599 TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3600
3601 hr = ddraw7_DuplicateSurface(&ddraw->IDirectDraw7_iface,
3602 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3603 if (FAILED(hr))
3604 return hr;
3605 dst_impl = impl_from_IDirectDrawSurface7(dst7);
3606 *dst = &dst_impl->IDirectDrawSurface_iface;
3607 IDirectDrawSurface_AddRef(*dst);
3608 IDirectDrawSurface7_Release(dst7);
3609
3610 return hr;
3611 }
3612
3613 /*****************************************************************************
3614 * IDirect3D7::EnumDevices
3615 *
3616 * The EnumDevices method for IDirect3D7. It enumerates all supported
3617 * D3D7 devices. Currently the T&L, HAL and RGB devices are enumerated.
3618 *
3619 * Params:
3620 * callback: Function to call for each enumerated device
3621 * context: Pointer to pass back to the app
3622 *
3623 * Returns:
3624 * D3D_OK, or the return value of the GetCaps call
3625 *
3626 *****************************************************************************/
3627 static HRESULT WINAPI d3d7_EnumDevices(IDirect3D7 *iface, LPD3DENUMDEVICESCALLBACK7 callback, void *context)
3628 {
3629 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
3630 D3DDEVICEDESC7 device_desc7;
3631 HRESULT hr;
3632 size_t i;
3633
3634 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3635
3636 if (!callback)
3637 return DDERR_INVALIDPARAMS;
3638
3639 wined3d_mutex_lock();
3640
3641 if (FAILED(hr = ddraw_get_d3dcaps(ddraw, &device_desc7)))
3642 {
3643 wined3d_mutex_unlock();
3644 return hr;
3645 }
3646
3647 for (i = 0; i < ARRAY_SIZE(device_list7); i++)
3648 {
3649 HRESULT ret;
3650
3651 device_desc7.deviceGUID = *device_list7[i].device_guid;
3652 ret = callback(device_list7[i].interface_name, device_list7[i].device_name, &device_desc7, context);
3653 if (ret != DDENUMRET_OK)
3654 {
3655 TRACE("Application cancelled the enumeration.\n");
3656 wined3d_mutex_unlock();
3657 return D3D_OK;
3658 }
3659 }
3660
3661 TRACE("End of enumeration.\n");
3662
3663 wined3d_mutex_unlock();
3664
3665 return D3D_OK;
3666 }
3667
3668 /*****************************************************************************
3669 * IDirect3D3::EnumDevices
3670 *
3671 * Enumerates all supported Direct3DDevice interfaces. This is the
3672 * implementation for Direct3D 1 to Direc3D 3, Version 7 has its own.
3673 *
3674 * Versions 1, 2 and 3
3675 *
3676 * Params:
3677 * callback: Application-provided routine to call for each enumerated device
3678 * Context: Pointer to pass to the callback
3679 *
3680 * Returns:
3681 * D3D_OK on success,
3682 * The result of IDirect3DImpl_GetCaps if it failed
3683 *
3684 *****************************************************************************/
3685 static HRESULT WINAPI d3d3_EnumDevices(IDirect3D3 *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
3686 {
3687 static CHAR wined3d_description[] = "Wine D3DDevice using WineD3D and OpenGL";
3688
3689 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3690 D3DDEVICEDESC device_desc1, hal_desc, hel_desc;
3691 D3DDEVICEDESC7 device_desc7;
3692 HRESULT hr;
3693
3694 /* Some games (Motoracer 2 demo) have the bad idea to modify the device
3695 * name string. Let's put the string in a sufficiently sized array in
3696 * writable memory. */
3697 char device_name[50];
3698 strcpy(device_name,"Direct3D HEL");
3699
3700 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3701
3702 if (!callback)
3703 return DDERR_INVALIDPARAMS;
3704
3705 wined3d_mutex_lock();
3706
3707 if (FAILED(hr = ddraw_get_d3dcaps(ddraw, &device_desc7)))
3708 {
3709 wined3d_mutex_unlock();
3710 return hr;
3711 }
3712 ddraw_d3dcaps1_from_7(&device_desc1, &device_desc7);
3713
3714 /* Do I have to enumerate the reference id? Note from old d3d7:
3715 * "It seems that enumerating the reference IID on Direct3D 1 games
3716 * (AvP / Motoracer2) breaks them". So do not enumerate this iid in V1
3717 *
3718 * There's a registry key HKLM\Software\Microsoft\Direct3D\Drivers,
3719 * EnumReference which enables / disables enumerating the reference
3720 * rasterizer. It's a DWORD, 0 means disabled, 2 means enabled. The
3721 * enablerefrast.reg and disablerefrast.reg files in the DirectX 7.0 sdk
3722 * demo directory suggest this.
3723 *
3724 * Some games(GTA 2) seem to use the second enumerated device, so I have
3725 * to enumerate at least 2 devices. So enumerate the reference device to
3726 * have 2 devices.
3727 *
3728 * Other games (Rollcage) tell emulation and hal device apart by certain
3729 * flags. Rollcage expects D3DPTEXTURECAPS_POW2 to be set (yeah, it is a
3730 * limitation flag), and it refuses all devices that have the perspective
3731 * flag set. This way it refuses the emulation device, and HAL devices
3732 * never have POW2 unset in d3d7 on windows. */
3733 if (ddraw->d3dversion != 1)
3734 {
3735 static CHAR reference_description[] = "RGB Direct3D emulation";
3736
3737 TRACE("Enumerating WineD3D D3DDevice interface.\n");
3738 hal_desc = device_desc1;
3739 hel_desc = device_desc1;
3740 /* The rgb device has the pow2 flag set in the hel caps, but not in the hal caps. */
3741 hal_desc.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
3742 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
3743 hal_desc.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
3744 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
3745 /* RGB, RAMP and MMX devices have a HAL dcmColorModel of 0 */
3746 hal_desc.dcmColorModel = 0;
3747 /* RGB, RAMP and MMX devices cannot report HAL hardware flags */
3748 hal_desc.dwFlags = 0;
3749
3750 hr = callback((GUID *)&IID_IDirect3DRGBDevice, reference_description,
3751 device_name, &hal_desc, &hel_desc, context);
3752 if (hr != D3DENUMRET_OK)
3753 {
3754 TRACE("Application cancelled the enumeration.\n");
3755 wined3d_mutex_unlock();
3756 return D3D_OK;
3757 }
3758 }
3759
3760 strcpy(device_name,"Direct3D HAL");
3761
3762 TRACE("Enumerating HAL Direct3D device.\n");
3763 hal_desc = device_desc1;
3764 hel_desc = device_desc1;
3765
3766 /* The hal device does not have the pow2 flag set in hel, but in hal. */
3767 hel_desc.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
3768 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
3769 hel_desc.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
3770 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
3771 /* HAL devices have a HEL dcmColorModel of 0 */
3772 hel_desc.dcmColorModel = 0;
3773
3774 hr = callback((GUID *)&IID_IDirect3DHALDevice, wined3d_description,
3775 device_name, &hal_desc, &hel_desc, context);
3776 if (hr != D3DENUMRET_OK)
3777 {
3778 TRACE("Application cancelled the enumeration.\n");
3779 wined3d_mutex_unlock();
3780 return D3D_OK;
3781 }
3782
3783 TRACE("End of enumeration.\n");
3784
3785 wined3d_mutex_unlock();
3786
3787 return D3D_OK;
3788 }
3789
3790 static HRESULT WINAPI d3d2_EnumDevices(IDirect3D2 *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
3791 {
3792 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
3793
3794 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3795
3796 return d3d3_EnumDevices(&ddraw->IDirect3D3_iface, callback, context);
3797 }
3798
3799 static HRESULT WINAPI d3d1_EnumDevices(IDirect3D *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
3800 {
3801 struct ddraw *ddraw = impl_from_IDirect3D(iface);
3802
3803 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3804
3805 return d3d3_EnumDevices(&ddraw->IDirect3D3_iface, callback, context);
3806 }
3807
3808 /*****************************************************************************
3809 * IDirect3D3::CreateLight
3810 *
3811 * Creates an IDirect3DLight interface. This interface is used in
3812 * Direct3D3 or earlier for lighting. In Direct3D7 it has been replaced
3813 * by the DIRECT3DLIGHT7 structure. Wine's Direct3DLight implementation
3814 * uses the IDirect3DDevice7 interface with D3D7 lights.
3815 *
3816 * Versions 1, 2 and 3
3817 *
3818 * Params:
3819 * light: Address to store the new interface pointer
3820 * outer_unknown: Basically for aggregation, but ddraw doesn't support it.
3821 * Must be NULL
3822 *
3823 * Returns:
3824 * D3D_OK on success
3825 * DDERR_OUTOFMEMORY if memory allocation failed
3826 * CLASS_E_NOAGGREGATION if outer_unknown != NULL
3827 *
3828 *****************************************************************************/
3829 static HRESULT WINAPI d3d3_CreateLight(IDirect3D3 *iface, IDirect3DLight **light,
3830 IUnknown *outer_unknown)
3831 {
3832 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3833 struct d3d_light *object;
3834
3835 TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
3836
3837 if (outer_unknown)
3838 return CLASS_E_NOAGGREGATION;
3839
3840 if (!(object = heap_alloc_zero(sizeof(*object))))
3841 {
3842 ERR("Failed to allocate light memory.\n");
3843 return DDERR_OUTOFMEMORY;
3844 }
3845
3846 d3d_light_init(object, ddraw);
3847
3848 TRACE("Created light %p.\n", object);
3849 *light = &object->IDirect3DLight_iface;
3850
3851 return D3D_OK;
3852 }
3853
3854 static HRESULT WINAPI d3d2_CreateLight(IDirect3D2 *iface, IDirect3DLight **light, IUnknown *outer_unknown)
3855 {
3856 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
3857
3858 TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
3859
3860 return d3d3_CreateLight(&ddraw->IDirect3D3_iface, light, outer_unknown);
3861 }
3862
3863 static HRESULT WINAPI d3d1_CreateLight(IDirect3D *iface, IDirect3DLight **light, IUnknown *outer_unknown)
3864 {
3865 struct ddraw *ddraw = impl_from_IDirect3D(iface);
3866
3867 TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
3868
3869 return d3d3_CreateLight(&ddraw->IDirect3D3_iface, light, outer_unknown);
3870 }
3871
3872 /*****************************************************************************
3873 * IDirect3D3::CreateMaterial
3874 *
3875 * Creates an IDirect3DMaterial interface. This interface is used by Direct3D3
3876 * and older versions. The IDirect3DMaterial implementation wraps its
3877 * functionality to IDirect3DDevice7::SetMaterial and friends.
3878 *
3879 * Versions 1, 2 and 3
3880 *
3881 * Params:
3882 * material: Address to store the new interface's pointer to
3883 * outer_unknown: Basically for aggregation, but ddraw doesn't support it.
3884 * Must be NULL
3885 *
3886 * Returns:
3887 * D3D_OK on success
3888 * DDERR_OUTOFMEMORY if memory allocation failed
3889 * CLASS_E_NOAGGREGATION if outer_unknown != NULL
3890 *
3891 *****************************************************************************/
3892 static HRESULT WINAPI d3d3_CreateMaterial(IDirect3D3 *iface, IDirect3DMaterial3 **material,
3893 IUnknown *outer_unknown)
3894 {
3895 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3896 struct d3d_material *object;
3897
3898 TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
3899
3900 if (outer_unknown) return CLASS_E_NOAGGREGATION;
3901
3902 object = d3d_material_create(ddraw);
3903 if (!object)
3904 {
3905 ERR("Failed to allocate material memory.\n");
3906 return DDERR_OUTOFMEMORY;
3907 }
3908
3909 TRACE("Created material %p.\n", object);
3910 *material = &object->IDirect3DMaterial3_iface;
3911
3912 return D3D_OK;
3913 }
3914
3915 static HRESULT WINAPI d3d2_CreateMaterial(IDirect3D2 *iface, IDirect3DMaterial2 **material,
3916 IUnknown *outer_unknown)
3917 {
3918 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
3919 struct d3d_material *object;
3920
3921 TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
3922
3923 object = d3d_material_create(ddraw);
3924 if (!object)
3925 {
3926 ERR("Failed to allocate material memory.\n");
3927 return DDERR_OUTOFMEMORY;
3928 }
3929
3930 TRACE("Created material %p.\n", object);
3931 *material = &object->IDirect3DMaterial2_iface;
3932
3933 return D3D_OK;
3934 }
3935
3936 static HRESULT WINAPI d3d1_CreateMaterial(IDirect3D *iface, IDirect3DMaterial **material,
3937 IUnknown *outer_unknown)
3938 {
3939 struct ddraw *ddraw = impl_from_IDirect3D(iface);
3940 struct d3d_material *object;
3941
3942 TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
3943
3944 object = d3d_material_create(ddraw);
3945 if (!object)
3946 {
3947 ERR("Failed to allocate material memory.\n");
3948 return DDERR_OUTOFMEMORY;
3949 }
3950
3951 TRACE("Created material %p.\n", object);
3952 *material = &object->IDirect3DMaterial_iface;
3953
3954 return D3D_OK;
3955 }
3956
3957 /*****************************************************************************
3958 * IDirect3D3::CreateViewport
3959 *
3960 * Creates an IDirect3DViewport interface. This interface is used
3961 * by Direct3D and earlier versions for Viewport management. In Direct3D7
3962 * it has been replaced by a viewport structure and
3963 * IDirect3DDevice7::*Viewport. Wine's IDirect3DViewport implementation
3964 * uses the IDirect3DDevice7 methods for its functionality
3965 *
3966 * Params:
3967 * Viewport: Address to store the new interface pointer
3968 * outer_unknown: Basically for aggregation, but ddraw doesn't support it.
3969 * Must be NULL
3970 *
3971 * Returns:
3972 * D3D_OK on success
3973 * DDERR_OUTOFMEMORY if memory allocation failed
3974 * CLASS_E_NOAGGREGATION if outer_unknown != NULL
3975 *
3976 *****************************************************************************/
3977 static HRESULT WINAPI d3d3_CreateViewport(IDirect3D3 *iface, IDirect3DViewport3 **viewport,
3978 IUnknown *outer_unknown)
3979 {
3980 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3981 struct d3d_viewport *object;
3982
3983 TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
3984
3985 if (outer_unknown) return CLASS_E_NOAGGREGATION;
3986
3987 if (!(object = heap_alloc_zero(sizeof(*object))))
3988 {
3989 ERR("Failed to allocate viewport memory.\n");
3990 return DDERR_OUTOFMEMORY;
3991 }
3992
3993 d3d_viewport_init(object, ddraw);
3994
3995 TRACE("Created viewport %p.\n", object);
3996 *viewport = &object->IDirect3DViewport3_iface;
3997
3998 return D3D_OK;
3999 }
4000
4001 static HRESULT WINAPI d3d2_CreateViewport(IDirect3D2 *iface, IDirect3DViewport2 **viewport, IUnknown *outer_unknown)
4002 {
4003 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4004
4005 TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4006
4007 return d3d3_CreateViewport(&ddraw->IDirect3D3_iface, (IDirect3DViewport3 **)viewport,
4008 outer_unknown);
4009 }
4010
4011 static HRESULT WINAPI d3d1_CreateViewport(IDirect3D *iface, IDirect3DViewport **viewport, IUnknown *outer_unknown)
4012 {
4013 struct ddraw *ddraw = impl_from_IDirect3D(iface);
4014
4015 TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4016
4017 return d3d3_CreateViewport(&ddraw->IDirect3D3_iface, (IDirect3DViewport3 **)viewport,
4018 outer_unknown);
4019 }
4020
4021 /*****************************************************************************
4022 * IDirect3D3::FindDevice
4023 *
4024 * This method finds a device with the requested properties and returns a
4025 * device description
4026 *
4027 * Versions 1, 2 and 3
4028 * Params:
4029 * fds: Describes the requested device characteristics
4030 * fdr: Returns the device description
4031 *
4032 * Returns:
4033 * D3D_OK on success
4034 * DDERR_INVALIDPARAMS if no device was found
4035 *
4036 *****************************************************************************/
4037 static HRESULT WINAPI d3d3_FindDevice(IDirect3D3 *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4038 {
4039 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4040 D3DDEVICEDESC7 desc7;
4041 D3DDEVICEDESC desc1;
4042 HRESULT hr;
4043
4044 TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4045
4046 if (!fds || !fdr) return DDERR_INVALIDPARAMS;
4047
4048 if (fds->dwSize != sizeof(D3DFINDDEVICESEARCH)
4049 || fdr->dwSize != sizeof(D3DFINDDEVICERESULT))
4050 return DDERR_INVALIDPARAMS;
4051
4052 if ((fds->dwFlags & D3DFDS_COLORMODEL)
4053 && fds->dcmColorModel != D3DCOLOR_RGB)
4054 {
4055 WARN("Trying to request a non-RGB D3D color model. Not supported.\n");
4056 return DDERR_INVALIDPARAMS; /* No real idea what to return here :-) */
4057 }
4058
4059 if (fds->dwFlags & D3DFDS_GUID)
4060 {
4061 TRACE("Trying to match guid %s.\n", debugstr_guid(&(fds->guid)));
4062 if (!IsEqualGUID(&IID_D3DDEVICE_WineD3D, &fds->guid)
4063 && !IsEqualGUID(&IID_IDirect3DHALDevice, &fds->guid)
4064 && !IsEqualGUID(&IID_IDirect3DRGBDevice, &fds->guid))
4065 {
4066 WARN("No match for this GUID.\n");
4067 return DDERR_NOTFOUND;
4068 }
4069 }
4070
4071 /* Get the caps */
4072 if (FAILED(hr = ddraw_get_d3dcaps(ddraw, &desc7)))
4073 return hr;
4074
4075 /* Now return our own GUID */
4076 ddraw_d3dcaps1_from_7(&desc1, &desc7);
4077 fdr->guid = IID_D3DDEVICE_WineD3D;
4078 fdr->ddHwDesc = desc1;
4079 fdr->ddSwDesc = desc1;
4080
4081 TRACE("Returning Wine's wined3d device with (undumped) capabilities.\n");
4082
4083 return D3D_OK;
4084 }
4085
4086 static HRESULT WINAPI d3d2_FindDevice(IDirect3D2 *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4087 {
4088 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4089
4090 TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4091
4092 return d3d3_FindDevice(&ddraw->IDirect3D3_iface, fds, fdr);
4093 }
4094
4095 static HRESULT WINAPI d3d1_FindDevice(IDirect3D *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4096 {
4097 struct ddraw *ddraw = impl_from_IDirect3D(iface);
4098
4099 TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4100
4101 return d3d3_FindDevice(&ddraw->IDirect3D3_iface, fds, fdr);
4102 }
4103
4104 /*****************************************************************************
4105 * IDirect3D7::CreateDevice
4106 *
4107 * Creates an IDirect3DDevice7 interface.
4108 *
4109 * Versions 2, 3 and 7. IDirect3DDevice 1 interfaces are interfaces to
4110 * DirectDraw surfaces and are created with
4111 * IDirectDrawSurface::QueryInterface. This method uses CreateDevice to
4112 * create the device object and QueryInterfaces for IDirect3DDevice
4113 *
4114 * Params:
4115 * refiid: IID of the device to create
4116 * Surface: Initial rendertarget
4117 * Device: Address to return the interface pointer
4118 *
4119 * Returns:
4120 * D3D_OK on success
4121 * DDERR_OUTOFMEMORY if memory allocation failed
4122 * DDERR_INVALIDPARAMS if a device exists already
4123 *
4124 *****************************************************************************/
4125 static HRESULT WINAPI d3d7_CreateDevice(IDirect3D7 *iface, REFCLSID riid,
4126 IDirectDrawSurface7 *surface, IDirect3DDevice7 **device)
4127 {
4128 struct ddraw_surface *target = unsafe_impl_from_IDirectDrawSurface7(surface);
4129 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4130 struct d3d_device *object;
4131 HRESULT hr;
4132
4133 TRACE("iface %p, riid %s, surface %p, device %p.\n", iface, debugstr_guid(riid), surface, device);
4134
4135 wined3d_mutex_lock();
4136 if (SUCCEEDED(hr = d3d_device_create(ddraw, target, (IUnknown *)surface, 7, &object, NULL)))
4137 {
4138 *device = &object->IDirect3DDevice7_iface;
4139 }
4140 else
4141 {
4142 WARN("Failed to create device, hr %#x.\n", hr);
4143 *device = NULL;
4144 }
4145 wined3d_mutex_unlock();
4146
4147 return hr;
4148 }
4149
4150 static HRESULT WINAPI d3d3_CreateDevice(IDirect3D3 *iface, REFCLSID riid,
4151 IDirectDrawSurface4 *surface, IDirect3DDevice3 **device, IUnknown *outer_unknown)
4152 {
4153 struct ddraw_surface *surface_impl = unsafe_impl_from_IDirectDrawSurface4(surface);
4154 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4155 struct d3d_device *device_impl;
4156 HRESULT hr;
4157
4158 TRACE("iface %p, riid %s, surface %p, device %p, outer_unknown %p.\n",
4159 iface, debugstr_guid(riid), surface, device, outer_unknown);
4160
4161 if (outer_unknown)
4162 return CLASS_E_NOAGGREGATION;
4163
4164 wined3d_mutex_lock();
4165 if (SUCCEEDED(hr = d3d_device_create(ddraw, surface_impl, (IUnknown *)surface, 3, &device_impl, NULL)))
4166 {
4167 *device = &device_impl->IDirect3DDevice3_iface;
4168 }
4169 else
4170 {
4171 WARN("Failed to create device, hr %#x.\n", hr);
4172 *device = NULL;
4173 }
4174 wined3d_mutex_unlock();
4175
4176 return hr;
4177 }
4178
4179 static HRESULT WINAPI d3d2_CreateDevice(IDirect3D2 *iface, REFCLSID riid,
4180 IDirectDrawSurface *surface, IDirect3DDevice2 **device)
4181 {
4182 struct ddraw_surface *surface_impl = unsafe_impl_from_IDirectDrawSurface(surface);
4183 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4184 struct d3d_device *device_impl;
4185 HRESULT hr;
4186
4187 TRACE("iface %p, riid %s, surface %p, device %p.\n",
4188 iface, debugstr_guid(riid), surface, device);
4189
4190 wined3d_mutex_lock();
4191 if (SUCCEEDED(hr = d3d_device_create(ddraw, surface_impl, (IUnknown *)surface, 2, &device_impl, NULL)))
4192 {
4193 *device = &device_impl->IDirect3DDevice2_iface;
4194 }
4195 else
4196 {
4197 WARN("Failed to create device, hr %#x.\n", hr);
4198 *device = NULL;
4199 }
4200 wined3d_mutex_unlock();
4201
4202 return hr;
4203 }
4204
4205 /*****************************************************************************
4206 * IDirect3D7::CreateVertexBuffer
4207 *
4208 * Creates a new vertex buffer object and returns a IDirect3DVertexBuffer7
4209 * interface.
4210 *
4211 * Versions 3 and 7
4212 *
4213 * Params:
4214 * desc: Requested Vertex buffer properties
4215 * vertex_buffer: Address to return the interface pointer at
4216 * flags: Some flags, should be 0
4217 *
4218 * Returns
4219 * D3D_OK on success
4220 * DDERR_OUTOFMEMORY if memory allocation failed
4221 * DDERR_INVALIDPARAMS if desc or vertex_buffer is NULL
4222 *
4223 *****************************************************************************/
4224 static HRESULT WINAPI d3d7_CreateVertexBuffer(IDirect3D7 *iface, D3DVERTEXBUFFERDESC *desc,
4225 IDirect3DVertexBuffer7 **vertex_buffer, DWORD flags)
4226 {
4227 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4228 struct d3d_vertex_buffer *object;
4229 HRESULT hr;
4230
4231 TRACE("iface %p, desc %p, vertex_buffer %p, flags %#x.\n",
4232 iface, desc, vertex_buffer, flags);
4233
4234 if (!vertex_buffer || !desc) return DDERR_INVALIDPARAMS;
4235
4236 hr = d3d_vertex_buffer_create(&object, ddraw, desc);
4237 if (hr == D3D_OK)
4238 {
4239 TRACE("Created vertex buffer %p.\n", object);
4240 *vertex_buffer = &object->IDirect3DVertexBuffer7_iface;
4241 }
4242 else
4243 WARN("Failed to create vertex buffer, hr %#x.\n", hr);
4244
4245 return hr;
4246 }
4247
4248 static HRESULT WINAPI d3d3_CreateVertexBuffer(IDirect3D3 *iface, D3DVERTEXBUFFERDESC *desc,
4249 IDirect3DVertexBuffer **vertex_buffer, DWORD flags, IUnknown *outer_unknown)
4250 {
4251 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4252 struct d3d_vertex_buffer *object;
4253 HRESULT hr;
4254
4255 TRACE("iface %p, desc %p, vertex_buffer %p, flags %#x, outer_unknown %p.\n",
4256 iface, desc, vertex_buffer, flags, outer_unknown);
4257
4258 if (outer_unknown)
4259 return CLASS_E_NOAGGREGATION;
4260 if (!vertex_buffer || !desc)
4261 return DDERR_INVALIDPARAMS;
4262
4263 hr = d3d_vertex_buffer_create(&object, ddraw, desc);
4264 if (hr == D3D_OK)
4265 {
4266 TRACE("Created vertex buffer %p.\n", object);
4267 *vertex_buffer = (IDirect3DVertexBuffer *)&object->IDirect3DVertexBuffer7_iface;
4268 }
4269 else
4270 WARN("Failed to create vertex buffer, hr %#x.\n", hr);
4271
4272 return hr;
4273 }
4274
4275 /*****************************************************************************
4276 * IDirect3D7::EnumZBufferFormats
4277 *
4278 * Enumerates all supported Z buffer pixel formats
4279 *
4280 * Versions 3 and 7
4281 *
4282 * Params:
4283 * device_iid:
4284 * callback: callback to call for each pixel format
4285 * context: Pointer to pass back to the callback
4286 *
4287 * Returns:
4288 * D3D_OK on success
4289 * DDERR_INVALIDPARAMS if callback is NULL
4290 *
4291 *****************************************************************************/
4292 static HRESULT WINAPI d3d7_EnumZBufferFormats(IDirect3D7 *iface, REFCLSID device_iid,
4293 LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
4294 {
4295 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4296 struct wined3d_display_mode mode;
4297 enum wined3d_device_type type;
4298 unsigned int i;
4299 HRESULT hr;
4300
4301 /* Order matters. Specifically, BattleZone II (full version) expects the
4302 * 16-bit depth formats to be listed before the 24 and 32 ones. */
4303 static const enum wined3d_format_id formats[] =
4304 {
4305 WINED3DFMT_S1_UINT_D15_UNORM,
4306 WINED3DFMT_D16_UNORM,
4307 WINED3DFMT_X8D24_UNORM,
4308 WINED3DFMT_S4X4_UINT_D24_UNORM,
4309 WINED3DFMT_D24_UNORM_S8_UINT,
4310 WINED3DFMT_D32_UNORM,
4311 };
4312
4313 TRACE("iface %p, device_iid %s, callback %p, context %p.\n",
4314 iface, debugstr_guid(device_iid), callback, context);
4315
4316 if (!callback) return DDERR_INVALIDPARAMS;
4317
4318 if (IsEqualGUID(device_iid, &IID_IDirect3DHALDevice)
4319 || IsEqualGUID(device_iid, &IID_IDirect3DTnLHalDevice)
4320 || IsEqualGUID(device_iid, &IID_D3DDEVICE_WineD3D))
4321 {
4322 TRACE("Asked for HAL device.\n");
4323 type = WINED3D_DEVICE_TYPE_HAL;
4324 }
4325 else if (IsEqualGUID(device_iid, &IID_IDirect3DRGBDevice)
4326 || IsEqualGUID(device_iid, &IID_IDirect3DMMXDevice))
4327 {
4328 TRACE("Asked for SW device.\n");
4329 type = WINED3D_DEVICE_TYPE_SW;
4330 }
4331 else if (IsEqualGUID(device_iid, &IID_IDirect3DRefDevice))
4332 {
4333 TRACE("Asked for REF device.\n");
4334 type = WINED3D_DEVICE_TYPE_REF;
4335 }
4336 else if (IsEqualGUID(device_iid, &IID_IDirect3DNullDevice))
4337 {
4338 TRACE("Asked for NULLREF device.\n");
4339 type = WINED3D_DEVICE_TYPE_NULLREF;
4340 }
4341 else
4342 {
4343 FIXME("Unexpected device GUID %s.\n", debugstr_guid(device_iid));
4344 type = WINED3D_DEVICE_TYPE_HAL;
4345 }
4346
4347 wined3d_mutex_lock();
4348 /* We need an adapter format from somewhere to please wined3d and WGL.
4349 * Use the current display mode. So far all cards offer the same depth
4350 * stencil format for all modes, but if some do not and applications do
4351 * not like that we'll have to find some workaround, like iterating over
4352 * all imaginable formats and collecting all the depth stencil formats we
4353 * can get. */
4354 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
4355 {
4356 ERR("Failed to get display mode, hr %#x.\n", hr);
4357 wined3d_mutex_unlock();
4358 return hr;
4359 }
4360
4361 for (i = 0; i < ARRAY_SIZE(formats); ++i)
4362 {
4363 if (SUCCEEDED(wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, type, mode.format_id,
4364 WINED3DUSAGE_DEPTHSTENCIL, WINED3D_RTYPE_TEXTURE_2D, formats[i])))
4365 {
4366 DDPIXELFORMAT pformat;
4367
4368 memset(&pformat, 0, sizeof(pformat));
4369 pformat.dwSize = sizeof(pformat);
4370 ddrawformat_from_wined3dformat(&pformat, formats[i]);
4371
4372 TRACE("Enumerating wined3d format %#x.\n", formats[i]);
4373 hr = callback(&pformat, context);
4374 if (hr != DDENUMRET_OK)
4375 {
4376 TRACE("Format enumeration cancelled by application.\n");
4377 wined3d_mutex_unlock();
4378 return D3D_OK;
4379 }
4380 }
4381 }
4382
4383 /* Historically some windows drivers used dwZBufferBitDepth=24 for WINED3DFMT_X8D24_UNORM,
4384 * while others used dwZBufferBitDepth=32. In either case the pitch matches a 32 bits per
4385 * pixel format, so we use dwZBufferBitDepth=32. Some games expect 24. Windows Vista and
4386 * newer enumerate both versions, so we do the same(bug 22434) */
4387 if (SUCCEEDED(wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, type, mode.format_id,
4388 WINED3DUSAGE_DEPTHSTENCIL, WINED3D_RTYPE_TEXTURE_2D, WINED3DFMT_X8D24_UNORM)))
4389 {
4390 DDPIXELFORMAT x8d24 =
4391 {
4392 sizeof(x8d24), DDPF_ZBUFFER, 0,
4393 {24}, {0x00000000}, {0x00ffffff}, {0x00000000}
4394 };
4395 TRACE("Enumerating WINED3DFMT_X8D24_UNORM, dwZBufferBitDepth=24 version\n");
4396 callback(&x8d24, context);
4397 }
4398
4399 TRACE("End of enumeration.\n");
4400
4401 wined3d_mutex_unlock();
4402
4403 return D3D_OK;
4404 }
4405
4406 static HRESULT WINAPI d3d3_EnumZBufferFormats(IDirect3D3 *iface, REFCLSID device_iid,
4407 LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
4408 {
4409 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4410
4411 TRACE("iface %p, device_iid %s, callback %p, context %p.\n",
4412 iface, debugstr_guid(device_iid), callback, context);
4413
4414 return d3d7_EnumZBufferFormats(&ddraw->IDirect3D7_iface, device_iid, callback, context);
4415 }
4416
4417 /*****************************************************************************
4418 * IDirect3D7::EvictManagedTextures
4419 *
4420 * Removes all managed textures (=surfaces with DDSCAPS2_TEXTUREMANAGE or
4421 * DDSCAPS2_D3DTEXTUREMANAGE caps) to be removed from video memory.
4422 *
4423 * Versions 3 and 7
4424 *
4425 * Returns:
4426 * D3D_OK, because it's a stub
4427 *
4428 *****************************************************************************/
4429 static HRESULT WINAPI d3d7_EvictManagedTextures(IDirect3D7 *iface)
4430 {
4431 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4432
4433 TRACE("iface %p!\n", iface);
4434
4435 wined3d_mutex_lock();
4436 if (ddraw->flags & DDRAW_D3D_INITIALIZED)
4437 wined3d_device_evict_managed_resources(ddraw->wined3d_device);
4438 wined3d_mutex_unlock();
4439
4440 return D3D_OK;
4441 }
4442
4443 static HRESULT WINAPI d3d3_EvictManagedTextures(IDirect3D3 *iface)
4444 {
4445 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4446
4447 TRACE("iface %p.\n", iface);
4448
4449 return d3d7_EvictManagedTextures(&ddraw->IDirect3D7_iface);
4450 }
4451
4452 /*****************************************************************************
4453 * IDirectDraw7 VTable
4454 *****************************************************************************/
4455 static const struct IDirectDraw7Vtbl ddraw7_vtbl =
4456 {
4457 /* IUnknown */
4458 ddraw7_QueryInterface,
4459 ddraw7_AddRef,
4460 ddraw7_Release,
4461 /* IDirectDraw */
4462 ddraw7_Compact,
4463 ddraw7_CreateClipper,
4464 ddraw7_CreatePalette,
4465 ddraw7_CreateSurface,
4466 ddraw7_DuplicateSurface,
4467 ddraw7_EnumDisplayModes,
4468 ddraw7_EnumSurfaces,
4469 ddraw7_FlipToGDISurface,
4470 ddraw7_GetCaps,
4471 ddraw7_GetDisplayMode,
4472 ddraw7_GetFourCCCodes,
4473 ddraw7_GetGDISurface,
4474 ddraw7_GetMonitorFrequency,
4475 ddraw7_GetScanLine,
4476 ddraw7_GetVerticalBlankStatus,
4477 ddraw7_Initialize,
4478 ddraw7_RestoreDisplayMode,
4479 ddraw7_SetCooperativeLevel,
4480 ddraw7_SetDisplayMode,
4481 ddraw7_WaitForVerticalBlank,
4482 /* IDirectDraw2 */
4483 ddraw7_GetAvailableVidMem,
4484 /* IDirectDraw3 */
4485 ddraw7_GetSurfaceFromDC,
4486 /* IDirectDraw4 */
4487 ddraw7_RestoreAllSurfaces,
4488 ddraw7_TestCooperativeLevel,
4489 ddraw7_GetDeviceIdentifier,
4490 /* IDirectDraw7 */
4491 ddraw7_StartModeTest,
4492 ddraw7_EvaluateMode
4493 };
4494
4495 static const struct IDirectDraw4Vtbl ddraw4_vtbl =
4496 {
4497 /* IUnknown */
4498 ddraw4_QueryInterface,
4499 ddraw4_AddRef,
4500 ddraw4_Release,
4501 /* IDirectDraw */
4502 ddraw4_Compact,
4503 ddraw4_CreateClipper,
4504 ddraw4_CreatePalette,
4505 ddraw4_CreateSurface,
4506 ddraw4_DuplicateSurface,
4507 ddraw4_EnumDisplayModes,
4508 ddraw4_EnumSurfaces,
4509 ddraw4_FlipToGDISurface,
4510 ddraw4_GetCaps,
4511 ddraw4_GetDisplayMode,
4512 ddraw4_GetFourCCCodes,
4513 ddraw4_GetGDISurface,
4514 ddraw4_GetMonitorFrequency,
4515 ddraw4_GetScanLine,
4516 ddraw4_GetVerticalBlankStatus,
4517 ddraw4_Initialize,
4518 ddraw4_RestoreDisplayMode,
4519 ddraw4_SetCooperativeLevel,
4520 ddraw4_SetDisplayMode,
4521 ddraw4_WaitForVerticalBlank,
4522 /* IDirectDraw2 */
4523 ddraw4_GetAvailableVidMem,
4524 /* IDirectDraw3 */
4525 ddraw4_GetSurfaceFromDC,
4526 /* IDirectDraw4 */
4527 ddraw4_RestoreAllSurfaces,
4528 ddraw4_TestCooperativeLevel,
4529 ddraw4_GetDeviceIdentifier,
4530 };
4531
4532 static const struct IDirectDraw2Vtbl ddraw2_vtbl =
4533 {
4534 /* IUnknown */
4535 ddraw2_QueryInterface,
4536 ddraw2_AddRef,
4537 ddraw2_Release,
4538 /* IDirectDraw */
4539 ddraw2_Compact,
4540 ddraw2_CreateClipper,
4541 ddraw2_CreatePalette,
4542 ddraw2_CreateSurface,
4543 ddraw2_DuplicateSurface,
4544 ddraw2_EnumDisplayModes,
4545 ddraw2_EnumSurfaces,
4546 ddraw2_FlipToGDISurface,
4547 ddraw2_GetCaps,
4548 ddraw2_GetDisplayMode,
4549 ddraw2_GetFourCCCodes,
4550 ddraw2_GetGDISurface,
4551 ddraw2_GetMonitorFrequency,
4552 ddraw2_GetScanLine,
4553 ddraw2_GetVerticalBlankStatus,
4554 ddraw2_Initialize,
4555 ddraw2_RestoreDisplayMode,
4556 ddraw2_SetCooperativeLevel,
4557 ddraw2_SetDisplayMode,
4558 ddraw2_WaitForVerticalBlank,
4559 /* IDirectDraw2 */
4560 ddraw2_GetAvailableVidMem,
4561 };
4562
4563 static const struct IDirectDrawVtbl ddraw1_vtbl =
4564 {
4565 /* IUnknown */
4566 ddraw1_QueryInterface,
4567 ddraw1_AddRef,
4568 ddraw1_Release,
4569 /* IDirectDraw */
4570 ddraw1_Compact,
4571 ddraw1_CreateClipper,
4572 ddraw1_CreatePalette,
4573 ddraw1_CreateSurface,
4574 ddraw1_DuplicateSurface,
4575 ddraw1_EnumDisplayModes,
4576 ddraw1_EnumSurfaces,
4577 ddraw1_FlipToGDISurface,
4578 ddraw1_GetCaps,
4579 ddraw1_GetDisplayMode,
4580 ddraw1_GetFourCCCodes,
4581 ddraw1_GetGDISurface,
4582 ddraw1_GetMonitorFrequency,
4583 ddraw1_GetScanLine,
4584 ddraw1_GetVerticalBlankStatus,
4585 ddraw1_Initialize,
4586 ddraw1_RestoreDisplayMode,
4587 ddraw1_SetCooperativeLevel,
4588 ddraw1_SetDisplayMode,
4589 ddraw1_WaitForVerticalBlank,
4590 };
4591
4592 static const struct IDirect3D7Vtbl d3d7_vtbl =
4593 {
4594 /* IUnknown methods */
4595 d3d7_QueryInterface,
4596 d3d7_AddRef,
4597 d3d7_Release,
4598 /* IDirect3D7 methods */
4599 d3d7_EnumDevices,
4600 d3d7_CreateDevice,
4601 d3d7_CreateVertexBuffer,
4602 d3d7_EnumZBufferFormats,
4603 d3d7_EvictManagedTextures
4604 };
4605
4606 static const struct IDirect3D3Vtbl d3d3_vtbl =
4607 {
4608 /* IUnknown methods */
4609 d3d3_QueryInterface,
4610 d3d3_AddRef,
4611 d3d3_Release,
4612 /* IDirect3D3 methods */
4613 d3d3_EnumDevices,
4614 d3d3_CreateLight,
4615 d3d3_CreateMaterial,
4616 d3d3_CreateViewport,
4617 d3d3_FindDevice,
4618 d3d3_CreateDevice,
4619 d3d3_CreateVertexBuffer,
4620 d3d3_EnumZBufferFormats,
4621 d3d3_EvictManagedTextures
4622 };
4623
4624 static const struct IDirect3D2Vtbl d3d2_vtbl =
4625 {
4626 /* IUnknown methods */
4627 d3d2_QueryInterface,
4628 d3d2_AddRef,
4629 d3d2_Release,
4630 /* IDirect3D2 methods */
4631 d3d2_EnumDevices,
4632 d3d2_CreateLight,
4633 d3d2_CreateMaterial,
4634 d3d2_CreateViewport,
4635 d3d2_FindDevice,
4636 d3d2_CreateDevice
4637 };
4638
4639 static const struct IDirect3DVtbl d3d1_vtbl =
4640 {
4641 /* IUnknown methods */
4642 d3d1_QueryInterface,
4643 d3d1_AddRef,
4644 d3d1_Release,
4645 /* IDirect3D methods */
4646 d3d1_Initialize,
4647 d3d1_EnumDevices,
4648 d3d1_CreateLight,
4649 d3d1_CreateMaterial,
4650 d3d1_CreateViewport,
4651 d3d1_FindDevice
4652 };
4653
4654 /*****************************************************************************
4655 * ddraw_find_decl
4656 *
4657 * Finds the WineD3D vertex declaration for a specific fvf, and creates one
4658 * if none was found.
4659 *
4660 * This function is in ddraw.c and the DDraw object space because D3D7
4661 * vertex buffers are created using the IDirect3D interface to the ddraw
4662 * object, so they can be valid across D3D devices(theoretically. The ddraw
4663 * object also owns the wined3d device
4664 *
4665 * Parameters:
4666 * This: Device
4667 * fvf: Fvf to find the decl for
4668 *
4669 * Returns:
4670 * NULL in case of an error, the vertex declaration for the FVF otherwise.
4671 *
4672 *****************************************************************************/
4673 struct wined3d_vertex_declaration *ddraw_find_decl(struct ddraw *This, DWORD fvf)
4674 {
4675 struct wined3d_vertex_declaration *pDecl = NULL;
4676 HRESULT hr;
4677 int p, low, high; /* deliberately signed */
4678 struct FvfToDecl *convertedDecls = This->decls;
4679
4680 TRACE("Searching for declaration for fvf %08x... ", fvf);
4681
4682 low = 0;
4683 high = This->numConvertedDecls - 1;
4684 while(low <= high) {
4685 p = (low + high) >> 1;
4686 TRACE("%d ", p);
4687 if(convertedDecls[p].fvf == fvf) {
4688 TRACE("found %p\n", convertedDecls[p].decl);
4689 return convertedDecls[p].decl;
4690 } else if(convertedDecls[p].fvf < fvf) {
4691 low = p + 1;
4692 } else {
4693 high = p - 1;
4694 }
4695 }
4696 TRACE("not found. Creating and inserting at position %d.\n", low);
4697
4698 hr = wined3d_vertex_declaration_create_from_fvf(This->wined3d_device,
4699 fvf, This, &ddraw_null_wined3d_parent_ops, &pDecl);
4700 if (hr != S_OK) return NULL;
4701
4702 if (This->declArraySize == This->numConvertedDecls)
4703 {
4704 unsigned int grow = max(This->declArraySize / 2, 8);
4705
4706 if (!(convertedDecls = heap_realloc(convertedDecls,
4707 (This->numConvertedDecls + grow) * sizeof(*convertedDecls))))
4708 {
4709 wined3d_vertex_declaration_decref(pDecl);
4710 return NULL;
4711 }
4712 This->decls = convertedDecls;
4713 This->declArraySize += grow;
4714 }
4715
4716 memmove(convertedDecls + low + 1, convertedDecls + low, sizeof(convertedDecls[0]) * (This->numConvertedDecls - low));
4717 convertedDecls[low].decl = pDecl;
4718 convertedDecls[low].fvf = fvf;
4719 This->numConvertedDecls++;
4720
4721 TRACE("Returning %p. %d decls in array\n", pDecl, This->numConvertedDecls);
4722 return pDecl;
4723 }
4724
4725 static inline struct ddraw *ddraw_from_device_parent(struct wined3d_device_parent *device_parent)
4726 {
4727 return CONTAINING_RECORD(device_parent, struct ddraw, device_parent);
4728 }
4729
4730 static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent,
4731 struct wined3d_device *device)
4732 {
4733 TRACE("device_parent %p, device %p.\n", device_parent, device);
4734 }
4735
4736 /* This is run from device_process_message() in wined3d, we can't take the
4737 * wined3d mutex. */
4738 /* FIXME: We only get mode change notifications in exclusive mode, but we
4739 * should mark surfaces as lost on mode changes in DDSCL_NORMAL mode as well. */
4740 static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent)
4741 {
4742 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4743 MONITORINFO monitor_info;
4744 HMONITOR monitor;
4745 RECT *r;
4746
4747 TRACE("device_parent %p.\n", device_parent);
4748
4749 if (!(ddraw->cooperative_level & DDSCL_EXCLUSIVE) || !ddraw->swapchain_window)
4750 {
4751 TRACE("Nothing to resize.\n");
4752 return;
4753 }
4754
4755 monitor = MonitorFromWindow(ddraw->swapchain_window, MONITOR_DEFAULTTOPRIMARY);
4756 monitor_info.cbSize = sizeof(monitor_info);
4757 if (!GetMonitorInfoW(monitor, &monitor_info))
4758 {
4759 ERR("Failed to get monitor info.\n");
4760 return;
4761 }
4762
4763 r = &monitor_info.rcMonitor;
4764 TRACE("Resizing window %p to %s.\n", ddraw->swapchain_window, wine_dbgstr_rect(r));
4765
4766 if (!SetWindowPos(ddraw->swapchain_window, HWND_TOP, r->left, r->top,
4767 r->right - r->left, r->bottom - r->top, SWP_SHOWWINDOW | SWP_NOACTIVATE))
4768 ERR("Failed to resize window.\n");
4769
4770 InterlockedCompareExchange(&ddraw->device_state, DDRAW_DEVICE_STATE_NOT_RESTORED, DDRAW_DEVICE_STATE_OK);
4771 }
4772
4773 static void CDECL device_parent_activate(struct wined3d_device_parent *device_parent, BOOL activate)
4774 {
4775 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4776
4777 TRACE("device_parent %p, activate %#x.\n", device_parent, activate);
4778
4779 if (!activate)
4780 {
4781 ddraw->device_state = DDRAW_DEVICE_STATE_LOST;
4782 exclusive_window = NULL;
4783 }
4784 else
4785 {
4786 InterlockedCompareExchange(&ddraw->device_state, DDRAW_DEVICE_STATE_NOT_RESTORED, DDRAW_DEVICE_STATE_LOST);
4787 }
4788 }
4789
4790 void ddraw_update_lost_surfaces(struct ddraw *ddraw)
4791 {
4792 struct ddraw_surface *surface;
4793
4794 if (ddraw->device_state != DDRAW_DEVICE_STATE_NOT_RESTORED)
4795 return;
4796
4797 LIST_FOR_EACH_ENTRY(surface, &ddraw->surface_list, struct ddraw_surface, surface_list_entry)
4798 {
4799 surface->is_lost = TRUE;
4800 }
4801 ddraw->device_state = DDRAW_DEVICE_STATE_OK;
4802 }
4803
4804 static HRESULT CDECL device_parent_texture_sub_resource_created(struct wined3d_device_parent *device_parent,
4805 enum wined3d_resource_type type, struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx,
4806 void **parent, const struct wined3d_parent_ops **parent_ops)
4807 {
4808 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4809 struct ddraw_surface *ddraw_surface;
4810
4811 TRACE("device_parent %p, type %#x, wined3d_texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n",
4812 device_parent, type, wined3d_texture, sub_resource_idx, parent, parent_ops);
4813
4814 /* We have a swapchain or wined3d internal texture. */
4815 if (type != WINED3D_RTYPE_TEXTURE_2D || !wined3d_texture_get_parent(wined3d_texture)
4816 || wined3d_texture_get_parent(wined3d_texture) == ddraw)
4817 {
4818 *parent = NULL;
4819 *parent_ops = &ddraw_null_wined3d_parent_ops;
4820
4821 return DD_OK;
4822 }
4823
4824 if (!(ddraw_surface = heap_alloc_zero(sizeof(*ddraw_surface))))
4825 {
4826 ERR("Failed to allocate surface memory.\n");
4827 return DDERR_OUTOFVIDEOMEMORY;
4828 }
4829
4830 ddraw_surface_init(ddraw_surface, ddraw, wined3d_texture, sub_resource_idx, parent_ops);
4831 *parent = ddraw_surface;
4832
4833 ddraw_update_lost_surfaces(ddraw);
4834 list_add_head(&ddraw->surface_list, &ddraw_surface->surface_list_entry);
4835
4836 TRACE("Created ddraw surface %p.\n", ddraw_surface);
4837
4838 return DD_OK;
4839 }
4840
4841 static void STDMETHODCALLTYPE ddraw_frontbuffer_destroyed(void *parent)
4842 {
4843 struct ddraw *ddraw = parent;
4844 ddraw->wined3d_frontbuffer = NULL;
4845 }
4846
4847 static const struct wined3d_parent_ops ddraw_frontbuffer_parent_ops =
4848 {
4849 ddraw_frontbuffer_destroyed,
4850 };
4851
4852 static HRESULT CDECL device_parent_create_swapchain_texture(struct wined3d_device_parent *device_parent,
4853 void *container_parent, const struct wined3d_resource_desc *desc, DWORD texture_flags,
4854 struct wined3d_texture **texture)
4855 {
4856 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4857 const struct wined3d_parent_ops *parent_ops;
4858 HRESULT hr;
4859
4860 TRACE("device_parent %p, container_parent %p, desc %p, texture flags %#x, texture %p.\n",
4861 device_parent, container_parent, desc, texture_flags, texture);
4862
4863 if (!ddraw->wined3d_frontbuffer)
4864 parent_ops = &ddraw_frontbuffer_parent_ops;
4865 else
4866 parent_ops = &ddraw_null_wined3d_parent_ops;
4867
4868 if (FAILED(hr = wined3d_texture_create(ddraw->wined3d_device, desc, 1, 1,
4869 texture_flags | WINED3D_TEXTURE_CREATE_MAPPABLE, NULL, ddraw, parent_ops, texture)))
4870 {
4871 WARN("Failed to create texture, hr %#x.\n", hr);
4872 return hr;
4873 }
4874
4875 if (!ddraw->wined3d_frontbuffer)
4876 ddraw->wined3d_frontbuffer = *texture;
4877
4878 return hr;
4879 }
4880
4881 static HRESULT CDECL device_parent_create_swapchain(struct wined3d_device_parent *device_parent,
4882 struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **swapchain)
4883 {
4884 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4885 HRESULT hr;
4886
4887 TRACE("device_parent %p, desc %p, swapchain %p.\n", device_parent, desc, swapchain);
4888
4889 if (ddraw->wined3d_swapchain)
4890 {
4891 ERR("Swapchain already created.\n");
4892 return E_FAIL;
4893 }
4894
4895 if (FAILED(hr = wined3d_swapchain_create(ddraw->wined3d_device, desc, NULL,
4896 &ddraw_null_wined3d_parent_ops, swapchain)))
4897 WARN("Failed to create swapchain, hr %#x.\n", hr);
4898
4899 return hr;
4900 }
4901
4902 static const struct wined3d_device_parent_ops ddraw_wined3d_device_parent_ops =
4903 {
4904 device_parent_wined3d_device_created,
4905 device_parent_mode_changed,
4906 device_parent_activate,
4907 device_parent_texture_sub_resource_created,
4908 device_parent_create_swapchain_texture,
4909 device_parent_create_swapchain,
4910 };
4911
4912 HRESULT ddraw_init(struct ddraw *ddraw, DWORD flags, enum wined3d_device_type device_type)
4913 {
4914 WINED3DCAPS caps;
4915 HRESULT hr;
4916
4917 ddraw->IDirectDraw7_iface.lpVtbl = &ddraw7_vtbl;
4918 ddraw->IDirectDraw_iface.lpVtbl = &ddraw1_vtbl;
4919 ddraw->IDirectDraw2_iface.lpVtbl = &ddraw2_vtbl;
4920 ddraw->IDirectDraw4_iface.lpVtbl = &ddraw4_vtbl;
4921 ddraw->IDirect3D_iface.lpVtbl = &d3d1_vtbl;
4922 ddraw->IDirect3D2_iface.lpVtbl = &d3d2_vtbl;
4923 ddraw->IDirect3D3_iface.lpVtbl = &d3d3_vtbl;
4924 ddraw->IDirect3D7_iface.lpVtbl = &d3d7_vtbl;
4925 ddraw->device_parent.ops = &ddraw_wined3d_device_parent_ops;
4926 ddraw->numIfaces = 1;
4927 ddraw->ref7 = 1;
4928
4929 flags |= DDRAW_WINED3D_FLAGS;
4930 if (!(ddraw->wined3d = wined3d_create(flags)))
4931 {
4932 flags |= WINED3D_NO3D;
4933 if (!(ddraw->wined3d = wined3d_create(flags)))
4934 {
4935 WARN("Failed to create a wined3d object.\n");
4936 return E_FAIL;
4937 }
4938 }
4939
4940 if (FAILED(hr = wined3d_get_device_caps(ddraw->wined3d, WINED3DADAPTER_DEFAULT, device_type, &caps)))
4941 {
4942 ERR("Failed to get device caps, hr %#x.\n", hr);
4943 wined3d_decref(ddraw->wined3d);
4944 return E_FAIL;
4945 }
4946
4947 if (!(caps.ddraw_caps.caps & WINEDDCAPS_3D))
4948 {
4949 WARN("Created a wined3d object without 3D support.\n");
4950 ddraw->flags |= DDRAW_NO3D;
4951 }
4952
4953 if (FAILED(hr = wined3d_device_create(ddraw->wined3d, WINED3DADAPTER_DEFAULT, device_type,
4954 NULL, 0, DDRAW_STRIDE_ALIGNMENT, &ddraw->device_parent, &ddraw->wined3d_device)))
4955 {
4956 WARN("Failed to create a wined3d device, hr %#x.\n", hr);
4957 wined3d_decref(ddraw->wined3d);
4958 return hr;
4959 }
4960
4961 list_init(&ddraw->surface_list);
4962
4963 return DD_OK;
4964 }
Windows API implementation