?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d8/tests: Add test for clip planes limits.
[wine.git] / dlls / ddraw / ddraw.c
blobd3e491c3e8bbc3cc36f7238d3cf090ba34f4e1d7
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 HeapFree(GetProcessHeap(), 0, 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 HeapFree(GetProcessHeap(), 0, 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 ddraw->decls = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw->decls) * ddraw->declArraySize);
604 if (!ddraw->decls)
605 {
606 ERR("Error allocating an array for the converted vertex decls.\n");
607 ddraw->declArraySize = 0;
608 hr = wined3d_device_uninit_3d(ddraw->wined3d_device);
609 return E_OUTOFMEMORY;
610 }
611
612 TRACE("Successfully initialized 3D.\n");
613
614 return DD_OK;
615 }
616
617 static HRESULT ddraw_create_swapchain(struct ddraw *ddraw, HWND window, BOOL windowed)
618 {
619 struct wined3d_swapchain_desc swapchain_desc;
620 struct wined3d_display_mode mode;
621 HRESULT hr = WINED3D_OK;
622
623 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
624 {
625 ERR("Failed to get display mode.\n");
626 return hr;
627 }
628
629 memset(&swapchain_desc, 0, sizeof(swapchain_desc));
630 swapchain_desc.backbuffer_width = mode.width;
631 swapchain_desc.backbuffer_height = mode.height;
632 swapchain_desc.backbuffer_format = mode.format_id;
633 swapchain_desc.swap_effect = WINED3D_SWAP_EFFECT_COPY;
634 swapchain_desc.device_window = window;
635 swapchain_desc.windowed = windowed;
636 swapchain_desc.flags = WINED3D_SWAPCHAIN_ALLOW_MODE_SWITCH;
637
638 if (!(ddraw->flags & DDRAW_NO3D))
639 hr = ddraw_attach_d3d_device(ddraw, &swapchain_desc);
640 else
641 hr = wined3d_device_init_gdi(ddraw->wined3d_device, &swapchain_desc);
642
643 if (FAILED(hr))
644 {
645 ERR("Failed to create swapchain, hr %#x.\n", hr);
646 return hr;
647 }
648
649 if (!(ddraw->wined3d_swapchain = wined3d_device_get_swapchain(ddraw->wined3d_device, 0)))
650 {
651 ERR("Failed to get swapchain.\n");
652 return DDERR_INVALIDPARAMS;
653 }
654
655 wined3d_swapchain_incref(ddraw->wined3d_swapchain);
656 ddraw_set_swapchain_window(ddraw, window);
657
658 if (ddraw->primary && ddraw->primary->palette)
659 wined3d_swapchain_set_palette(ddraw->wined3d_swapchain, ddraw->primary->palette->wined3d_palette);
660
661 return DD_OK;
662 }
663
664 /*****************************************************************************
665 * IDirectDraw7::RestoreDisplayMode
666 *
667 * Restores the display mode to what it was at creation time. Basically.
668 *
669 * Returns
670 * DD_OK on success
671 * DDERR_NOEXCLUSIVE mode if the device isn't in fullscreen mode
672 *
673 *****************************************************************************/
674 static HRESULT WINAPI ddraw7_RestoreDisplayMode(IDirectDraw7 *iface)
675 {
676 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
677 HRESULT hr;
678
679 TRACE("iface %p.\n", iface);
680
681 wined3d_mutex_lock();
682
683 if (!(ddraw->flags & DDRAW_RESTORE_MODE))
684 {
685 wined3d_mutex_unlock();
686 return DD_OK;
687 }
688
689 if (exclusive_ddraw && exclusive_ddraw != ddraw)
690 {
691 wined3d_mutex_unlock();
692 return DDERR_NOEXCLUSIVEMODE;
693 }
694
695 if (SUCCEEDED(hr = wined3d_set_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, NULL)))
696 ddraw->flags &= ~DDRAW_RESTORE_MODE;
697
698 InterlockedCompareExchange(&ddraw->device_state, DDRAW_DEVICE_STATE_NOT_RESTORED, DDRAW_DEVICE_STATE_OK);
699
700 wined3d_mutex_unlock();
701
702 return hr;
703 }
704
705 static HRESULT WINAPI ddraw4_RestoreDisplayMode(IDirectDraw4 *iface)
706 {
707 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
708
709 TRACE("iface %p.\n", iface);
710
711 return ddraw7_RestoreDisplayMode(&ddraw->IDirectDraw7_iface);
712 }
713
714 static HRESULT WINAPI ddraw2_RestoreDisplayMode(IDirectDraw2 *iface)
715 {
716 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
717
718 TRACE("iface %p.\n", iface);
719
720 return ddraw7_RestoreDisplayMode(&ddraw->IDirectDraw7_iface);
721 }
722
723 static HRESULT WINAPI ddraw1_RestoreDisplayMode(IDirectDraw *iface)
724 {
725 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
726
727 TRACE("iface %p.\n", iface);
728
729 return ddraw7_RestoreDisplayMode(&ddraw->IDirectDraw7_iface);
730 }
731
732 /*****************************************************************************
733 * IDirectDraw7::SetCooperativeLevel
734 *
735 * Sets the cooperative level for the DirectDraw object, and the window
736 * assigned to it. The cooperative level determines the general behavior
737 * of the DirectDraw application
738 *
739 * Warning: This is quite tricky, as it's not really documented which
740 * cooperative levels can be combined with each other. If a game fails
741 * after this function, try to check the cooperative levels passed on
742 * Windows, and if it returns something different.
743 *
744 * If you think that this function caused the failure because it writes a
745 * fixme, be sure to run again with a +ddraw trace.
746 *
747 * What is known about cooperative levels (See the ddraw modes test):
748 * DDSCL_EXCLUSIVE requires DDSCL_FULLSCREEN.
749 * DDSCL_NORMAL is not compatible with DDSCL_EXCLUSIVE.
750 * Unlike what msdn claims, DDSCL_NORMAL | DDSCL_FULLSCREEN is allowed.
751 * DDSCL_SETFOCUSWINDOW can be passed only in DDSCL_NORMAL mode, but after that
752 * DDSCL_EXCLUSIVE can be activated.
753 * DDSCL_SETFOCUSWINDOW may only be used with DDSCL_NOWINDOWCHANGES or
754 * DDSCL_CREATEDEVICEWINDOW.
755 *
756 * Handled flags: DDSCL_NORMAL, DDSCL_FULLSCREEN, DDSCL_EXCLUSIVE,
757 * DDSCL_CREATEDEVICEWINDOW, DDSCL_SETDEVICEWINDOW
758 * DDSCL_SETFOCUSWINDOW (partially),
759 * DDSCL_MULTITHREADED (work in progress)
760 * DDSCL_FPUPRESERVE (see device.c)
761 *
762 * Unsure about this: DDSCL_FPUSETUP
763 *
764 * These don't seem very important for wine:
765 * DDSCL_ALLOWREBOOT, DDSCL_NOWINDOWCHANGES, DDSCL_ALLOWMODEX
766 *
767 * Returns:
768 * DD_OK if the cooperative level was set successfully
769 * DDERR_INVALIDPARAMS if the passed cooperative level combination is invalid
770 * DDERR_HWNDALREADYSET if DDSCL_SETFOCUSWINDOW is passed in exclusive mode
771 * (Probably others too, have to investigate)
772 *
773 *****************************************************************************/
774 static HRESULT ddraw_set_cooperative_level(struct ddraw *ddraw, HWND window,
775 DWORD cooplevel, BOOL restore_mode_on_normal)
776 {
777 struct wined3d_rendertarget_view *rtv = NULL, *dsv = NULL;
778 struct wined3d_stateblock *stateblock;
779 BOOL restore_state = FALSE;
780 HRESULT hr;
781
782 TRACE("ddraw %p, window %p, flags %#x, restore_mode_on_normal %x.\n", ddraw, window, cooplevel,
783 restore_mode_on_normal);
784 DDRAW_dump_cooperativelevel(cooplevel);
785
786 wined3d_mutex_lock();
787
788 if (ddraw->flags & DDRAW_SCL_RECURSIVE)
789 {
790 WARN("Recursive call, returning DD_OK.\n");
791 hr = DD_OK;
792 goto done;
793 }
794 ddraw->flags |= DDRAW_SCL_RECURSIVE;
795
796 /* Tests suggest that we need one of them: */
797 if(!(cooplevel & (DDSCL_SETFOCUSWINDOW |
798 DDSCL_NORMAL |
799 DDSCL_EXCLUSIVE )))
800 {
801 TRACE("Incorrect cooplevel flags, returning DDERR_INVALIDPARAMS\n");
802 hr = DDERR_INVALIDPARAMS;
803 goto done;
804 }
805
806 if ((cooplevel & DDSCL_CREATEDEVICEWINDOW) && !(cooplevel & DDSCL_EXCLUSIVE))
807 {
808 WARN("DDSCL_CREATEDEVICEWINDOW requires DDSCL_EXCLUSIVE.\n");
809 hr = DDERR_INVALIDPARAMS;
810 goto done;
811 }
812
813 /* Handle those levels first which set various hwnds */
814 if ((cooplevel & DDSCL_SETFOCUSWINDOW) && !(cooplevel & DDSCL_CREATEDEVICEWINDOW))
815 {
816 /* This isn't compatible with a lot of flags */
817 if (cooplevel & (DDSCL_MULTITHREADED
818 | DDSCL_FPUSETUP
819 | DDSCL_FPUPRESERVE
820 | DDSCL_ALLOWREBOOT
821 | DDSCL_ALLOWMODEX
822 | DDSCL_SETDEVICEWINDOW
823 | DDSCL_NORMAL
824 | DDSCL_EXCLUSIVE
825 | DDSCL_FULLSCREEN))
826 {
827 WARN("Called with incompatible flags, returning DDERR_INVALIDPARAMS.\n");
828 hr = DDERR_INVALIDPARAMS;
829 goto done;
830 }
831
832 hr = ddraw_set_focus_window(ddraw, window);
833 goto done;
834 }
835
836 if (cooplevel & DDSCL_EXCLUSIVE)
837 {
838 if (!(cooplevel & DDSCL_FULLSCREEN) || !(window || (cooplevel & DDSCL_CREATEDEVICEWINDOW)))
839 {
840 WARN("DDSCL_EXCLUSIVE requires DDSCL_FULLSCREEN and a window.\n");
841 hr = DDERR_INVALIDPARAMS;
842 goto done;
843 }
844
845 if (cooplevel & DDSCL_CREATEDEVICEWINDOW)
846 {
847 HWND device_window;
848
849 if (!ddraw->focuswindow && !(cooplevel & DDSCL_SETFOCUSWINDOW))
850 {
851 WARN("No focus window set.\n");
852 hr = DDERR_NOFOCUSWINDOW;
853 goto done;
854 }
855
856 device_window = CreateWindowExA(0, DDRAW_WINDOW_CLASS_NAME, "DirectDrawDeviceWnd",
857 WS_POPUP, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
858 NULL, NULL, NULL, NULL);
859 if (!device_window)
860 {
861 ERR("Failed to create window, last error %#x.\n", GetLastError());
862 hr = E_FAIL;
863 goto done;
864 }
865
866 ShowWindow(device_window, SW_SHOW);
867 TRACE("Created a device window %p.\n", device_window);
868
869 /* Native apparently leaks the created device window if setting the
870 * focus window below fails. */
871 ddraw->cooperative_level |= DDSCL_CREATEDEVICEWINDOW;
872 ddraw->devicewindow = device_window;
873
874 if (cooplevel & DDSCL_SETFOCUSWINDOW)
875 {
876 if (!window)
877 {
878 hr = DDERR_NOHWND;
879 goto done;
880 }
881
882 if (FAILED(hr = ddraw_set_focus_window(ddraw, window)))
883 goto done;
884 }
885
886 window = device_window;
887 }
888 }
889 else
890 {
891 if (ddraw->cooperative_level & DDSCL_CREATEDEVICEWINDOW)
892 DestroyWindow(ddraw->devicewindow);
893 ddraw->devicewindow = NULL;
894 ddraw->focuswindow = NULL;
895 }
896
897 if ((cooplevel & DDSCL_FULLSCREEN) != (ddraw->cooperative_level & DDSCL_FULLSCREEN) || window != ddraw->dest_window)
898 {
899 if (ddraw->cooperative_level & DDSCL_FULLSCREEN)
900 wined3d_device_restore_fullscreen_window(ddraw->wined3d_device, ddraw->dest_window, NULL);
901
902 if (cooplevel & DDSCL_FULLSCREEN)
903 {
904 struct wined3d_display_mode display_mode;
905
906 wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &display_mode, NULL);
907 wined3d_device_setup_fullscreen_window(ddraw->wined3d_device, window,
908 display_mode.width, display_mode.height);
909 }
910 }
911
912 if ((cooplevel & DDSCL_EXCLUSIVE) && exclusive_window != window)
913 {
914 ddraw->device_state = DDRAW_DEVICE_STATE_NOT_RESTORED;
915 exclusive_window = window;
916 }
917
918 if (cooplevel & DDSCL_MULTITHREADED && !(ddraw->cooperative_level & DDSCL_MULTITHREADED))
919 wined3d_device_set_multithreaded(ddraw->wined3d_device);
920
921 if (ddraw->wined3d_swapchain)
922 {
923 if (!(ddraw->flags & DDRAW_NO3D))
924 {
925 restore_state = TRUE;
926
927 if (FAILED(hr = wined3d_stateblock_create(ddraw->wined3d_device, WINED3D_SBT_ALL, &stateblock)))
928 {
929 ERR("Failed to create stateblock, hr %#x.\n", hr);
930 goto done;
931 }
932
933 wined3d_stateblock_capture(stateblock);
934 rtv = wined3d_device_get_rendertarget_view(ddraw->wined3d_device, 0);
935 /* Rendering to ddraw->wined3d_frontbuffer. */
936 if (rtv && !wined3d_rendertarget_view_get_sub_resource_parent(rtv))
937 rtv = NULL;
938 else if (rtv)
939 wined3d_rendertarget_view_incref(rtv);
940
941 if ((dsv = wined3d_device_get_depth_stencil_view(ddraw->wined3d_device)))
942 wined3d_rendertarget_view_incref(dsv);
943 }
944
945 ddraw_destroy_swapchain(ddraw);
946 }
947
948 if (FAILED(hr = ddraw_create_swapchain(ddraw, window, !(cooplevel & DDSCL_FULLSCREEN))))
949 ERR("Failed to create swapchain, hr %#x.\n", hr);
950
951 if (restore_state)
952 {
953 if (dsv)
954 {
955 wined3d_device_set_depth_stencil_view(ddraw->wined3d_device, dsv);
956 wined3d_rendertarget_view_decref(dsv);
957 }
958
959 if (rtv)
960 {
961 wined3d_device_set_rendertarget_view(ddraw->wined3d_device, 0, rtv, FALSE);
962 wined3d_rendertarget_view_decref(rtv);
963 }
964
965 wined3d_stateblock_apply(stateblock);
966 wined3d_stateblock_decref(stateblock);
967 }
968
969 if (!(cooplevel & DDSCL_EXCLUSIVE) && (ddraw->cooperative_level & DDSCL_EXCLUSIVE)
970 && restore_mode_on_normal)
971 {
972 hr = ddraw7_RestoreDisplayMode(&ddraw->IDirectDraw7_iface);
973 if (FAILED(hr))
974 ERR("RestoreDisplayMode failed\n");
975 }
976
977 if ((ddraw->cooperative_level & DDSCL_EXCLUSIVE)
978 && (window != ddraw->dest_window || !(cooplevel & DDSCL_EXCLUSIVE)))
979 wined3d_device_release_focus_window(ddraw->wined3d_device);
980
981 if ((cooplevel & DDSCL_EXCLUSIVE)
982 && (window != ddraw->dest_window || !(ddraw->cooperative_level & DDSCL_EXCLUSIVE)))
983 {
984 hr = wined3d_device_acquire_focus_window(ddraw->wined3d_device, window);
985 if (FAILED(hr))
986 {
987 ERR("Failed to acquire focus window, hr %#x.\n", hr);
988 goto done;
989 }
990 }
991
992 /* Unhandled flags */
993 if (cooplevel & DDSCL_ALLOWREBOOT)
994 WARN("Unhandled flag DDSCL_ALLOWREBOOT, harmless\n");
995 if (cooplevel & DDSCL_ALLOWMODEX)
996 WARN("Unhandled flag DDSCL_ALLOWMODEX, harmless\n");
997 if (cooplevel & DDSCL_FPUSETUP)
998 WARN("Unhandled flag DDSCL_FPUSETUP, harmless\n");
999
1000 if (cooplevel & DDSCL_EXCLUSIVE)
1001 exclusive_ddraw = ddraw;
1002 else if (exclusive_ddraw == ddraw)
1003 exclusive_ddraw = NULL;
1004
1005 /* Store the cooperative_level */
1006 ddraw->cooperative_level = cooplevel;
1007 ddraw->dest_window = window;
1008
1009 TRACE("SetCooperativeLevel returning DD_OK\n");
1010 hr = DD_OK;
1011 done:
1012 ddraw->flags &= ~DDRAW_SCL_RECURSIVE;
1013 wined3d_mutex_unlock();
1014
1015 return hr;
1016 }
1017
1018 static HRESULT WINAPI ddraw7_SetCooperativeLevel(IDirectDraw7 *iface, HWND window, DWORD flags)
1019 {
1020 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1021
1022 TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1023
1024 return ddraw_set_cooperative_level(ddraw, window, flags, !(ddraw->flags & DDRAW_SCL_DDRAW1));
1025 }
1026
1027 static HRESULT WINAPI ddraw4_SetCooperativeLevel(IDirectDraw4 *iface, HWND window, DWORD flags)
1028 {
1029 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1030
1031 TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1032
1033 return ddraw_set_cooperative_level(ddraw, window, flags, !(ddraw->flags & DDRAW_SCL_DDRAW1));
1034 }
1035
1036 static HRESULT WINAPI ddraw2_SetCooperativeLevel(IDirectDraw2 *iface, HWND window, DWORD flags)
1037 {
1038 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1039
1040 TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1041
1042 return ddraw_set_cooperative_level(ddraw, window, flags, !(ddraw->flags & DDRAW_SCL_DDRAW1));
1043 }
1044
1045 static HRESULT WINAPI ddraw1_SetCooperativeLevel(IDirectDraw *iface, HWND window, DWORD flags)
1046 {
1047 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1048 HRESULT hr;
1049
1050 TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1051
1052 hr = ddraw_set_cooperative_level(ddraw, window, flags, FALSE);
1053 if (SUCCEEDED(hr))
1054 ddraw->flags |= DDRAW_SCL_DDRAW1;
1055 return hr;
1056 }
1057
1058 /*****************************************************************************
1059 * IDirectDraw7::SetDisplayMode
1060 *
1061 * Sets the display screen resolution, color depth and refresh frequency
1062 * when in fullscreen mode (in theory).
1063 * Possible return values listed in the SDK suggest that this method fails
1064 * when not in fullscreen mode, but this is wrong. Windows 2000 happily sets
1065 * the display mode in DDSCL_NORMAL mode without an hwnd specified.
1066 * It seems to be valid to pass 0 for With and Height, this has to be tested
1067 * It could mean that the current video mode should be left as-is. (But why
1068 * call it then?)
1069 *
1070 * Params:
1071 * Height, Width: Screen dimension
1072 * BPP: Color depth in Bits per pixel
1073 * Refreshrate: Screen refresh rate
1074 * Flags: Other stuff
1075 *
1076 * Returns
1077 * DD_OK on success
1078 *
1079 *****************************************************************************/
1080 static HRESULT WINAPI ddraw7_SetDisplayMode(IDirectDraw7 *iface, DWORD width, DWORD height,
1081 DWORD bpp, DWORD refresh_rate, DWORD flags)
1082 {
1083 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1084 struct wined3d_display_mode mode;
1085 enum wined3d_format_id format;
1086 HRESULT hr;
1087
1088 TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
1089 iface, width, height, bpp, refresh_rate, flags);
1090
1091 if (force_refresh_rate != 0)
1092 {
1093 TRACE("ForceRefreshRate overriding passed-in refresh rate (%u Hz) to %u Hz\n",
1094 refresh_rate, force_refresh_rate);
1095 refresh_rate = force_refresh_rate;
1096 }
1097
1098 wined3d_mutex_lock();
1099
1100 if (exclusive_ddraw && exclusive_ddraw != ddraw)
1101 {
1102 wined3d_mutex_unlock();
1103 return DDERR_NOEXCLUSIVEMODE;
1104 }
1105
1106 if (!width || !height)
1107 {
1108 /* It looks like Need for Speed Porsche Unleashed expects DD_OK here. */
1109 wined3d_mutex_unlock();
1110 return DD_OK;
1111 }
1112
1113 switch (bpp)
1114 {
1115 case 8: format = WINED3DFMT_P8_UINT; break;
1116 case 15: format = WINED3DFMT_B5G5R5X1_UNORM; break;
1117 case 16: format = WINED3DFMT_B5G6R5_UNORM; break;
1118 case 24: format = WINED3DFMT_B8G8R8_UNORM; break;
1119 case 32: format = WINED3DFMT_B8G8R8X8_UNORM; break;
1120 default: format = WINED3DFMT_UNKNOWN; break;
1121 }
1122
1123 mode.width = width;
1124 mode.height = height;
1125 mode.refresh_rate = refresh_rate;
1126 mode.format_id = format;
1127 mode.scanline_ordering = WINED3D_SCANLINE_ORDERING_UNKNOWN;
1128
1129 /* TODO: The possible return values from msdn suggest that the screen mode
1130 * can't be changed if a surface is locked or some drawing is in progress. */
1131 if (SUCCEEDED(hr = wined3d_set_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode)))
1132 {
1133 if (ddraw->primary)
1134 {
1135 DDSURFACEDESC2 *surface_desc = &ddraw->primary->surface_desc;
1136
1137 if (FAILED(hr = wined3d_swapchain_resize_buffers(ddraw->wined3d_swapchain, 0,
1138 surface_desc->dwWidth, surface_desc->dwHeight, mode.format_id, WINED3D_MULTISAMPLE_NONE, 0)))
1139 ERR("Failed to resize buffers, hr %#x.\n", hr);
1140 else
1141 ddrawformat_from_wined3dformat(&ddraw->primary->surface_desc.u4.ddpfPixelFormat, mode.format_id);
1142 }
1143 ddraw->flags |= DDRAW_RESTORE_MODE;
1144 }
1145
1146 InterlockedCompareExchange(&ddraw->device_state, DDRAW_DEVICE_STATE_NOT_RESTORED, DDRAW_DEVICE_STATE_OK);
1147
1148 wined3d_mutex_unlock();
1149
1150 switch (hr)
1151 {
1152 case WINED3DERR_NOTAVAILABLE: return DDERR_UNSUPPORTED;
1153 default: return hr;
1154 }
1155 }
1156
1157 static HRESULT WINAPI ddraw4_SetDisplayMode(IDirectDraw4 *iface, DWORD width, DWORD height,
1158 DWORD bpp, DWORD refresh_rate, DWORD flags)
1159 {
1160 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1161
1162 TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
1163 iface, width, height, bpp, refresh_rate, flags);
1164
1165 return ddraw7_SetDisplayMode(&ddraw->IDirectDraw7_iface, width, height, bpp, refresh_rate, flags);
1166 }
1167
1168 static HRESULT WINAPI ddraw2_SetDisplayMode(IDirectDraw2 *iface,
1169 DWORD width, DWORD height, DWORD bpp, DWORD refresh_rate, DWORD flags)
1170 {
1171 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1172
1173 TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
1174 iface, width, height, bpp, refresh_rate, flags);
1175
1176 return ddraw7_SetDisplayMode(&ddraw->IDirectDraw7_iface, width, height, bpp, refresh_rate, flags);
1177 }
1178
1179 static HRESULT WINAPI ddraw1_SetDisplayMode(IDirectDraw *iface, DWORD width, DWORD height, DWORD bpp)
1180 {
1181 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1182
1183 TRACE("iface %p, width %u, height %u, bpp %u.\n", iface, width, height, bpp);
1184
1185 return ddraw7_SetDisplayMode(&ddraw->IDirectDraw7_iface, width, height, bpp, 0, 0);
1186 }
1187
1188 void ddraw_d3dcaps1_from_7(D3DDEVICEDESC *caps1, D3DDEVICEDESC7 *caps7)
1189 {
1190 memset(caps1, 0, sizeof(*caps1));
1191 caps1->dwSize = sizeof(*caps1);
1192 caps1->dwFlags = D3DDD_COLORMODEL
1193 | D3DDD_DEVCAPS
1194 | D3DDD_TRANSFORMCAPS
1195 | D3DDD_BCLIPPING
1196 | D3DDD_LIGHTINGCAPS
1197 | D3DDD_LINECAPS
1198 | D3DDD_TRICAPS
1199 | D3DDD_DEVICERENDERBITDEPTH
1200 | D3DDD_DEVICEZBUFFERBITDEPTH
1201 | D3DDD_MAXBUFFERSIZE
1202 | D3DDD_MAXVERTEXCOUNT;
1203 caps1->dcmColorModel = D3DCOLOR_RGB;
1204 caps1->dwDevCaps = caps7->dwDevCaps;
1205 caps1->dtcTransformCaps.dwSize = sizeof(caps1->dtcTransformCaps);
1206 caps1->dtcTransformCaps.dwCaps = D3DTRANSFORMCAPS_CLIP;
1207 caps1->bClipping = TRUE;
1208 caps1->dlcLightingCaps.dwSize = sizeof(caps1->dlcLightingCaps);
1209 caps1->dlcLightingCaps.dwCaps = D3DLIGHTCAPS_DIRECTIONAL
1210 | D3DLIGHTCAPS_PARALLELPOINT
1211 | D3DLIGHTCAPS_POINT
1212 | D3DLIGHTCAPS_SPOT;
1213 caps1->dlcLightingCaps.dwLightingModel = D3DLIGHTINGMODEL_RGB;
1214 caps1->dlcLightingCaps.dwNumLights = caps7->dwMaxActiveLights;
1215 caps1->dpcLineCaps = caps7->dpcLineCaps;
1216 caps1->dpcTriCaps = caps7->dpcTriCaps;
1217 caps1->dwDeviceRenderBitDepth = caps7->dwDeviceRenderBitDepth;
1218 caps1->dwDeviceZBufferBitDepth = caps7->dwDeviceZBufferBitDepth;
1219 caps1->dwMaxBufferSize = 0;
1220 caps1->dwMaxVertexCount = 65536;
1221 caps1->dwMinTextureWidth = caps7->dwMinTextureWidth;
1222 caps1->dwMinTextureHeight = caps7->dwMinTextureHeight;
1223 caps1->dwMaxTextureWidth = caps7->dwMaxTextureWidth;
1224 caps1->dwMaxTextureHeight = caps7->dwMaxTextureHeight;
1225 caps1->dwMinStippleWidth = 1;
1226 caps1->dwMinStippleHeight = 1;
1227 caps1->dwMaxStippleWidth = 32;
1228 caps1->dwMaxStippleHeight = 32;
1229 caps1->dwMaxTextureRepeat = caps7->dwMaxTextureRepeat;
1230 caps1->dwMaxTextureAspectRatio = caps7->dwMaxTextureAspectRatio;
1231 caps1->dwMaxAnisotropy = caps7->dwMaxAnisotropy;
1232 caps1->dvGuardBandLeft = caps7->dvGuardBandLeft;
1233 caps1->dvGuardBandTop = caps7->dvGuardBandTop;
1234 caps1->dvGuardBandRight = caps7->dvGuardBandRight;
1235 caps1->dvGuardBandBottom = caps7->dvGuardBandBottom;
1236 caps1->dvExtentsAdjust = caps7->dvExtentsAdjust;
1237 caps1->dwStencilCaps = caps7->dwStencilCaps;
1238 caps1->dwFVFCaps = caps7->dwFVFCaps;
1239 caps1->dwTextureOpCaps = caps7->dwTextureOpCaps;
1240 caps1->wMaxTextureBlendStages = caps7->wMaxTextureBlendStages;
1241 caps1->wMaxSimultaneousTextures = caps7->wMaxSimultaneousTextures;
1242 }
1243
1244 HRESULT ddraw_get_d3dcaps(const struct ddraw *ddraw, D3DDEVICEDESC7 *caps)
1245 {
1246 WINED3DCAPS wined3d_caps;
1247 HRESULT hr;
1248
1249 TRACE("ddraw %p, caps %p.\n", ddraw, caps);
1250
1251 memset(&wined3d_caps, 0, sizeof(wined3d_caps));
1252
1253 wined3d_mutex_lock();
1254 hr = wined3d_get_device_caps(ddraw->wined3d, 0, WINED3D_DEVICE_TYPE_HAL, &wined3d_caps);
1255 wined3d_mutex_unlock();
1256 if (FAILED(hr))
1257 {
1258 WARN("Failed to get device caps, hr %#x.\n", hr);
1259 return hr;
1260 }
1261
1262 caps->dwDevCaps = wined3d_caps.DevCaps;
1263 caps->dpcLineCaps.dwMiscCaps = wined3d_caps.PrimitiveMiscCaps;
1264 caps->dpcLineCaps.dwRasterCaps = wined3d_caps.RasterCaps;
1265 caps->dpcLineCaps.dwZCmpCaps = wined3d_caps.ZCmpCaps;
1266 caps->dpcLineCaps.dwSrcBlendCaps = wined3d_caps.SrcBlendCaps;
1267 caps->dpcLineCaps.dwDestBlendCaps = wined3d_caps.DestBlendCaps;
1268 caps->dpcLineCaps.dwAlphaCmpCaps = wined3d_caps.AlphaCmpCaps;
1269 caps->dpcLineCaps.dwShadeCaps = wined3d_caps.ShadeCaps;
1270 caps->dpcLineCaps.dwTextureCaps = wined3d_caps.TextureCaps;
1271 caps->dpcLineCaps.dwTextureFilterCaps = wined3d_caps.TextureFilterCaps;
1272 caps->dpcLineCaps.dwTextureAddressCaps = wined3d_caps.TextureAddressCaps;
1273
1274 caps->dwMaxTextureWidth = wined3d_caps.MaxTextureWidth;
1275 caps->dwMaxTextureHeight = wined3d_caps.MaxTextureHeight;
1276
1277 caps->dwMaxTextureRepeat = wined3d_caps.MaxTextureRepeat;
1278 caps->dwMaxTextureAspectRatio = wined3d_caps.MaxTextureAspectRatio;
1279 caps->dwMaxAnisotropy = wined3d_caps.MaxAnisotropy;
1280 caps->dvMaxVertexW = wined3d_caps.MaxVertexW;
1281
1282 caps->dvGuardBandLeft = wined3d_caps.GuardBandLeft;
1283 caps->dvGuardBandTop = wined3d_caps.GuardBandTop;
1284 caps->dvGuardBandRight = wined3d_caps.GuardBandRight;
1285 caps->dvGuardBandBottom = wined3d_caps.GuardBandBottom;
1286
1287 caps->dvExtentsAdjust = wined3d_caps.ExtentsAdjust;
1288 caps->dwStencilCaps = wined3d_caps.StencilCaps;
1289
1290 caps->dwFVFCaps = wined3d_caps.FVFCaps;
1291 caps->dwTextureOpCaps = wined3d_caps.TextureOpCaps;
1292
1293 caps->dwVertexProcessingCaps = wined3d_caps.VertexProcessingCaps;
1294 caps->dwMaxActiveLights = wined3d_caps.MaxActiveLights;
1295
1296 /* Remove all non-d3d7 caps */
1297 caps->dwDevCaps &= (
1298 D3DDEVCAPS_FLOATTLVERTEX | D3DDEVCAPS_SORTINCREASINGZ | D3DDEVCAPS_SORTDECREASINGZ |
1299 D3DDEVCAPS_SORTEXACT | D3DDEVCAPS_EXECUTESYSTEMMEMORY | D3DDEVCAPS_EXECUTEVIDEOMEMORY |
1300 D3DDEVCAPS_TLVERTEXSYSTEMMEMORY | D3DDEVCAPS_TLVERTEXVIDEOMEMORY | D3DDEVCAPS_TEXTURESYSTEMMEMORY |
1301 D3DDEVCAPS_TEXTUREVIDEOMEMORY | D3DDEVCAPS_DRAWPRIMTLVERTEX | D3DDEVCAPS_CANRENDERAFTERFLIP |
1302 D3DDEVCAPS_TEXTURENONLOCALVIDMEM | D3DDEVCAPS_DRAWPRIMITIVES2 | D3DDEVCAPS_SEPARATETEXTUREMEMORIES |
1303 D3DDEVCAPS_DRAWPRIMITIVES2EX | D3DDEVCAPS_HWTRANSFORMANDLIGHT | D3DDEVCAPS_CANBLTSYSTONONLOCAL |
1304 D3DDEVCAPS_HWRASTERIZATION);
1305
1306 caps->dwStencilCaps &= (
1307 D3DSTENCILCAPS_KEEP | D3DSTENCILCAPS_ZERO | D3DSTENCILCAPS_REPLACE |
1308 D3DSTENCILCAPS_INCRSAT | D3DSTENCILCAPS_DECRSAT | D3DSTENCILCAPS_INVERT |
1309 D3DSTENCILCAPS_INCR | D3DSTENCILCAPS_DECR);
1310
1311 /* FVF caps ?*/
1312
1313 caps->dwTextureOpCaps &= (
1314 D3DTEXOPCAPS_DISABLE | D3DTEXOPCAPS_SELECTARG1 | D3DTEXOPCAPS_SELECTARG2 |
1315 D3DTEXOPCAPS_MODULATE | D3DTEXOPCAPS_MODULATE2X | D3DTEXOPCAPS_MODULATE4X |
1316 D3DTEXOPCAPS_ADD | D3DTEXOPCAPS_ADDSIGNED | D3DTEXOPCAPS_ADDSIGNED2X |
1317 D3DTEXOPCAPS_SUBTRACT | D3DTEXOPCAPS_ADDSMOOTH | D3DTEXOPCAPS_BLENDTEXTUREALPHA |
1318 D3DTEXOPCAPS_BLENDFACTORALPHA | D3DTEXOPCAPS_BLENDTEXTUREALPHAPM | D3DTEXOPCAPS_BLENDCURRENTALPHA |
1319 D3DTEXOPCAPS_PREMODULATE | D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
1320 D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA | D3DTEXOPCAPS_BUMPENVMAP |
1321 D3DTEXOPCAPS_BUMPENVMAPLUMINANCE | D3DTEXOPCAPS_DOTPRODUCT3);
1322
1323 caps->dwVertexProcessingCaps &= (
1324 D3DVTXPCAPS_TEXGEN | D3DVTXPCAPS_MATERIALSOURCE7 | D3DVTXPCAPS_VERTEXFOG |
1325 D3DVTXPCAPS_DIRECTIONALLIGHTS | D3DVTXPCAPS_POSITIONALLIGHTS | D3DVTXPCAPS_LOCALVIEWER);
1326
1327 caps->dpcLineCaps.dwMiscCaps &= (
1328 D3DPMISCCAPS_MASKPLANES | D3DPMISCCAPS_MASKZ | D3DPMISCCAPS_LINEPATTERNREP |
1329 D3DPMISCCAPS_CONFORMANT | D3DPMISCCAPS_CULLNONE | D3DPMISCCAPS_CULLCW |
1330 D3DPMISCCAPS_CULLCCW);
1331
1332 caps->dpcLineCaps.dwRasterCaps &= (
1333 D3DPRASTERCAPS_DITHER | D3DPRASTERCAPS_ROP2 | D3DPRASTERCAPS_XOR |
1334 D3DPRASTERCAPS_PAT | D3DPRASTERCAPS_ZTEST | D3DPRASTERCAPS_SUBPIXEL |
1335 D3DPRASTERCAPS_SUBPIXELX | D3DPRASTERCAPS_FOGVERTEX | D3DPRASTERCAPS_FOGTABLE |
1336 D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT | D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT |
1337 D3DPRASTERCAPS_ANTIALIASEDGES | D3DPRASTERCAPS_MIPMAPLODBIAS | D3DPRASTERCAPS_ZBIAS |
1338 D3DPRASTERCAPS_ZBUFFERLESSHSR | D3DPRASTERCAPS_FOGRANGE | D3DPRASTERCAPS_ANISOTROPY |
1339 D3DPRASTERCAPS_WBUFFER | D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT | D3DPRASTERCAPS_WFOG |
1340 D3DPRASTERCAPS_ZFOG);
1341
1342 caps->dpcLineCaps.dwZCmpCaps &= (
1343 D3DPCMPCAPS_NEVER | D3DPCMPCAPS_LESS | D3DPCMPCAPS_EQUAL |
1344 D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_NOTEQUAL |
1345 D3DPCMPCAPS_GREATEREQUAL | D3DPCMPCAPS_ALWAYS);
1346
1347 caps->dpcLineCaps.dwSrcBlendCaps &= (
1348 D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR |
1349 D3DPBLENDCAPS_INVSRCCOLOR | D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA |
1350 D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_DESTCOLOR |
1351 D3DPBLENDCAPS_INVDESTCOLOR | D3DPBLENDCAPS_SRCALPHASAT | D3DPBLENDCAPS_BOTHSRCALPHA |
1352 D3DPBLENDCAPS_BOTHINVSRCALPHA);
1353
1354 caps->dpcLineCaps.dwDestBlendCaps &= (
1355 D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR |
1356 D3DPBLENDCAPS_INVSRCCOLOR | D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA |
1357 D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_DESTCOLOR |
1358 D3DPBLENDCAPS_INVDESTCOLOR | D3DPBLENDCAPS_SRCALPHASAT | D3DPBLENDCAPS_BOTHSRCALPHA |
1359 D3DPBLENDCAPS_BOTHINVSRCALPHA);
1360
1361 caps->dpcLineCaps.dwAlphaCmpCaps &= (
1362 D3DPCMPCAPS_NEVER | D3DPCMPCAPS_LESS | D3DPCMPCAPS_EQUAL |
1363 D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_NOTEQUAL |
1364 D3DPCMPCAPS_GREATEREQUAL | D3DPCMPCAPS_ALWAYS);
1365
1366 caps->dpcLineCaps.dwShadeCaps &= (
1367 D3DPSHADECAPS_COLORFLATMONO | D3DPSHADECAPS_COLORFLATRGB | D3DPSHADECAPS_COLORGOURAUDMONO |
1368 D3DPSHADECAPS_COLORGOURAUDRGB | D3DPSHADECAPS_COLORPHONGMONO | D3DPSHADECAPS_COLORPHONGRGB |
1369 D3DPSHADECAPS_SPECULARFLATMONO | D3DPSHADECAPS_SPECULARFLATRGB | D3DPSHADECAPS_SPECULARGOURAUDMONO |
1370 D3DPSHADECAPS_SPECULARGOURAUDRGB | D3DPSHADECAPS_SPECULARPHONGMONO | D3DPSHADECAPS_SPECULARPHONGRGB |
1371 D3DPSHADECAPS_ALPHAFLATBLEND | D3DPSHADECAPS_ALPHAFLATSTIPPLED | D3DPSHADECAPS_ALPHAGOURAUDBLEND |
1372 D3DPSHADECAPS_ALPHAGOURAUDSTIPPLED | D3DPSHADECAPS_ALPHAPHONGBLEND | D3DPSHADECAPS_ALPHAPHONGSTIPPLED |
1373 D3DPSHADECAPS_FOGFLAT | D3DPSHADECAPS_FOGGOURAUD | D3DPSHADECAPS_FOGPHONG);
1374
1375 caps->dpcLineCaps.dwTextureCaps &= (
1376 D3DPTEXTURECAPS_PERSPECTIVE | D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_ALPHA |
1377 D3DPTEXTURECAPS_TRANSPARENCY | D3DPTEXTURECAPS_BORDER | D3DPTEXTURECAPS_SQUAREONLY |
1378 D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE | D3DPTEXTURECAPS_ALPHAPALETTE| D3DPTEXTURECAPS_NONPOW2CONDITIONAL |
1379 D3DPTEXTURECAPS_PROJECTED | D3DPTEXTURECAPS_CUBEMAP | D3DPTEXTURECAPS_COLORKEYBLEND);
1380
1381 caps->dpcLineCaps.dwTextureFilterCaps &= (
1382 D3DPTFILTERCAPS_NEAREST | D3DPTFILTERCAPS_LINEAR | D3DPTFILTERCAPS_MIPNEAREST |
1383 D3DPTFILTERCAPS_MIPLINEAR | D3DPTFILTERCAPS_LINEARMIPNEAREST | D3DPTFILTERCAPS_LINEARMIPLINEAR |
1384 D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MINFLINEAR | D3DPTFILTERCAPS_MINFANISOTROPIC |
1385 D3DPTFILTERCAPS_MIPFPOINT | D3DPTFILTERCAPS_MIPFLINEAR | D3DPTFILTERCAPS_MAGFPOINT |
1386 D3DPTFILTERCAPS_MAGFLINEAR | D3DPTFILTERCAPS_MAGFANISOTROPIC | D3DPTFILTERCAPS_MAGFAFLATCUBIC |
1387 D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC);
1388
1389 caps->dpcLineCaps.dwTextureAddressCaps &= (
1390 D3DPTADDRESSCAPS_WRAP | D3DPTADDRESSCAPS_MIRROR | D3DPTADDRESSCAPS_CLAMP |
1391 D3DPTADDRESSCAPS_BORDER | D3DPTADDRESSCAPS_INDEPENDENTUV);
1392
1393 if (!(caps->dpcLineCaps.dwTextureCaps & D3DPTEXTURECAPS_POW2))
1394 {
1395 /* DirectX7 always has the np2 flag set, no matter what the card
1396 * supports. Some old games (Rollcage) check the caps incorrectly.
1397 * If wined3d supports nonpow2 textures it also has np2 conditional
1398 * support. */
1399 caps->dpcLineCaps.dwTextureCaps |= D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL;
1400 }
1401
1402 /* Fill the missing members, and do some fixup */
1403 caps->dpcLineCaps.dwSize = sizeof(caps->dpcLineCaps);
1404 caps->dpcLineCaps.dwTextureBlendCaps = D3DPTBLENDCAPS_ADD
1405 | D3DPTBLENDCAPS_MODULATEMASK
1406 | D3DPTBLENDCAPS_COPY
1407 | D3DPTBLENDCAPS_DECAL
1408 | D3DPTBLENDCAPS_DECALALPHA
1409 | D3DPTBLENDCAPS_DECALMASK
1410 | D3DPTBLENDCAPS_MODULATE
1411 | D3DPTBLENDCAPS_MODULATEALPHA;
1412 caps->dpcLineCaps.dwStippleWidth = 32;
1413 caps->dpcLineCaps.dwStippleHeight = 32;
1414 /* Use the same for the TriCaps */
1415 caps->dpcTriCaps = caps->dpcLineCaps;
1416
1417 caps->dwDeviceRenderBitDepth = DDBD_16 | DDBD_24 | DDBD_32;
1418 caps->dwDeviceZBufferBitDepth = DDBD_16 | DDBD_24;
1419 caps->dwMinTextureWidth = 1;
1420 caps->dwMinTextureHeight = 1;
1421
1422 /* Convert DWORDs safely to WORDs */
1423 caps->wMaxTextureBlendStages = min(wined3d_caps.MaxTextureBlendStages, 0xffff);
1424 caps->wMaxSimultaneousTextures = min(wined3d_caps.MaxSimultaneousTextures, 0xffff);
1425 caps->wMaxUserClipPlanes = min(wined3d_caps.MaxUserClipPlanes, D3DMAXUSERCLIPPLANES);
1426 caps->wMaxVertexBlendMatrices = min(wined3d_caps.MaxVertexBlendMatrices, 0xffff);
1427
1428 caps->deviceGUID = IID_IDirect3DTnLHalDevice;
1429
1430 caps->dwReserved1 = 0;
1431 caps->dwReserved2 = 0;
1432 caps->dwReserved3 = 0;
1433 caps->dwReserved4 = 0;
1434
1435 return DD_OK;
1436 }
1437
1438 /*****************************************************************************
1439 * IDirectDraw7::GetCaps
1440 *
1441 * Returns the drives capabilities
1442 *
1443 * Used for version 1, 2, 4 and 7
1444 *
1445 * Params:
1446 * DriverCaps: Structure to write the Hardware accelerated caps to
1447 * HelCaps: Structure to write the emulation caps to
1448 *
1449 * Returns
1450 * This implementation returns DD_OK only
1451 *
1452 *****************************************************************************/
1453 static HRESULT WINAPI ddraw7_GetCaps(IDirectDraw7 *iface, DDCAPS *DriverCaps, DDCAPS *HELCaps)
1454 {
1455 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1456 DDCAPS caps;
1457 WINED3DCAPS winecaps;
1458 HRESULT hr;
1459 DDSCAPS2 ddscaps = {0, 0, 0, {0}};
1460
1461 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, DriverCaps, HELCaps);
1462
1463 /* One structure must be != NULL */
1464 if (!DriverCaps && !HELCaps)
1465 {
1466 WARN("Invalid parameters.\n");
1467 return DDERR_INVALIDPARAMS;
1468 }
1469
1470 memset(&caps, 0, sizeof(caps));
1471 memset(&winecaps, 0, sizeof(winecaps));
1472 caps.dwSize = sizeof(caps);
1473
1474 wined3d_mutex_lock();
1475 hr = wined3d_device_get_device_caps(ddraw->wined3d_device, &winecaps);
1476 if (FAILED(hr))
1477 {
1478 WARN("Failed to get device caps, %#x.\n", hr);
1479 wined3d_mutex_unlock();
1480 return hr;
1481 }
1482
1483 hr = IDirectDraw7_GetAvailableVidMem(iface, &ddscaps, &caps.dwVidMemTotal, &caps.dwVidMemFree);
1484 if (FAILED(hr))
1485 {
1486 WARN("IDirectDraw7::GetAvailableVidMem failed\n");
1487 wined3d_mutex_unlock();
1488 return hr;
1489 }
1490
1491 hr = IDirectDraw7_GetFourCCCodes(iface, &caps.dwNumFourCCCodes, NULL);
1492 wined3d_mutex_unlock();
1493 if (FAILED(hr))
1494 {
1495 WARN("IDirectDraw7::GetFourCCCodes failed\n");
1496 return hr;
1497 }
1498
1499 caps.dwCaps = winecaps.ddraw_caps.caps;
1500 caps.dwCaps2 = winecaps.ddraw_caps.caps2;
1501 caps.dwCKeyCaps = winecaps.ddraw_caps.color_key_caps;
1502 caps.dwFXCaps = winecaps.ddraw_caps.fx_caps;
1503 caps.dwPalCaps = DDPCAPS_8BIT | DDPCAPS_PRIMARYSURFACE;
1504 caps.ddsCaps.dwCaps = winecaps.ddraw_caps.dds_caps;
1505 caps.dwSVBCaps = winecaps.ddraw_caps.svb_caps;
1506 caps.dwSVBCKeyCaps = winecaps.ddraw_caps.svb_color_key_caps;
1507 caps.dwSVBFXCaps = winecaps.ddraw_caps.svb_fx_caps;
1508 caps.dwVSBCaps = winecaps.ddraw_caps.vsb_caps;
1509 caps.dwVSBCKeyCaps = winecaps.ddraw_caps.vsb_color_key_caps;
1510 caps.dwVSBFXCaps = winecaps.ddraw_caps.vsb_fx_caps;
1511 caps.dwSSBCaps = winecaps.ddraw_caps.ssb_caps;
1512 caps.dwSSBCKeyCaps = winecaps.ddraw_caps.ssb_color_key_caps;
1513 caps.dwSSBFXCaps = winecaps.ddraw_caps.ssb_fx_caps;
1514
1515 caps.dwCaps |= DDCAPS_ALIGNSTRIDE;
1516 caps.dwAlignStrideAlign = DDRAW_STRIDE_ALIGNMENT;
1517
1518 if(DriverCaps)
1519 {
1520 DD_STRUCT_COPY_BYSIZE(DriverCaps, &caps);
1521 if (TRACE_ON(ddraw))
1522 {
1523 TRACE("Driver Caps :\n");
1524 DDRAW_dump_DDCAPS(DriverCaps);
1525 }
1526
1527 }
1528 if(HELCaps)
1529 {
1530 DD_STRUCT_COPY_BYSIZE(HELCaps, &caps);
1531 if (TRACE_ON(ddraw))
1532 {
1533 TRACE("HEL Caps :\n");
1534 DDRAW_dump_DDCAPS(HELCaps);
1535 }
1536 }
1537
1538 return DD_OK;
1539 }
1540
1541 static HRESULT WINAPI ddraw4_GetCaps(IDirectDraw4 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1542 {
1543 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1544
1545 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1546
1547 return ddraw7_GetCaps(&ddraw->IDirectDraw7_iface, driver_caps, hel_caps);
1548 }
1549
1550 static HRESULT WINAPI ddraw2_GetCaps(IDirectDraw2 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1551 {
1552 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1553
1554 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1555
1556 return ddraw7_GetCaps(&ddraw->IDirectDraw7_iface, driver_caps, hel_caps);
1557 }
1558
1559 static HRESULT WINAPI ddraw1_GetCaps(IDirectDraw *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1560 {
1561 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1562
1563 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1564
1565 return ddraw7_GetCaps(&ddraw->IDirectDraw7_iface, driver_caps, hel_caps);
1566 }
1567
1568 /*****************************************************************************
1569 * IDirectDraw7::Compact
1570 *
1571 * No idea what it does, MSDN says it's not implemented.
1572 *
1573 * Returns
1574 * DD_OK, but this is unchecked
1575 *
1576 *****************************************************************************/
1577 static HRESULT WINAPI ddraw7_Compact(IDirectDraw7 *iface)
1578 {
1579 TRACE("iface %p.\n", iface);
1580
1581 return DD_OK;
1582 }
1583
1584 static HRESULT WINAPI ddraw4_Compact(IDirectDraw4 *iface)
1585 {
1586 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1587
1588 TRACE("iface %p.\n", iface);
1589
1590 return ddraw7_Compact(&ddraw->IDirectDraw7_iface);
1591 }
1592
1593 static HRESULT WINAPI ddraw2_Compact(IDirectDraw2 *iface)
1594 {
1595 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1596
1597 TRACE("iface %p.\n", iface);
1598
1599 return ddraw7_Compact(&ddraw->IDirectDraw7_iface);
1600 }
1601
1602 static HRESULT WINAPI ddraw1_Compact(IDirectDraw *iface)
1603 {
1604 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1605
1606 TRACE("iface %p.\n", iface);
1607
1608 return ddraw7_Compact(&ddraw->IDirectDraw7_iface);
1609 }
1610
1611 /*****************************************************************************
1612 * IDirectDraw7::GetDisplayMode
1613 *
1614 * Returns information about the current display mode
1615 *
1616 * Exists in versions 1, 2, 4 and 7
1617 *
1618 * Params:
1619 * DDSD: Address of a surface description structure to write the info to
1620 *
1621 * Returns
1622 * DD_OK
1623 *
1624 *****************************************************************************/
1625 static HRESULT WINAPI ddraw7_GetDisplayMode(IDirectDraw7 *iface, DDSURFACEDESC2 *DDSD)
1626 {
1627 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1628 struct wined3d_display_mode mode;
1629 HRESULT hr;
1630 DWORD Size;
1631
1632 TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
1633
1634 wined3d_mutex_lock();
1635 /* This seems sane */
1636 if (!DDSD)
1637 {
1638 wined3d_mutex_unlock();
1639 return DDERR_INVALIDPARAMS;
1640 }
1641
1642 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
1643 {
1644 ERR("Failed to get display mode, hr %#x.\n", hr);
1645 wined3d_mutex_unlock();
1646 return hr;
1647 }
1648
1649 Size = DDSD->dwSize;
1650 memset(DDSD, 0, Size);
1651
1652 DDSD->dwSize = Size;
1653 DDSD->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
1654 DDSD->dwWidth = mode.width;
1655 DDSD->dwHeight = mode.height;
1656 DDSD->u2.dwRefreshRate = 60;
1657 DDSD->ddsCaps.dwCaps = 0;
1658 DDSD->u4.ddpfPixelFormat.dwSize = sizeof(DDSD->u4.ddpfPixelFormat);
1659 ddrawformat_from_wined3dformat(&DDSD->u4.ddpfPixelFormat, mode.format_id);
1660 DDSD->u1.lPitch = mode.width * DDSD->u4.ddpfPixelFormat.u1.dwRGBBitCount / 8;
1661
1662 if(TRACE_ON(ddraw))
1663 {
1664 TRACE("Returning surface desc :\n");
1665 DDRAW_dump_surface_desc(DDSD);
1666 }
1667
1668 wined3d_mutex_unlock();
1669
1670 return DD_OK;
1671 }
1672
1673 static HRESULT WINAPI ddraw4_GetDisplayMode(IDirectDraw4 *iface, DDSURFACEDESC2 *surface_desc)
1674 {
1675 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1676
1677 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1678
1679 return ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, surface_desc);
1680 }
1681
1682 static HRESULT WINAPI ddraw2_GetDisplayMode(IDirectDraw2 *iface, DDSURFACEDESC *surface_desc)
1683 {
1684 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1685
1686 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1687
1688 /* FIXME: Test sizes, properly convert surface_desc */
1689 return ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
1690 }
1691
1692 static HRESULT WINAPI ddraw1_GetDisplayMode(IDirectDraw *iface, DDSURFACEDESC *surface_desc)
1693 {
1694 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1695
1696 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1697
1698 /* FIXME: Test sizes, properly convert surface_desc */
1699 return ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
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 < (sizeof(formats) / sizeof(formats[0])); ++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 enum_modes = HeapAlloc(GetProcessHeap(), 0, sizeof(*enum_modes) * enum_mode_array_size);
2394 if (!enum_modes) return DDERR_OUTOFMEMORY;
2395
2396 wined3d_mutex_lock();
2397
2398 pixelformat.dwSize = sizeof(pixelformat);
2399 for(fmt = 0; fmt < (sizeof(checkFormatList) / sizeof(checkFormatList[0])); 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 HeapFree(GetProcessHeap(), 0, 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 new_enum_modes = HeapReAlloc(GetProcessHeap(), 0, enum_modes,
2469 sizeof(*new_enum_modes) * enum_mode_array_size);
2470 if (!new_enum_modes)
2471 {
2472 HeapFree(GetProcessHeap(), 0, enum_modes);
2473 wined3d_mutex_unlock();
2474 return DDERR_OUTOFMEMORY;
2475 }
2476
2477 enum_modes = new_enum_modes;
2478 }
2479 enum_modes[enum_mode_count++] = mode;
2480 }
2481 }
2482
2483 TRACE("End of enumeration\n");
2484 HeapFree(GetProcessHeap(), 0, enum_modes);
2485 wined3d_mutex_unlock();
2486
2487 return DD_OK;
2488 }
2489
2490 static HRESULT WINAPI ddraw4_EnumDisplayModes(IDirectDraw4 *iface, DWORD flags,
2491 DDSURFACEDESC2 *surface_desc, void *context, LPDDENUMMODESCALLBACK2 callback)
2492 {
2493 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2494
2495 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2496 iface, flags, surface_desc, context, callback);
2497
2498 return ddraw7_EnumDisplayModes(&ddraw->IDirectDraw7_iface, flags, surface_desc, context, callback);
2499 }
2500
2501 static HRESULT WINAPI ddraw2_EnumDisplayModes(IDirectDraw2 *iface, DWORD flags,
2502 DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2503 {
2504 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2505 struct displaymodescallback_context cbcontext;
2506 DDSURFACEDESC2 surface_desc2;
2507
2508 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2509 iface, flags, surface_desc, context, callback);
2510
2511 cbcontext.func = callback;
2512 cbcontext.context = context;
2513
2514 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
2515 return ddraw7_EnumDisplayModes(&ddraw->IDirectDraw7_iface, flags,
2516 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumDisplayModesCallbackThunk);
2517 }
2518
2519 static HRESULT WINAPI ddraw1_EnumDisplayModes(IDirectDraw *iface, DWORD flags,
2520 DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2521 {
2522 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2523 struct displaymodescallback_context cbcontext;
2524 DDSURFACEDESC2 surface_desc2;
2525
2526 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2527 iface, flags, surface_desc, context, callback);
2528
2529 cbcontext.func = callback;
2530 cbcontext.context = context;
2531
2532 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
2533 return ddraw7_EnumDisplayModes(&ddraw->IDirectDraw7_iface, flags,
2534 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumDisplayModesCallbackThunk);
2535 }
2536
2537 /*****************************************************************************
2538 * IDirectDraw7::EvaluateMode
2539 *
2540 * Used with IDirectDraw7::StartModeTest to test video modes.
2541 * EvaluateMode is used to pass or fail a mode, and continue with the next
2542 * mode
2543 *
2544 * Params:
2545 * Flags: DDEM_MODEPASSED or DDEM_MODEFAILED
2546 * Timeout: Returns the amount of seconds left before the mode would have
2547 * been failed automatically
2548 *
2549 * Returns:
2550 * This implementation always DD_OK, because it's a stub
2551 *
2552 *****************************************************************************/
2553 static HRESULT WINAPI ddraw7_EvaluateMode(IDirectDraw7 *iface, DWORD Flags, DWORD *Timeout)
2554 {
2555 FIXME("iface %p, flags %#x, timeout %p stub!\n", iface, Flags, Timeout);
2556
2557 /* When implementing this, implement it in WineD3D */
2558
2559 return DD_OK;
2560 }
2561
2562 /*****************************************************************************
2563 * IDirectDraw7::GetDeviceIdentifier
2564 *
2565 * Returns the device identifier, which gives information about the driver
2566 * Our device identifier is defined at the beginning of this file.
2567 *
2568 * Params:
2569 * DDDI: Address for the returned structure
2570 * Flags: Can be DDGDI_GETHOSTIDENTIFIER
2571 *
2572 * Returns:
2573 * On success it returns DD_OK
2574 * DDERR_INVALIDPARAMS if DDDI is NULL
2575 *
2576 *****************************************************************************/
2577 static HRESULT WINAPI ddraw7_GetDeviceIdentifier(IDirectDraw7 *iface,
2578 DDDEVICEIDENTIFIER2 *DDDI, DWORD Flags)
2579 {
2580 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2581 struct wined3d_adapter_identifier adapter_id;
2582 HRESULT hr = S_OK;
2583
2584 TRACE("iface %p, device_identifier %p, flags %#x.\n", iface, DDDI, Flags);
2585
2586 if (!DDDI)
2587 return DDERR_INVALIDPARAMS;
2588
2589 if (Flags & DDGDI_GETHOSTIDENTIFIER)
2590 {
2591 /* The DDGDI_GETHOSTIDENTIFIER returns the information about the 2D
2592 * host adapter, if there's a secondary 3D adapter. This doesn't apply
2593 * to any modern hardware, nor is it interesting for Wine, so ignore it.
2594 * Size of DDDEVICEIDENTIFIER2 may be aligned to 8 bytes and thus 4
2595 * bytes too long. So only copy the relevant part of the structure
2596 */
2597
2598 memcpy(DDDI, &deviceidentifier, FIELD_OFFSET(DDDEVICEIDENTIFIER2, dwWHQLLevel) + sizeof(DWORD));
2599 return DD_OK;
2600 }
2601
2602 /* Drakan: Order of the Flame expects accurate D3D device information from ddraw */
2603 adapter_id.driver = DDDI->szDriver;
2604 adapter_id.driver_size = sizeof(DDDI->szDriver);
2605 adapter_id.description = DDDI->szDescription;
2606 adapter_id.description_size = sizeof(DDDI->szDescription);
2607 adapter_id.device_name_size = 0;
2608 wined3d_mutex_lock();
2609 hr = wined3d_get_adapter_identifier(ddraw->wined3d, WINED3DADAPTER_DEFAULT, 0x0, &adapter_id);
2610 wined3d_mutex_unlock();
2611 if (FAILED(hr)) return hr;
2612
2613 DDDI->liDriverVersion = adapter_id.driver_version;
2614 DDDI->dwVendorId = adapter_id.vendor_id;
2615 DDDI->dwDeviceId = adapter_id.device_id;
2616 DDDI->dwSubSysId = adapter_id.subsystem_id;
2617 DDDI->dwRevision = adapter_id.revision;
2618 DDDI->guidDeviceIdentifier = adapter_id.device_identifier;
2619 DDDI->dwWHQLLevel = adapter_id.whql_level;
2620 return DD_OK;
2621 }
2622
2623 static HRESULT WINAPI ddraw4_GetDeviceIdentifier(IDirectDraw4 *iface,
2624 DDDEVICEIDENTIFIER *identifier, DWORD flags)
2625 {
2626 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2627 DDDEVICEIDENTIFIER2 identifier2;
2628 HRESULT hr;
2629
2630 TRACE("iface %p, identifier %p, flags %#x.\n", iface, identifier, flags);
2631
2632 hr = ddraw7_GetDeviceIdentifier(&ddraw->IDirectDraw7_iface, &identifier2, flags);
2633 DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1(&identifier2, identifier);
2634
2635 return hr;
2636 }
2637
2638 /*****************************************************************************
2639 * IDirectDraw7::GetSurfaceFromDC
2640 *
2641 * Returns the Surface for a GDI device context handle.
2642 * Is this related to IDirectDrawSurface::GetDC ???
2643 *
2644 * Params:
2645 * hdc: hdc to return the surface for
2646 * Surface: Address to write the surface pointer to
2647 *
2648 * Returns:
2649 * Always returns DD_OK because it's a stub
2650 *
2651 *****************************************************************************/
2652 static HRESULT WINAPI ddraw7_GetSurfaceFromDC(IDirectDraw7 *iface,
2653 HDC dc, IDirectDrawSurface7 **surface)
2654 {
2655 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2656 struct ddraw_surface *surface_impl;
2657
2658 TRACE("iface %p, dc %p, surface %p.\n", iface, dc, surface);
2659
2660 if (!surface)
2661 return E_INVALIDARG;
2662
2663 if (!dc)
2664 goto done;
2665
2666 wined3d_mutex_lock();
2667 LIST_FOR_EACH_ENTRY(surface_impl, &ddraw->surface_list, struct ddraw_surface, surface_list_entry)
2668 {
2669 if (surface_impl->dc != dc)
2670 continue;
2671
2672 TRACE("Found surface %p for dc %p.\n", surface_impl, dc);
2673 *surface = &surface_impl->IDirectDrawSurface7_iface;
2674 IDirectDrawSurface7_AddRef(*surface);
2675 wined3d_mutex_unlock();
2676 return DD_OK;
2677 }
2678 wined3d_mutex_unlock();
2679
2680 done:
2681 TRACE("No surface found for dc %p.\n", dc);
2682 *surface = NULL;
2683 return DDERR_NOTFOUND;
2684 }
2685
2686 static HRESULT WINAPI ddraw4_GetSurfaceFromDC(IDirectDraw4 *iface, HDC dc,
2687 IDirectDrawSurface4 **surface)
2688 {
2689 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2690 struct ddraw_surface *surface_impl;
2691 IDirectDrawSurface7 *surface7;
2692 HRESULT hr;
2693
2694 TRACE("iface %p, dc %p, surface %p.\n", iface, dc, surface);
2695
2696 if (!surface) return E_INVALIDARG;
2697
2698 hr = ddraw7_GetSurfaceFromDC(&ddraw->IDirectDraw7_iface, dc, &surface7);
2699 if (FAILED(hr))
2700 {
2701 *surface = NULL;
2702 return hr;
2703 }
2704 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2705 /* Tests say this is true */
2706 *surface = (IDirectDrawSurface4 *)&surface_impl->IDirectDrawSurface_iface;
2707 IDirectDrawSurface_AddRef(&surface_impl->IDirectDrawSurface_iface);
2708 IDirectDrawSurface7_Release(surface7);
2709
2710 return hr;
2711 }
2712
2713 static HRESULT CALLBACK restore_callback(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *desc, void *context)
2714 {
2715 IDirectDrawSurface_Restore(surface);
2716 IDirectDrawSurface_Release(surface);
2717
2718 return DDENUMRET_OK;
2719 }
2720
2721 static HRESULT WINAPI ddraw7_RestoreAllSurfaces(IDirectDraw7 *iface)
2722 {
2723 TRACE("iface %p.\n", iface);
2724
2725 return IDirectDraw7_EnumSurfaces(iface, DDENUMSURFACES_ALL | DDENUMSURFACES_DOESEXIST,
2726 NULL, NULL, restore_callback);
2727 }
2728
2729 static HRESULT WINAPI ddraw4_RestoreAllSurfaces(IDirectDraw4 *iface)
2730 {
2731 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2732
2733 TRACE("iface %p.\n", iface);
2734
2735 return ddraw7_RestoreAllSurfaces(&ddraw->IDirectDraw7_iface);
2736 }
2737
2738 /*****************************************************************************
2739 * IDirectDraw7::StartModeTest
2740 *
2741 * Tests the specified video modes to update the system registry with
2742 * refresh rate information. StartModeTest starts the mode test,
2743 * EvaluateMode is used to fail or pass a mode. If EvaluateMode
2744 * isn't called within 15 seconds, the mode is failed automatically
2745 *
2746 * As refresh rates are handled by the X server, I don't think this
2747 * Method is important
2748 *
2749 * Params:
2750 * Modes: An array of mode specifications
2751 * NumModes: The number of modes in Modes
2752 * Flags: Some flags...
2753 *
2754 * Returns:
2755 * Returns DDERR_TESTFINISHED if flags contains DDSMT_ISTESTREQUIRED,
2756 * if no modes are passed, DDERR_INVALIDPARAMS is returned,
2757 * otherwise DD_OK
2758 *
2759 *****************************************************************************/
2760 static HRESULT WINAPI ddraw7_StartModeTest(IDirectDraw7 *iface, SIZE *Modes, DWORD NumModes, DWORD Flags)
2761 {
2762 FIXME("iface %p, modes %p, mode_count %u, flags %#x partial stub!\n",
2763 iface, Modes, NumModes, Flags);
2764
2765 /* This looks sane */
2766 if( (!Modes) || (NumModes == 0) ) return DDERR_INVALIDPARAMS;
2767
2768 /* DDSMT_ISTESTREQUIRED asks if a mode test is necessary.
2769 * As it is not, DDERR_TESTFINISHED is returned
2770 * (hopefully that's correct
2771 *
2772 if(Flags & DDSMT_ISTESTREQUIRED) return DDERR_TESTFINISHED;
2773 * well, that value doesn't (yet) exist in the wine headers, so ignore it
2774 */
2775
2776 return DD_OK;
2777 }
2778
2779 static HRESULT WINAPI ddraw7_CreateSurface(IDirectDraw7 *iface, DDSURFACEDESC2 *surface_desc,
2780 IDirectDrawSurface7 **surface, IUnknown *outer_unknown)
2781 {
2782 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2783 struct ddraw_surface *impl;
2784 HRESULT hr;
2785
2786 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2787 iface, surface_desc, surface, outer_unknown);
2788
2789 wined3d_mutex_lock();
2790
2791 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
2792 {
2793 WARN("Cooperative level not set.\n");
2794 wined3d_mutex_unlock();
2795 return DDERR_NOCOOPERATIVELEVELSET;
2796 }
2797
2798 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC2))
2799 {
2800 WARN("Application supplied invalid surface descriptor\n");
2801 wined3d_mutex_unlock();
2802 return DDERR_INVALIDPARAMS;
2803 }
2804
2805 __TRY
2806 {
2807 *surface = NULL;
2808 }
2809 __EXCEPT_PAGE_FAULT
2810 {
2811 WARN("Surface pointer %p is invalid.\n", surface);
2812 wined3d_mutex_unlock();
2813 return DDERR_INVALIDPARAMS;
2814 }
2815 __ENDTRY;
2816
2817 if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
2818 {
2819 if (TRACE_ON(ddraw))
2820 {
2821 TRACE(" (%p) Requesting surface desc :\n", iface);
2822 DDRAW_dump_surface_desc(surface_desc);
2823 }
2824
2825 WARN("Application tried to create an explicit front or back buffer\n");
2826 wined3d_mutex_unlock();
2827 return DDERR_INVALIDCAPS;
2828 }
2829
2830 hr = ddraw_surface_create(ddraw, surface_desc, &impl, outer_unknown, 7);
2831 wined3d_mutex_unlock();
2832 if (FAILED(hr))
2833 return hr;
2834
2835 *surface = &impl->IDirectDrawSurface7_iface;
2836 IDirectDraw7_AddRef(iface);
2837 impl->ifaceToRelease = (IUnknown *)iface;
2838
2839 return hr;
2840 }
2841
2842 static HRESULT WINAPI ddraw4_CreateSurface(IDirectDraw4 *iface,
2843 DDSURFACEDESC2 *surface_desc, IDirectDrawSurface4 **surface, IUnknown *outer_unknown)
2844 {
2845 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2846 struct ddraw_surface *impl;
2847 HRESULT hr;
2848
2849 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2850 iface, surface_desc, surface, outer_unknown);
2851
2852 wined3d_mutex_lock();
2853
2854 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
2855 {
2856 WARN("Cooperative level not set.\n");
2857 wined3d_mutex_unlock();
2858 return DDERR_NOCOOPERATIVELEVELSET;
2859 }
2860
2861 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC2))
2862 {
2863 WARN("Application supplied invalid surface descriptor\n");
2864 wined3d_mutex_unlock();
2865 return DDERR_INVALIDPARAMS;
2866 }
2867
2868 __TRY
2869 {
2870 *surface = NULL;
2871 }
2872 __EXCEPT_PAGE_FAULT
2873 {
2874 WARN("Surface pointer %p is invalid.\n", surface);
2875 wined3d_mutex_unlock();
2876 return DDERR_INVALIDPARAMS;
2877 }
2878 __ENDTRY;
2879
2880 if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
2881 {
2882 if (TRACE_ON(ddraw))
2883 {
2884 TRACE(" (%p) Requesting surface desc :\n", iface);
2885 DDRAW_dump_surface_desc(surface_desc);
2886 }
2887
2888 WARN("Application tried to create an explicit front or back buffer\n");
2889 wined3d_mutex_unlock();
2890 return DDERR_INVALIDCAPS;
2891 }
2892
2893 hr = ddraw_surface_create(ddraw, surface_desc, &impl, outer_unknown, 4);
2894 wined3d_mutex_unlock();
2895 if (FAILED(hr))
2896 return hr;
2897
2898 *surface = &impl->IDirectDrawSurface4_iface;
2899 IDirectDraw4_AddRef(iface);
2900 impl->ifaceToRelease = (IUnknown *)iface;
2901
2902 return hr;
2903 }
2904
2905 static HRESULT WINAPI ddraw2_CreateSurface(IDirectDraw2 *iface,
2906 DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
2907 {
2908 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2909 struct ddraw_surface *impl;
2910 HRESULT hr;
2911 DDSURFACEDESC2 surface_desc2;
2912
2913 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2914 iface, surface_desc, surface, outer_unknown);
2915
2916 wined3d_mutex_lock();
2917
2918 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
2919 {
2920 WARN("Cooperative level not set.\n");
2921 wined3d_mutex_unlock();
2922 return DDERR_NOCOOPERATIVELEVELSET;
2923 }
2924
2925 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
2926 {
2927 WARN("Application supplied invalid surface descriptor\n");
2928 wined3d_mutex_unlock();
2929 return DDERR_INVALIDPARAMS;
2930 }
2931
2932 __TRY
2933 {
2934 *surface = NULL;
2935 }
2936 __EXCEPT_PAGE_FAULT
2937 {
2938 WARN("Surface pointer %p is invalid.\n", surface);
2939 wined3d_mutex_unlock();
2940 return DDERR_INVALIDPARAMS;
2941 }
2942 __ENDTRY;
2943
2944 DDSD_to_DDSD2(surface_desc, &surface_desc2);
2945 if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
2946 {
2947 if (TRACE_ON(ddraw))
2948 {
2949 TRACE(" (%p) Requesting surface desc :\n", iface);
2950 DDRAW_dump_surface_desc((DDSURFACEDESC2 *)surface_desc);
2951 }
2952
2953 WARN("Application tried to create an explicit front or back buffer\n");
2954 wined3d_mutex_unlock();
2955 return DDERR_INVALIDCAPS;
2956 }
2957
2958 hr = ddraw_surface_create(ddraw, &surface_desc2, &impl, outer_unknown, 2);
2959 wined3d_mutex_unlock();
2960 if (FAILED(hr))
2961 return hr;
2962
2963 *surface = &impl->IDirectDrawSurface_iface;
2964 impl->ifaceToRelease = NULL;
2965
2966 return hr;
2967 }
2968
2969 static HRESULT WINAPI ddraw1_CreateSurface(IDirectDraw *iface,
2970 DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
2971 {
2972 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2973 struct ddraw_surface *impl;
2974 HRESULT hr;
2975 DDSURFACEDESC2 surface_desc2;
2976
2977 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2978 iface, surface_desc, surface, outer_unknown);
2979
2980 wined3d_mutex_lock();
2981
2982 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
2983 {
2984 WARN("Cooperative level not set.\n");
2985 wined3d_mutex_unlock();
2986 return DDERR_NOCOOPERATIVELEVELSET;
2987 }
2988
2989 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
2990 {
2991 WARN("Application supplied invalid surface descriptor\n");
2992 wined3d_mutex_unlock();
2993 return DDERR_INVALIDPARAMS;
2994 }
2995
2996 __TRY
2997 {
2998 *surface = NULL;
2999 }
3000 __EXCEPT_PAGE_FAULT
3001 {
3002 WARN("Surface pointer %p is invalid.\n", surface);
3003 wined3d_mutex_unlock();
3004 return DDERR_INVALIDPARAMS;
3005 }
3006 __ENDTRY;
3007
3008 if ((surface_desc->ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_BACKBUFFER))
3009 == (DDSCAPS_PRIMARYSURFACE | DDSCAPS_BACKBUFFER)
3010 || (surface_desc->ddsCaps.dwCaps & (DDSCAPS_FLIP | DDSCAPS_FRONTBUFFER))
3011 == ((DDSCAPS_FLIP | DDSCAPS_FRONTBUFFER)))
3012 {
3013 WARN("Application tried to create an explicit front or back buffer.\n");
3014 wined3d_mutex_unlock();
3015 return DDERR_INVALIDCAPS;
3016 }
3017
3018 DDSD_to_DDSD2(surface_desc, &surface_desc2);
3019 hr = ddraw_surface_create(ddraw, &surface_desc2, &impl, outer_unknown, 1);
3020 wined3d_mutex_unlock();
3021 if (FAILED(hr))
3022 return hr;
3023
3024 *surface = &impl->IDirectDrawSurface_iface;
3025 impl->ifaceToRelease = NULL;
3026
3027 return hr;
3028 }
3029
3030 static BOOL
3031 Main_DirectDraw_DDPIXELFORMAT_Match(const DDPIXELFORMAT *requested,
3032 const DDPIXELFORMAT *provided)
3033 {
3034 /* Some flags must be present in both or neither for a match. */
3035 static const DWORD must_match = DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2
3036 | DDPF_PALETTEINDEXED4 | DDPF_PALETTEINDEXED8 | DDPF_FOURCC
3037 | DDPF_ZBUFFER | DDPF_STENCILBUFFER;
3038
3039 if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
3040 return FALSE;
3041
3042 if ((requested->dwFlags & must_match) != (provided->dwFlags & must_match))
3043 return FALSE;
3044
3045 if (requested->dwFlags & DDPF_FOURCC)
3046 if (requested->dwFourCC != provided->dwFourCC)
3047 return FALSE;
3048
3049 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_ALPHA
3050 |DDPF_LUMINANCE|DDPF_BUMPDUDV))
3051 if (requested->u1.dwRGBBitCount != provided->u1.dwRGBBitCount)
3052 return FALSE;
3053
3054 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
3055 |DDPF_LUMINANCE|DDPF_BUMPDUDV))
3056 if (requested->u2.dwRBitMask != provided->u2.dwRBitMask)
3057 return FALSE;
3058
3059 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_BUMPDUDV))
3060 if (requested->u3.dwGBitMask != provided->u3.dwGBitMask)
3061 return FALSE;
3062
3063 /* I could be wrong about the bumpmapping. MSDN docs are vague. */
3064 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
3065 |DDPF_BUMPDUDV))
3066 if (requested->u4.dwBBitMask != provided->u4.dwBBitMask)
3067 return FALSE;
3068
3069 if (requested->dwFlags & (DDPF_ALPHAPIXELS|DDPF_ZPIXELS))
3070 if (requested->u5.dwRGBAlphaBitMask != provided->u5.dwRGBAlphaBitMask)
3071 return FALSE;
3072
3073 return TRUE;
3074 }
3075
3076 static BOOL ddraw_match_surface_desc(const DDSURFACEDESC2 *requested, const DDSURFACEDESC2 *provided)
3077 {
3078 struct compare_info
3079 {
3080 DWORD flag;
3081 ptrdiff_t offset;
3082 size_t size;
3083 };
3084
3085 #define CMP(FLAG, FIELD) \
3086 { DDSD_##FLAG, offsetof(DDSURFACEDESC2, FIELD), \
3087 sizeof(((DDSURFACEDESC2 *)(NULL))->FIELD) }
3088
3089 static const struct compare_info compare[] =
3090 {
3091 CMP(ALPHABITDEPTH, dwAlphaBitDepth),
3092 CMP(BACKBUFFERCOUNT, u5.dwBackBufferCount),
3093 CMP(CAPS, ddsCaps),
3094 CMP(CKDESTBLT, ddckCKDestBlt),
3095 CMP(CKDESTOVERLAY, u3 /* ddckCKDestOverlay */),
3096 CMP(CKSRCBLT, ddckCKSrcBlt),
3097 CMP(CKSRCOVERLAY, ddckCKSrcOverlay),
3098 CMP(HEIGHT, dwHeight),
3099 CMP(LINEARSIZE, u1 /* dwLinearSize */),
3100 CMP(LPSURFACE, lpSurface),
3101 CMP(MIPMAPCOUNT, u2 /* dwMipMapCount */),
3102 CMP(PITCH, u1 /* lPitch */),
3103 /* PIXELFORMAT: manual */
3104 CMP(REFRESHRATE, u2 /* dwRefreshRate */),
3105 CMP(TEXTURESTAGE, dwTextureStage),
3106 CMP(WIDTH, dwWidth),
3107 /* ZBUFFERBITDEPTH: "obsolete" */
3108 };
3109
3110 #undef CMP
3111
3112 unsigned int i;
3113
3114 if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
3115 return FALSE;
3116
3117 for (i=0; i < sizeof(compare)/sizeof(compare[0]); i++)
3118 {
3119 if (requested->dwFlags & compare[i].flag
3120 && memcmp((const char *)provided + compare[i].offset,
3121 (const char *)requested + compare[i].offset,
3122 compare[i].size) != 0)
3123 return FALSE;
3124 }
3125
3126 if (requested->dwFlags & DDSD_PIXELFORMAT)
3127 {
3128 if (!Main_DirectDraw_DDPIXELFORMAT_Match(&requested->u4.ddpfPixelFormat,
3129 &provided->u4.ddpfPixelFormat))
3130 return FALSE;
3131 }
3132
3133 return TRUE;
3134 }
3135
3136 struct surfacescallback2_context
3137 {
3138 LPDDENUMSURFACESCALLBACK2 func;
3139 void *context;
3140 };
3141
3142 struct surfacescallback_context
3143 {
3144 LPDDENUMSURFACESCALLBACK func;
3145 void *context;
3146 };
3147
3148 static HRESULT CALLBACK EnumSurfacesCallback2Thunk(IDirectDrawSurface7 *surface,
3149 DDSURFACEDESC2 *surface_desc, void *context)
3150 {
3151 struct ddraw_surface *surface_impl = impl_from_IDirectDrawSurface7(surface);
3152 struct surfacescallback2_context *cbcontext = context;
3153
3154 IDirectDrawSurface4_AddRef(&surface_impl->IDirectDrawSurface4_iface);
3155 IDirectDrawSurface7_Release(surface);
3156
3157 return cbcontext->func(&surface_impl->IDirectDrawSurface4_iface,
3158 surface_desc, cbcontext->context);
3159 }
3160
3161 static HRESULT CALLBACK EnumSurfacesCallbackThunk(IDirectDrawSurface7 *surface,
3162 DDSURFACEDESC2 *surface_desc, void *context)
3163 {
3164 struct ddraw_surface *surface_impl = impl_from_IDirectDrawSurface7(surface);
3165 struct surfacescallback_context *cbcontext = context;
3166
3167 IDirectDrawSurface_AddRef(&surface_impl->IDirectDrawSurface_iface);
3168 IDirectDrawSurface7_Release(surface);
3169
3170 return cbcontext->func(&surface_impl->IDirectDrawSurface_iface,
3171 (DDSURFACEDESC *)surface_desc, cbcontext->context);
3172 }
3173
3174 /*****************************************************************************
3175 * IDirectDraw7::EnumSurfaces
3176 *
3177 * Loops through all surfaces attached to this device and calls the
3178 * application callback. This can't be relayed to WineD3DDevice,
3179 * because some WineD3DSurfaces' parents are IParent objects
3180 *
3181 * Params:
3182 * Flags: Some filtering flags. See IDirectDrawImpl_EnumSurfacesCallback
3183 * DDSD: Description to filter for
3184 * Context: Application-provided pointer, it's passed unmodified to the
3185 * Callback function
3186 * Callback: Address to call for each surface
3187 *
3188 * Returns:
3189 * DDERR_INVALIDPARAMS if the callback is NULL
3190 * DD_OK on success
3191 *
3192 *****************************************************************************/
3193 static HRESULT WINAPI ddraw7_EnumSurfaces(IDirectDraw7 *iface, DWORD Flags,
3194 DDSURFACEDESC2 *DDSD, void *Context, LPDDENUMSURFACESCALLBACK7 Callback)
3195 {
3196 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
3197 struct ddraw_surface *surf;
3198 BOOL all, nomatch;
3199 DDSURFACEDESC2 desc;
3200 struct list *entry, *entry2;
3201
3202 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3203 iface, Flags, DDSD, Context, Callback);
3204
3205 all = Flags & DDENUMSURFACES_ALL;
3206 nomatch = Flags & DDENUMSURFACES_NOMATCH;
3207
3208 if (!Callback)
3209 return DDERR_INVALIDPARAMS;
3210
3211 wined3d_mutex_lock();
3212
3213 /* Use the _SAFE enumeration, the app may destroy enumerated surfaces */
3214 LIST_FOR_EACH_SAFE(entry, entry2, &ddraw->surface_list)
3215 {
3216 surf = LIST_ENTRY(entry, struct ddraw_surface, surface_list_entry);
3217
3218 if (!surf->iface_count)
3219 {
3220 WARN("Not enumerating surface %p because it doesn't have any references.\n", surf);
3221 continue;
3222 }
3223
3224 if (all || (nomatch != ddraw_match_surface_desc(DDSD, &surf->surface_desc)))
3225 {
3226 TRACE("Enumerating surface %p.\n", surf);
3227 desc = surf->surface_desc;
3228 IDirectDrawSurface7_AddRef(&surf->IDirectDrawSurface7_iface);
3229 if (Callback(&surf->IDirectDrawSurface7_iface, &desc, Context) != DDENUMRET_OK)
3230 {
3231 wined3d_mutex_unlock();
3232 return DD_OK;
3233 }
3234 }
3235 }
3236
3237 wined3d_mutex_unlock();
3238
3239 return DD_OK;
3240 }
3241
3242 static HRESULT WINAPI ddraw4_EnumSurfaces(IDirectDraw4 *iface, DWORD flags,
3243 DDSURFACEDESC2 *surface_desc, void *context, LPDDENUMSURFACESCALLBACK2 callback)
3244 {
3245 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3246 struct surfacescallback2_context cbcontext;
3247
3248 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3249 iface, flags, surface_desc, context, callback);
3250
3251 cbcontext.func = callback;
3252 cbcontext.context = context;
3253
3254 return ddraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, flags, surface_desc,
3255 &cbcontext, EnumSurfacesCallback2Thunk);
3256 }
3257
3258 static HRESULT WINAPI ddraw2_EnumSurfaces(IDirectDraw2 *iface, DWORD flags,
3259 DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3260 {
3261 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3262 struct surfacescallback_context cbcontext;
3263 DDSURFACEDESC2 surface_desc2;
3264
3265 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3266 iface, flags, surface_desc, context, callback);
3267
3268 cbcontext.func = callback;
3269 cbcontext.context = context;
3270
3271 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3272 return ddraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, flags,
3273 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumSurfacesCallbackThunk);
3274 }
3275
3276 static HRESULT WINAPI ddraw1_EnumSurfaces(IDirectDraw *iface, DWORD flags,
3277 DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3278 {
3279 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3280 struct surfacescallback_context cbcontext;
3281 DDSURFACEDESC2 surface_desc2;
3282
3283 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3284 iface, flags, surface_desc, context, callback);
3285
3286 cbcontext.func = callback;
3287 cbcontext.context = context;
3288
3289 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3290 return ddraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, flags,
3291 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumSurfacesCallbackThunk);
3292 }
3293
3294 /*****************************************************************************
3295 * DirectDrawCreateClipper (DDRAW.@)
3296 *
3297 * Creates a new IDirectDrawClipper object.
3298 *
3299 * Params:
3300 * Clipper: Address to write the interface pointer to
3301 * UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3302 * NULL
3303 *
3304 * Returns:
3305 * CLASS_E_NOAGGREGATION if UnkOuter != NULL
3306 * E_OUTOFMEMORY if allocating the object failed
3307 *
3308 *****************************************************************************/
3309 HRESULT WINAPI DirectDrawCreateClipper(DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3310 {
3311 struct ddraw_clipper *object;
3312 HRESULT hr;
3313
3314 TRACE("flags %#x, clipper %p, outer_unknown %p.\n",
3315 flags, clipper, outer_unknown);
3316
3317 if (outer_unknown)
3318 return CLASS_E_NOAGGREGATION;
3319
3320 wined3d_mutex_lock();
3321
3322 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3323 if (!object)
3324 {
3325 wined3d_mutex_unlock();
3326 return E_OUTOFMEMORY;
3327 }
3328
3329 hr = ddraw_clipper_init(object);
3330 if (FAILED(hr))
3331 {
3332 WARN("Failed to initialize clipper, hr %#x.\n", hr);
3333 HeapFree(GetProcessHeap(), 0, object);
3334 wined3d_mutex_unlock();
3335 return hr;
3336 }
3337
3338 TRACE("Created clipper %p.\n", object);
3339 *clipper = &object->IDirectDrawClipper_iface;
3340 wined3d_mutex_unlock();
3341
3342 return DD_OK;
3343 }
3344
3345 /*****************************************************************************
3346 * IDirectDraw7::CreateClipper
3347 *
3348 * Creates a DDraw clipper. See DirectDrawCreateClipper for details
3349 *
3350 *****************************************************************************/
3351 static HRESULT WINAPI ddraw7_CreateClipper(IDirectDraw7 *iface, DWORD Flags,
3352 IDirectDrawClipper **Clipper, IUnknown *UnkOuter)
3353 {
3354 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3355 iface, Flags, Clipper, UnkOuter);
3356
3357 return DirectDrawCreateClipper(Flags, Clipper, UnkOuter);
3358 }
3359
3360 static HRESULT WINAPI ddraw4_CreateClipper(IDirectDraw4 *iface, DWORD flags,
3361 IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3362 {
3363 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3364
3365 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3366 iface, flags, clipper, outer_unknown);
3367
3368 return ddraw7_CreateClipper(&ddraw->IDirectDraw7_iface, flags, clipper, outer_unknown);
3369 }
3370
3371 static HRESULT WINAPI ddraw2_CreateClipper(IDirectDraw2 *iface,
3372 DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3373 {
3374 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3375
3376 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3377 iface, flags, clipper, outer_unknown);
3378
3379 return ddraw7_CreateClipper(&ddraw->IDirectDraw7_iface, flags, clipper, outer_unknown);
3380 }
3381
3382 static HRESULT WINAPI ddraw1_CreateClipper(IDirectDraw *iface,
3383 DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3384 {
3385 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3386
3387 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3388 iface, flags, clipper, outer_unknown);
3389
3390 return ddraw7_CreateClipper(&ddraw->IDirectDraw7_iface, flags, clipper, outer_unknown);
3391 }
3392
3393 /*****************************************************************************
3394 * IDirectDraw7::CreatePalette
3395 *
3396 * Creates a new IDirectDrawPalette object
3397 *
3398 * Params:
3399 * Flags: The flags for the new clipper
3400 * ColorTable: Color table to assign to the new clipper
3401 * Palette: Address to write the interface pointer to
3402 * UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3403 * NULL
3404 *
3405 * Returns:
3406 * CLASS_E_NOAGGREGATION if UnkOuter != NULL
3407 * E_OUTOFMEMORY if allocating the object failed
3408 *
3409 *****************************************************************************/
3410 static HRESULT WINAPI ddraw7_CreatePalette(IDirectDraw7 *iface, DWORD Flags,
3411 PALETTEENTRY *ColorTable, IDirectDrawPalette **Palette, IUnknown *pUnkOuter)
3412 {
3413 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
3414 struct ddraw_palette *object;
3415 HRESULT hr;
3416
3417 TRACE("iface %p, flags %#x, color_table %p, palette %p, outer_unknown %p.\n",
3418 iface, Flags, ColorTable, Palette, pUnkOuter);
3419
3420 if (pUnkOuter)
3421 return CLASS_E_NOAGGREGATION;
3422
3423 wined3d_mutex_lock();
3424
3425 /* The refcount test shows that a cooplevel is required for this */
3426 if (!ddraw->cooperative_level)
3427 {
3428 WARN("No cooperative level set, returning DDERR_NOCOOPERATIVELEVELSET\n");
3429 wined3d_mutex_unlock();
3430 return DDERR_NOCOOPERATIVELEVELSET;
3431 }
3432
3433 object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object));
3434 if (!object)
3435 {
3436 ERR("Out of memory when allocating memory for a palette implementation\n");
3437 wined3d_mutex_unlock();
3438 return E_OUTOFMEMORY;
3439 }
3440
3441 hr = ddraw_palette_init(object, ddraw, Flags, ColorTable);
3442 if (FAILED(hr))
3443 {
3444 WARN("Failed to initialize palette, hr %#x.\n", hr);
3445 HeapFree(GetProcessHeap(), 0, object);
3446 wined3d_mutex_unlock();
3447 return hr;
3448 }
3449
3450 TRACE("Created palette %p.\n", object);
3451 *Palette = &object->IDirectDrawPalette_iface;
3452 wined3d_mutex_unlock();
3453
3454 return DD_OK;
3455 }
3456
3457 static HRESULT WINAPI ddraw4_CreatePalette(IDirectDraw4 *iface, DWORD flags, PALETTEENTRY *entries,
3458 IDirectDrawPalette **palette, IUnknown *outer_unknown)
3459 {
3460 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3461 HRESULT hr;
3462
3463 TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3464 iface, flags, entries, palette, outer_unknown);
3465
3466 hr = ddraw7_CreatePalette(&ddraw->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3467 if (SUCCEEDED(hr) && *palette)
3468 {
3469 struct ddraw_palette *impl = impl_from_IDirectDrawPalette(*palette);
3470 IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
3471 IDirectDraw4_AddRef(iface);
3472 impl->ifaceToRelease = (IUnknown *)iface;
3473 }
3474 return hr;
3475 }
3476
3477 static HRESULT WINAPI ddraw2_CreatePalette(IDirectDraw2 *iface, DWORD flags,
3478 PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3479 {
3480 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3481 HRESULT hr;
3482
3483 TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3484 iface, flags, entries, palette, outer_unknown);
3485
3486 hr = ddraw7_CreatePalette(&ddraw->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3487 if (SUCCEEDED(hr) && *palette)
3488 {
3489 struct ddraw_palette *impl = impl_from_IDirectDrawPalette(*palette);
3490 IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
3491 impl->ifaceToRelease = NULL;
3492 }
3493
3494 return hr;
3495 }
3496
3497 static HRESULT WINAPI ddraw1_CreatePalette(IDirectDraw *iface, DWORD flags,
3498 PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3499 {
3500 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3501 HRESULT hr;
3502
3503 TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3504 iface, flags, entries, palette, outer_unknown);
3505
3506 hr = ddraw7_CreatePalette(&ddraw->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3507 if (SUCCEEDED(hr) && *palette)
3508 {
3509 struct ddraw_palette *impl = impl_from_IDirectDrawPalette(*palette);
3510 IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
3511 impl->ifaceToRelease = NULL;
3512 }
3513
3514 return hr;
3515 }
3516
3517 /*****************************************************************************
3518 * IDirectDraw7::DuplicateSurface
3519 *
3520 * Duplicates a surface. The surface memory points to the same memory as
3521 * the original surface, and it's released when the last surface referencing
3522 * it is released. I guess that's beyond Wine's surface management right now
3523 * (Idea: create a new DDraw surface with the same WineD3DSurface. I need a
3524 * test application to implement this)
3525 *
3526 * Params:
3527 * Src: Address of the source surface
3528 * Dest: Address to write the new surface pointer to
3529 *
3530 * Returns:
3531 * See IDirectDraw7::CreateSurface
3532 *
3533 *****************************************************************************/
3534 static HRESULT WINAPI ddraw7_DuplicateSurface(IDirectDraw7 *iface,
3535 IDirectDrawSurface7 *Src, IDirectDrawSurface7 **Dest)
3536 {
3537 struct ddraw_surface *src_surface = unsafe_impl_from_IDirectDrawSurface7(Src);
3538
3539 FIXME("iface %p, src %p, dst %p partial stub!\n", iface, Src, Dest);
3540
3541 /* For now, simply create a new, independent surface */
3542 return IDirectDraw7_CreateSurface(iface, &src_surface->surface_desc, Dest, NULL);
3543 }
3544
3545 static HRESULT WINAPI ddraw4_DuplicateSurface(IDirectDraw4 *iface, IDirectDrawSurface4 *src,
3546 IDirectDrawSurface4 **dst)
3547 {
3548 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface4(src);
3549 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3550 struct ddraw_surface *dst_impl;
3551 IDirectDrawSurface7 *dst7;
3552 HRESULT hr;
3553
3554 TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3555
3556 hr = ddraw7_DuplicateSurface(&ddraw->IDirectDraw7_iface,
3557 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3558 if (FAILED(hr))
3559 {
3560 *dst = NULL;
3561 return hr;
3562 }
3563 dst_impl = impl_from_IDirectDrawSurface7(dst7);
3564 *dst = &dst_impl->IDirectDrawSurface4_iface;
3565 IDirectDrawSurface4_AddRef(*dst);
3566 IDirectDrawSurface7_Release(dst7);
3567
3568 return hr;
3569 }
3570
3571 static HRESULT WINAPI ddraw2_DuplicateSurface(IDirectDraw2 *iface,
3572 IDirectDrawSurface *src, IDirectDrawSurface **dst)
3573 {
3574 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface(src);
3575 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3576 struct ddraw_surface *dst_impl;
3577 IDirectDrawSurface7 *dst7;
3578 HRESULT hr;
3579
3580 TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3581
3582 hr = ddraw7_DuplicateSurface(&ddraw->IDirectDraw7_iface,
3583 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3584 if (FAILED(hr))
3585 return hr;
3586 dst_impl = impl_from_IDirectDrawSurface7(dst7);
3587 *dst = &dst_impl->IDirectDrawSurface_iface;
3588 IDirectDrawSurface_AddRef(*dst);
3589 IDirectDrawSurface7_Release(dst7);
3590
3591 return hr;
3592 }
3593
3594 static HRESULT WINAPI ddraw1_DuplicateSurface(IDirectDraw *iface, IDirectDrawSurface *src,
3595 IDirectDrawSurface **dst)
3596 {
3597 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface(src);
3598 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3599 struct ddraw_surface *dst_impl;
3600 IDirectDrawSurface7 *dst7;
3601 HRESULT hr;
3602
3603 TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3604
3605 hr = ddraw7_DuplicateSurface(&ddraw->IDirectDraw7_iface,
3606 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3607 if (FAILED(hr))
3608 return hr;
3609 dst_impl = impl_from_IDirectDrawSurface7(dst7);
3610 *dst = &dst_impl->IDirectDrawSurface_iface;
3611 IDirectDrawSurface_AddRef(*dst);
3612 IDirectDrawSurface7_Release(dst7);
3613
3614 return hr;
3615 }
3616
3617 /*****************************************************************************
3618 * IDirect3D7::EnumDevices
3619 *
3620 * The EnumDevices method for IDirect3D7. It enumerates all supported
3621 * D3D7 devices. Currently the T&L, HAL and RGB devices are enumerated.
3622 *
3623 * Params:
3624 * callback: Function to call for each enumerated device
3625 * context: Pointer to pass back to the app
3626 *
3627 * Returns:
3628 * D3D_OK, or the return value of the GetCaps call
3629 *
3630 *****************************************************************************/
3631 static HRESULT WINAPI d3d7_EnumDevices(IDirect3D7 *iface, LPD3DENUMDEVICESCALLBACK7 callback, void *context)
3632 {
3633 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
3634 D3DDEVICEDESC7 device_desc7;
3635 HRESULT hr;
3636 size_t i;
3637
3638 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3639
3640 if (!callback)
3641 return DDERR_INVALIDPARAMS;
3642
3643 wined3d_mutex_lock();
3644
3645 if (FAILED(hr = ddraw_get_d3dcaps(ddraw, &device_desc7)))
3646 {
3647 wined3d_mutex_unlock();
3648 return hr;
3649 }
3650
3651 for (i = 0; i < sizeof(device_list7)/sizeof(device_list7[0]); i++)
3652 {
3653 HRESULT ret;
3654
3655 device_desc7.deviceGUID = *device_list7[i].device_guid;
3656 ret = callback(device_list7[i].interface_name, device_list7[i].device_name, &device_desc7, context);
3657 if (ret != DDENUMRET_OK)
3658 {
3659 TRACE("Application cancelled the enumeration.\n");
3660 wined3d_mutex_unlock();
3661 return D3D_OK;
3662 }
3663 }
3664
3665 TRACE("End of enumeration.\n");
3666
3667 wined3d_mutex_unlock();
3668
3669 return D3D_OK;
3670 }
3671
3672 /*****************************************************************************
3673 * IDirect3D3::EnumDevices
3674 *
3675 * Enumerates all supported Direct3DDevice interfaces. This is the
3676 * implementation for Direct3D 1 to Direc3D 3, Version 7 has its own.
3677 *
3678 * Versions 1, 2 and 3
3679 *
3680 * Params:
3681 * callback: Application-provided routine to call for each enumerated device
3682 * Context: Pointer to pass to the callback
3683 *
3684 * Returns:
3685 * D3D_OK on success,
3686 * The result of IDirect3DImpl_GetCaps if it failed
3687 *
3688 *****************************************************************************/
3689 static HRESULT WINAPI d3d3_EnumDevices(IDirect3D3 *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
3690 {
3691 static CHAR wined3d_description[] = "Wine D3DDevice using WineD3D and OpenGL";
3692
3693 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3694 D3DDEVICEDESC device_desc1, hal_desc, hel_desc;
3695 D3DDEVICEDESC7 device_desc7;
3696 HRESULT hr;
3697
3698 /* Some games (Motoracer 2 demo) have the bad idea to modify the device
3699 * name string. Let's put the string in a sufficiently sized array in
3700 * writable memory. */
3701 char device_name[50];
3702 strcpy(device_name,"Direct3D HEL");
3703
3704 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3705
3706 if (!callback)
3707 return DDERR_INVALIDPARAMS;
3708
3709 wined3d_mutex_lock();
3710
3711 if (FAILED(hr = ddraw_get_d3dcaps(ddraw, &device_desc7)))
3712 {
3713 wined3d_mutex_unlock();
3714 return hr;
3715 }
3716 ddraw_d3dcaps1_from_7(&device_desc1, &device_desc7);
3717
3718 /* Do I have to enumerate the reference id? Note from old d3d7:
3719 * "It seems that enumerating the reference IID on Direct3D 1 games
3720 * (AvP / Motoracer2) breaks them". So do not enumerate this iid in V1
3721 *
3722 * There's a registry key HKLM\Software\Microsoft\Direct3D\Drivers,
3723 * EnumReference which enables / disables enumerating the reference
3724 * rasterizer. It's a DWORD, 0 means disabled, 2 means enabled. The
3725 * enablerefrast.reg and disablerefrast.reg files in the DirectX 7.0 sdk
3726 * demo directory suggest this.
3727 *
3728 * Some games(GTA 2) seem to use the second enumerated device, so I have
3729 * to enumerate at least 2 devices. So enumerate the reference device to
3730 * have 2 devices.
3731 *
3732 * Other games (Rollcage) tell emulation and hal device apart by certain
3733 * flags. Rollcage expects D3DPTEXTURECAPS_POW2 to be set (yeah, it is a
3734 * limitation flag), and it refuses all devices that have the perspective
3735 * flag set. This way it refuses the emulation device, and HAL devices
3736 * never have POW2 unset in d3d7 on windows. */
3737 if (ddraw->d3dversion != 1)
3738 {
3739 static CHAR reference_description[] = "RGB Direct3D emulation";
3740
3741 TRACE("Enumerating WineD3D D3DDevice interface.\n");
3742 hal_desc = device_desc1;
3743 hel_desc = device_desc1;
3744 /* The rgb device has the pow2 flag set in the hel caps, but not in the hal caps. */
3745 hal_desc.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
3746 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
3747 hal_desc.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
3748 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
3749 /* RGB, RAMP and MMX devices have a HAL dcmColorModel of 0 */
3750 hal_desc.dcmColorModel = 0;
3751 /* RGB, RAMP and MMX devices cannot report HAL hardware flags */
3752 hal_desc.dwFlags = 0;
3753
3754 hr = callback((GUID *)&IID_IDirect3DRGBDevice, reference_description,
3755 device_name, &hal_desc, &hel_desc, context);
3756 if (hr != D3DENUMRET_OK)
3757 {
3758 TRACE("Application cancelled the enumeration.\n");
3759 wined3d_mutex_unlock();
3760 return D3D_OK;
3761 }
3762 }
3763
3764 strcpy(device_name,"Direct3D HAL");
3765
3766 TRACE("Enumerating HAL Direct3D device.\n");
3767 hal_desc = device_desc1;
3768 hel_desc = device_desc1;
3769
3770 /* The hal device does not have the pow2 flag set in hel, but in hal. */
3771 hel_desc.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
3772 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
3773 hel_desc.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
3774 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
3775 /* HAL devices have a HEL dcmColorModel of 0 */
3776 hel_desc.dcmColorModel = 0;
3777
3778 hr = callback((GUID *)&IID_IDirect3DHALDevice, wined3d_description,
3779 device_name, &hal_desc, &hel_desc, context);
3780 if (hr != D3DENUMRET_OK)
3781 {
3782 TRACE("Application cancelled the enumeration.\n");
3783 wined3d_mutex_unlock();
3784 return D3D_OK;
3785 }
3786
3787 TRACE("End of enumeration.\n");
3788
3789 wined3d_mutex_unlock();
3790
3791 return D3D_OK;
3792 }
3793
3794 static HRESULT WINAPI d3d2_EnumDevices(IDirect3D2 *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
3795 {
3796 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
3797
3798 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3799
3800 return d3d3_EnumDevices(&ddraw->IDirect3D3_iface, callback, context);
3801 }
3802
3803 static HRESULT WINAPI d3d1_EnumDevices(IDirect3D *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
3804 {
3805 struct ddraw *ddraw = impl_from_IDirect3D(iface);
3806
3807 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3808
3809 return d3d3_EnumDevices(&ddraw->IDirect3D3_iface, callback, context);
3810 }
3811
3812 /*****************************************************************************
3813 * IDirect3D3::CreateLight
3814 *
3815 * Creates an IDirect3DLight interface. This interface is used in
3816 * Direct3D3 or earlier for lighting. In Direct3D7 it has been replaced
3817 * by the DIRECT3DLIGHT7 structure. Wine's Direct3DLight implementation
3818 * uses the IDirect3DDevice7 interface with D3D7 lights.
3819 *
3820 * Versions 1, 2 and 3
3821 *
3822 * Params:
3823 * light: Address to store the new interface pointer
3824 * outer_unknown: Basically for aggregation, but ddraw doesn't support it.
3825 * Must be NULL
3826 *
3827 * Returns:
3828 * D3D_OK on success
3829 * DDERR_OUTOFMEMORY if memory allocation failed
3830 * CLASS_E_NOAGGREGATION if outer_unknown != NULL
3831 *
3832 *****************************************************************************/
3833 static HRESULT WINAPI d3d3_CreateLight(IDirect3D3 *iface, IDirect3DLight **light,
3834 IUnknown *outer_unknown)
3835 {
3836 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3837 struct d3d_light *object;
3838
3839 TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
3840
3841 if (outer_unknown) return CLASS_E_NOAGGREGATION;
3842
3843 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3844 if (!object)
3845 {
3846 ERR("Failed to allocate light memory.\n");
3847 return DDERR_OUTOFMEMORY;
3848 }
3849
3850 d3d_light_init(object, ddraw);
3851
3852 TRACE("Created light %p.\n", object);
3853 *light = &object->IDirect3DLight_iface;
3854
3855 return D3D_OK;
3856 }
3857
3858 static HRESULT WINAPI d3d2_CreateLight(IDirect3D2 *iface, IDirect3DLight **light, IUnknown *outer_unknown)
3859 {
3860 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
3861
3862 TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
3863
3864 return d3d3_CreateLight(&ddraw->IDirect3D3_iface, light, outer_unknown);
3865 }
3866
3867 static HRESULT WINAPI d3d1_CreateLight(IDirect3D *iface, IDirect3DLight **light, IUnknown *outer_unknown)
3868 {
3869 struct ddraw *ddraw = impl_from_IDirect3D(iface);
3870
3871 TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
3872
3873 return d3d3_CreateLight(&ddraw->IDirect3D3_iface, light, outer_unknown);
3874 }
3875
3876 /*****************************************************************************
3877 * IDirect3D3::CreateMaterial
3878 *
3879 * Creates an IDirect3DMaterial interface. This interface is used by Direct3D3
3880 * and older versions. The IDirect3DMaterial implementation wraps its
3881 * functionality to IDirect3DDevice7::SetMaterial and friends.
3882 *
3883 * Versions 1, 2 and 3
3884 *
3885 * Params:
3886 * material: Address to store the new interface's pointer to
3887 * outer_unknown: Basically for aggregation, but ddraw doesn't support it.
3888 * Must be NULL
3889 *
3890 * Returns:
3891 * D3D_OK on success
3892 * DDERR_OUTOFMEMORY if memory allocation failed
3893 * CLASS_E_NOAGGREGATION if outer_unknown != NULL
3894 *
3895 *****************************************************************************/
3896 static HRESULT WINAPI d3d3_CreateMaterial(IDirect3D3 *iface, IDirect3DMaterial3 **material,
3897 IUnknown *outer_unknown)
3898 {
3899 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3900 struct d3d_material *object;
3901
3902 TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
3903
3904 if (outer_unknown) return CLASS_E_NOAGGREGATION;
3905
3906 object = d3d_material_create(ddraw);
3907 if (!object)
3908 {
3909 ERR("Failed to allocate material memory.\n");
3910 return DDERR_OUTOFMEMORY;
3911 }
3912
3913 TRACE("Created material %p.\n", object);
3914 *material = &object->IDirect3DMaterial3_iface;
3915
3916 return D3D_OK;
3917 }
3918
3919 static HRESULT WINAPI d3d2_CreateMaterial(IDirect3D2 *iface, IDirect3DMaterial2 **material,
3920 IUnknown *outer_unknown)
3921 {
3922 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
3923 struct d3d_material *object;
3924
3925 TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
3926
3927 object = d3d_material_create(ddraw);
3928 if (!object)
3929 {
3930 ERR("Failed to allocate material memory.\n");
3931 return DDERR_OUTOFMEMORY;
3932 }
3933
3934 TRACE("Created material %p.\n", object);
3935 *material = &object->IDirect3DMaterial2_iface;
3936
3937 return D3D_OK;
3938 }
3939
3940 static HRESULT WINAPI d3d1_CreateMaterial(IDirect3D *iface, IDirect3DMaterial **material,
3941 IUnknown *outer_unknown)
3942 {
3943 struct ddraw *ddraw = impl_from_IDirect3D(iface);
3944 struct d3d_material *object;
3945
3946 TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
3947
3948 object = d3d_material_create(ddraw);
3949 if (!object)
3950 {
3951 ERR("Failed to allocate material memory.\n");
3952 return DDERR_OUTOFMEMORY;
3953 }
3954
3955 TRACE("Created material %p.\n", object);
3956 *material = &object->IDirect3DMaterial_iface;
3957
3958 return D3D_OK;
3959 }
3960
3961 /*****************************************************************************
3962 * IDirect3D3::CreateViewport
3963 *
3964 * Creates an IDirect3DViewport interface. This interface is used
3965 * by Direct3D and earlier versions for Viewport management. In Direct3D7
3966 * it has been replaced by a viewport structure and
3967 * IDirect3DDevice7::*Viewport. Wine's IDirect3DViewport implementation
3968 * uses the IDirect3DDevice7 methods for its functionality
3969 *
3970 * Params:
3971 * Viewport: Address to store the new interface pointer
3972 * outer_unknown: Basically for aggregation, but ddraw doesn't support it.
3973 * Must be NULL
3974 *
3975 * Returns:
3976 * D3D_OK on success
3977 * DDERR_OUTOFMEMORY if memory allocation failed
3978 * CLASS_E_NOAGGREGATION if outer_unknown != NULL
3979 *
3980 *****************************************************************************/
3981 static HRESULT WINAPI d3d3_CreateViewport(IDirect3D3 *iface, IDirect3DViewport3 **viewport,
3982 IUnknown *outer_unknown)
3983 {
3984 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3985 struct d3d_viewport *object;
3986
3987 TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
3988
3989 if (outer_unknown) return CLASS_E_NOAGGREGATION;
3990
3991 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3992 if (!object)
3993 {
3994 ERR("Failed to allocate viewport memory.\n");
3995 return DDERR_OUTOFMEMORY;
3996 }
3997
3998 d3d_viewport_init(object, ddraw);
3999
4000 TRACE("Created viewport %p.\n", object);
4001 *viewport = &object->IDirect3DViewport3_iface;
4002
4003 return D3D_OK;
4004 }
4005
4006 static HRESULT WINAPI d3d2_CreateViewport(IDirect3D2 *iface, IDirect3DViewport2 **viewport, IUnknown *outer_unknown)
4007 {
4008 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4009
4010 TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4011
4012 return d3d3_CreateViewport(&ddraw->IDirect3D3_iface, (IDirect3DViewport3 **)viewport,
4013 outer_unknown);
4014 }
4015
4016 static HRESULT WINAPI d3d1_CreateViewport(IDirect3D *iface, IDirect3DViewport **viewport, IUnknown *outer_unknown)
4017 {
4018 struct ddraw *ddraw = impl_from_IDirect3D(iface);
4019
4020 TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4021
4022 return d3d3_CreateViewport(&ddraw->IDirect3D3_iface, (IDirect3DViewport3 **)viewport,
4023 outer_unknown);
4024 }
4025
4026 /*****************************************************************************
4027 * IDirect3D3::FindDevice
4028 *
4029 * This method finds a device with the requested properties and returns a
4030 * device description
4031 *
4032 * Versions 1, 2 and 3
4033 * Params:
4034 * fds: Describes the requested device characteristics
4035 * fdr: Returns the device description
4036 *
4037 * Returns:
4038 * D3D_OK on success
4039 * DDERR_INVALIDPARAMS if no device was found
4040 *
4041 *****************************************************************************/
4042 static HRESULT WINAPI d3d3_FindDevice(IDirect3D3 *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4043 {
4044 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4045 D3DDEVICEDESC7 desc7;
4046 D3DDEVICEDESC desc1;
4047 HRESULT hr;
4048
4049 TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4050
4051 if (!fds || !fdr) return DDERR_INVALIDPARAMS;
4052
4053 if (fds->dwSize != sizeof(D3DFINDDEVICESEARCH)
4054 || fdr->dwSize != sizeof(D3DFINDDEVICERESULT))
4055 return DDERR_INVALIDPARAMS;
4056
4057 if ((fds->dwFlags & D3DFDS_COLORMODEL)
4058 && fds->dcmColorModel != D3DCOLOR_RGB)
4059 {
4060 WARN("Trying to request a non-RGB D3D color model. Not supported.\n");
4061 return DDERR_INVALIDPARAMS; /* No real idea what to return here :-) */
4062 }
4063
4064 if (fds->dwFlags & D3DFDS_GUID)
4065 {
4066 TRACE("Trying to match guid %s.\n", debugstr_guid(&(fds->guid)));
4067 if (!IsEqualGUID(&IID_D3DDEVICE_WineD3D, &fds->guid)
4068 && !IsEqualGUID(&IID_IDirect3DHALDevice, &fds->guid)
4069 && !IsEqualGUID(&IID_IDirect3DRGBDevice, &fds->guid))
4070 {
4071 WARN("No match for this GUID.\n");
4072 return DDERR_NOTFOUND;
4073 }
4074 }
4075
4076 /* Get the caps */
4077 if (FAILED(hr = ddraw_get_d3dcaps(ddraw, &desc7)))
4078 return hr;
4079
4080 /* Now return our own GUID */
4081 ddraw_d3dcaps1_from_7(&desc1, &desc7);
4082 fdr->guid = IID_D3DDEVICE_WineD3D;
4083 fdr->ddHwDesc = desc1;
4084 fdr->ddSwDesc = desc1;
4085
4086 TRACE("Returning Wine's wined3d device with (undumped) capabilities.\n");
4087
4088 return D3D_OK;
4089 }
4090
4091 static HRESULT WINAPI d3d2_FindDevice(IDirect3D2 *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4092 {
4093 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4094
4095 TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4096
4097 return d3d3_FindDevice(&ddraw->IDirect3D3_iface, fds, fdr);
4098 }
4099
4100 static HRESULT WINAPI d3d1_FindDevice(IDirect3D *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4101 {
4102 struct ddraw *ddraw = impl_from_IDirect3D(iface);
4103
4104 TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4105
4106 return d3d3_FindDevice(&ddraw->IDirect3D3_iface, fds, fdr);
4107 }
4108
4109 /*****************************************************************************
4110 * IDirect3D7::CreateDevice
4111 *
4112 * Creates an IDirect3DDevice7 interface.
4113 *
4114 * Versions 2, 3 and 7. IDirect3DDevice 1 interfaces are interfaces to
4115 * DirectDraw surfaces and are created with
4116 * IDirectDrawSurface::QueryInterface. This method uses CreateDevice to
4117 * create the device object and QueryInterfaces for IDirect3DDevice
4118 *
4119 * Params:
4120 * refiid: IID of the device to create
4121 * Surface: Initial rendertarget
4122 * Device: Address to return the interface pointer
4123 *
4124 * Returns:
4125 * D3D_OK on success
4126 * DDERR_OUTOFMEMORY if memory allocation failed
4127 * DDERR_INVALIDPARAMS if a device exists already
4128 *
4129 *****************************************************************************/
4130 static HRESULT WINAPI d3d7_CreateDevice(IDirect3D7 *iface, REFCLSID riid,
4131 IDirectDrawSurface7 *surface, IDirect3DDevice7 **device)
4132 {
4133 struct ddraw_surface *target = unsafe_impl_from_IDirectDrawSurface7(surface);
4134 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4135 struct d3d_device *object;
4136 HRESULT hr;
4137
4138 TRACE("iface %p, riid %s, surface %p, device %p.\n", iface, debugstr_guid(riid), surface, device);
4139
4140 wined3d_mutex_lock();
4141 if (SUCCEEDED(hr = d3d_device_create(ddraw, target, (IUnknown *)surface, 7, &object, NULL)))
4142 {
4143 *device = &object->IDirect3DDevice7_iface;
4144 }
4145 else
4146 {
4147 WARN("Failed to create device, hr %#x.\n", hr);
4148 *device = NULL;
4149 }
4150 wined3d_mutex_unlock();
4151
4152 return hr;
4153 }
4154
4155 static HRESULT WINAPI d3d3_CreateDevice(IDirect3D3 *iface, REFCLSID riid,
4156 IDirectDrawSurface4 *surface, IDirect3DDevice3 **device, IUnknown *outer_unknown)
4157 {
4158 struct ddraw_surface *surface_impl = unsafe_impl_from_IDirectDrawSurface4(surface);
4159 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4160 struct d3d_device *device_impl;
4161 HRESULT hr;
4162
4163 TRACE("iface %p, riid %s, surface %p, device %p, outer_unknown %p.\n",
4164 iface, debugstr_guid(riid), surface, device, outer_unknown);
4165
4166 if (outer_unknown)
4167 return CLASS_E_NOAGGREGATION;
4168
4169 wined3d_mutex_lock();
4170 if (SUCCEEDED(hr = d3d_device_create(ddraw, surface_impl, (IUnknown *)surface, 3, &device_impl, NULL)))
4171 {
4172 *device = &device_impl->IDirect3DDevice3_iface;
4173 }
4174 else
4175 {
4176 WARN("Failed to create device, hr %#x.\n", hr);
4177 *device = NULL;
4178 }
4179 wined3d_mutex_unlock();
4180
4181 return hr;
4182 }
4183
4184 static HRESULT WINAPI d3d2_CreateDevice(IDirect3D2 *iface, REFCLSID riid,
4185 IDirectDrawSurface *surface, IDirect3DDevice2 **device)
4186 {
4187 struct ddraw_surface *surface_impl = unsafe_impl_from_IDirectDrawSurface(surface);
4188 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4189 struct d3d_device *device_impl;
4190 HRESULT hr;
4191
4192 TRACE("iface %p, riid %s, surface %p, device %p.\n",
4193 iface, debugstr_guid(riid), surface, device);
4194
4195 wined3d_mutex_lock();
4196 if (SUCCEEDED(hr = d3d_device_create(ddraw, surface_impl, (IUnknown *)surface, 2, &device_impl, NULL)))
4197 {
4198 *device = &device_impl->IDirect3DDevice2_iface;
4199 }
4200 else
4201 {
4202 WARN("Failed to create device, hr %#x.\n", hr);
4203 *device = NULL;
4204 }
4205 wined3d_mutex_unlock();
4206
4207 return hr;
4208 }
4209
4210 /*****************************************************************************
4211 * IDirect3D7::CreateVertexBuffer
4212 *
4213 * Creates a new vertex buffer object and returns a IDirect3DVertexBuffer7
4214 * interface.
4215 *
4216 * Versions 3 and 7
4217 *
4218 * Params:
4219 * desc: Requested Vertex buffer properties
4220 * vertex_buffer: Address to return the interface pointer at
4221 * flags: Some flags, should be 0
4222 *
4223 * Returns
4224 * D3D_OK on success
4225 * DDERR_OUTOFMEMORY if memory allocation failed
4226 * DDERR_INVALIDPARAMS if desc or vertex_buffer is NULL
4227 *
4228 *****************************************************************************/
4229 static HRESULT WINAPI d3d7_CreateVertexBuffer(IDirect3D7 *iface, D3DVERTEXBUFFERDESC *desc,
4230 IDirect3DVertexBuffer7 **vertex_buffer, DWORD flags)
4231 {
4232 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4233 struct d3d_vertex_buffer *object;
4234 HRESULT hr;
4235
4236 TRACE("iface %p, desc %p, vertex_buffer %p, flags %#x.\n",
4237 iface, desc, vertex_buffer, flags);
4238
4239 if (!vertex_buffer || !desc) return DDERR_INVALIDPARAMS;
4240
4241 hr = d3d_vertex_buffer_create(&object, ddraw, desc);
4242 if (hr == D3D_OK)
4243 {
4244 TRACE("Created vertex buffer %p.\n", object);
4245 *vertex_buffer = &object->IDirect3DVertexBuffer7_iface;
4246 }
4247 else
4248 WARN("Failed to create vertex buffer, hr %#x.\n", hr);
4249
4250 return hr;
4251 }
4252
4253 static HRESULT WINAPI d3d3_CreateVertexBuffer(IDirect3D3 *iface, D3DVERTEXBUFFERDESC *desc,
4254 IDirect3DVertexBuffer **vertex_buffer, DWORD flags, IUnknown *outer_unknown)
4255 {
4256 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4257 struct d3d_vertex_buffer *object;
4258 HRESULT hr;
4259
4260 TRACE("iface %p, desc %p, vertex_buffer %p, flags %#x, outer_unknown %p.\n",
4261 iface, desc, vertex_buffer, flags, outer_unknown);
4262
4263 if (outer_unknown)
4264 return CLASS_E_NOAGGREGATION;
4265 if (!vertex_buffer || !desc)
4266 return DDERR_INVALIDPARAMS;
4267
4268 hr = d3d_vertex_buffer_create(&object, ddraw, desc);
4269 if (hr == D3D_OK)
4270 {
4271 TRACE("Created vertex buffer %p.\n", object);
4272 *vertex_buffer = (IDirect3DVertexBuffer *)&object->IDirect3DVertexBuffer7_iface;
4273 }
4274 else
4275 WARN("Failed to create vertex buffer, hr %#x.\n", hr);
4276
4277 return hr;
4278 }
4279
4280 /*****************************************************************************
4281 * IDirect3D7::EnumZBufferFormats
4282 *
4283 * Enumerates all supported Z buffer pixel formats
4284 *
4285 * Versions 3 and 7
4286 *
4287 * Params:
4288 * device_iid:
4289 * callback: callback to call for each pixel format
4290 * context: Pointer to pass back to the callback
4291 *
4292 * Returns:
4293 * D3D_OK on success
4294 * DDERR_INVALIDPARAMS if callback is NULL
4295 *
4296 *****************************************************************************/
4297 static HRESULT WINAPI d3d7_EnumZBufferFormats(IDirect3D7 *iface, REFCLSID device_iid,
4298 LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
4299 {
4300 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4301 struct wined3d_display_mode mode;
4302 enum wined3d_device_type type;
4303 unsigned int i;
4304 HRESULT hr;
4305
4306 /* Order matters. Specifically, BattleZone II (full version) expects the
4307 * 16-bit depth formats to be listed before the 24 and 32 ones. */
4308 static const enum wined3d_format_id formats[] =
4309 {
4310 WINED3DFMT_S1_UINT_D15_UNORM,
4311 WINED3DFMT_D16_UNORM,
4312 WINED3DFMT_X8D24_UNORM,
4313 WINED3DFMT_S4X4_UINT_D24_UNORM,
4314 WINED3DFMT_D24_UNORM_S8_UINT,
4315 WINED3DFMT_D32_UNORM,
4316 };
4317
4318 TRACE("iface %p, device_iid %s, callback %p, context %p.\n",
4319 iface, debugstr_guid(device_iid), callback, context);
4320
4321 if (!callback) return DDERR_INVALIDPARAMS;
4322
4323 if (IsEqualGUID(device_iid, &IID_IDirect3DHALDevice)
4324 || IsEqualGUID(device_iid, &IID_IDirect3DTnLHalDevice)
4325 || IsEqualGUID(device_iid, &IID_D3DDEVICE_WineD3D))
4326 {
4327 TRACE("Asked for HAL device.\n");
4328 type = WINED3D_DEVICE_TYPE_HAL;
4329 }
4330 else if (IsEqualGUID(device_iid, &IID_IDirect3DRGBDevice)
4331 || IsEqualGUID(device_iid, &IID_IDirect3DMMXDevice))
4332 {
4333 TRACE("Asked for SW device.\n");
4334 type = WINED3D_DEVICE_TYPE_SW;
4335 }
4336 else if (IsEqualGUID(device_iid, &IID_IDirect3DRefDevice))
4337 {
4338 TRACE("Asked for REF device.\n");
4339 type = WINED3D_DEVICE_TYPE_REF;
4340 }
4341 else if (IsEqualGUID(device_iid, &IID_IDirect3DNullDevice))
4342 {
4343 TRACE("Asked for NULLREF device.\n");
4344 type = WINED3D_DEVICE_TYPE_NULLREF;
4345 }
4346 else
4347 {
4348 FIXME("Unexpected device GUID %s.\n", debugstr_guid(device_iid));
4349 type = WINED3D_DEVICE_TYPE_HAL;
4350 }
4351
4352 wined3d_mutex_lock();
4353 /* We need an adapter format from somewhere to please wined3d and WGL.
4354 * Use the current display mode. So far all cards offer the same depth
4355 * stencil format for all modes, but if some do not and applications do
4356 * not like that we'll have to find some workaround, like iterating over
4357 * all imaginable formats and collecting all the depth stencil formats we
4358 * can get. */
4359 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
4360 {
4361 ERR("Failed to get display mode, hr %#x.\n", hr);
4362 wined3d_mutex_unlock();
4363 return hr;
4364 }
4365
4366 for (i = 0; i < (sizeof(formats) / sizeof(*formats)); ++i)
4367 {
4368 if (SUCCEEDED(wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, type, mode.format_id,
4369 WINED3DUSAGE_DEPTHSTENCIL, WINED3D_RTYPE_TEXTURE_2D, formats[i])))
4370 {
4371 DDPIXELFORMAT pformat;
4372
4373 memset(&pformat, 0, sizeof(pformat));
4374 pformat.dwSize = sizeof(pformat);
4375 ddrawformat_from_wined3dformat(&pformat, formats[i]);
4376
4377 TRACE("Enumerating wined3d format %#x.\n", formats[i]);
4378 hr = callback(&pformat, context);
4379 if (hr != DDENUMRET_OK)
4380 {
4381 TRACE("Format enumeration cancelled by application.\n");
4382 wined3d_mutex_unlock();
4383 return D3D_OK;
4384 }
4385 }
4386 }
4387
4388 /* Historically some windows drivers used dwZBufferBitDepth=24 for WINED3DFMT_X8D24_UNORM,
4389 * while others used dwZBufferBitDepth=32. In either case the pitch matches a 32 bits per
4390 * pixel format, so we use dwZBufferBitDepth=32. Some games expect 24. Windows Vista and
4391 * newer enumerate both versions, so we do the same(bug 22434) */
4392 if (SUCCEEDED(wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, type, mode.format_id,
4393 WINED3DUSAGE_DEPTHSTENCIL, WINED3D_RTYPE_TEXTURE_2D, WINED3DFMT_X8D24_UNORM)))
4394 {
4395 DDPIXELFORMAT x8d24 =
4396 {
4397 sizeof(x8d24), DDPF_ZBUFFER, 0,
4398 {24}, {0x00000000}, {0x00ffffff}, {0x00000000}
4399 };
4400 TRACE("Enumerating WINED3DFMT_X8D24_UNORM, dwZBufferBitDepth=24 version\n");
4401 callback(&x8d24, context);
4402 }
4403
4404 TRACE("End of enumeration.\n");
4405
4406 wined3d_mutex_unlock();
4407
4408 return D3D_OK;
4409 }
4410
4411 static HRESULT WINAPI d3d3_EnumZBufferFormats(IDirect3D3 *iface, REFCLSID device_iid,
4412 LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
4413 {
4414 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4415
4416 TRACE("iface %p, device_iid %s, callback %p, context %p.\n",
4417 iface, debugstr_guid(device_iid), callback, context);
4418
4419 return d3d7_EnumZBufferFormats(&ddraw->IDirect3D7_iface, device_iid, callback, context);
4420 }
4421
4422 /*****************************************************************************
4423 * IDirect3D7::EvictManagedTextures
4424 *
4425 * Removes all managed textures (=surfaces with DDSCAPS2_TEXTUREMANAGE or
4426 * DDSCAPS2_D3DTEXTUREMANAGE caps) to be removed from video memory.
4427 *
4428 * Versions 3 and 7
4429 *
4430 * Returns:
4431 * D3D_OK, because it's a stub
4432 *
4433 *****************************************************************************/
4434 static HRESULT WINAPI d3d7_EvictManagedTextures(IDirect3D7 *iface)
4435 {
4436 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4437
4438 TRACE("iface %p!\n", iface);
4439
4440 wined3d_mutex_lock();
4441 if (ddraw->flags & DDRAW_D3D_INITIALIZED)
4442 wined3d_device_evict_managed_resources(ddraw->wined3d_device);
4443 wined3d_mutex_unlock();
4444
4445 return D3D_OK;
4446 }
4447
4448 static HRESULT WINAPI d3d3_EvictManagedTextures(IDirect3D3 *iface)
4449 {
4450 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4451
4452 TRACE("iface %p.\n", iface);
4453
4454 return d3d7_EvictManagedTextures(&ddraw->IDirect3D7_iface);
4455 }
4456
4457 /*****************************************************************************
4458 * IDirectDraw7 VTable
4459 *****************************************************************************/
4460 static const struct IDirectDraw7Vtbl ddraw7_vtbl =
4461 {
4462 /* IUnknown */
4463 ddraw7_QueryInterface,
4464 ddraw7_AddRef,
4465 ddraw7_Release,
4466 /* IDirectDraw */
4467 ddraw7_Compact,
4468 ddraw7_CreateClipper,
4469 ddraw7_CreatePalette,
4470 ddraw7_CreateSurface,
4471 ddraw7_DuplicateSurface,
4472 ddraw7_EnumDisplayModes,
4473 ddraw7_EnumSurfaces,
4474 ddraw7_FlipToGDISurface,
4475 ddraw7_GetCaps,
4476 ddraw7_GetDisplayMode,
4477 ddraw7_GetFourCCCodes,
4478 ddraw7_GetGDISurface,
4479 ddraw7_GetMonitorFrequency,
4480 ddraw7_GetScanLine,
4481 ddraw7_GetVerticalBlankStatus,
4482 ddraw7_Initialize,
4483 ddraw7_RestoreDisplayMode,
4484 ddraw7_SetCooperativeLevel,
4485 ddraw7_SetDisplayMode,
4486 ddraw7_WaitForVerticalBlank,
4487 /* IDirectDraw2 */
4488 ddraw7_GetAvailableVidMem,
4489 /* IDirectDraw3 */
4490 ddraw7_GetSurfaceFromDC,
4491 /* IDirectDraw4 */
4492 ddraw7_RestoreAllSurfaces,
4493 ddraw7_TestCooperativeLevel,
4494 ddraw7_GetDeviceIdentifier,
4495 /* IDirectDraw7 */
4496 ddraw7_StartModeTest,
4497 ddraw7_EvaluateMode
4498 };
4499
4500 static const struct IDirectDraw4Vtbl ddraw4_vtbl =
4501 {
4502 /* IUnknown */
4503 ddraw4_QueryInterface,
4504 ddraw4_AddRef,
4505 ddraw4_Release,
4506 /* IDirectDraw */
4507 ddraw4_Compact,
4508 ddraw4_CreateClipper,
4509 ddraw4_CreatePalette,
4510 ddraw4_CreateSurface,
4511 ddraw4_DuplicateSurface,
4512 ddraw4_EnumDisplayModes,
4513 ddraw4_EnumSurfaces,
4514 ddraw4_FlipToGDISurface,
4515 ddraw4_GetCaps,
4516 ddraw4_GetDisplayMode,
4517 ddraw4_GetFourCCCodes,
4518 ddraw4_GetGDISurface,
4519 ddraw4_GetMonitorFrequency,
4520 ddraw4_GetScanLine,
4521 ddraw4_GetVerticalBlankStatus,
4522 ddraw4_Initialize,
4523 ddraw4_RestoreDisplayMode,
4524 ddraw4_SetCooperativeLevel,
4525 ddraw4_SetDisplayMode,
4526 ddraw4_WaitForVerticalBlank,
4527 /* IDirectDraw2 */
4528 ddraw4_GetAvailableVidMem,
4529 /* IDirectDraw3 */
4530 ddraw4_GetSurfaceFromDC,
4531 /* IDirectDraw4 */
4532 ddraw4_RestoreAllSurfaces,
4533 ddraw4_TestCooperativeLevel,
4534 ddraw4_GetDeviceIdentifier,
4535 };
4536
4537 static const struct IDirectDraw2Vtbl ddraw2_vtbl =
4538 {
4539 /* IUnknown */
4540 ddraw2_QueryInterface,
4541 ddraw2_AddRef,
4542 ddraw2_Release,
4543 /* IDirectDraw */
4544 ddraw2_Compact,
4545 ddraw2_CreateClipper,
4546 ddraw2_CreatePalette,
4547 ddraw2_CreateSurface,
4548 ddraw2_DuplicateSurface,
4549 ddraw2_EnumDisplayModes,
4550 ddraw2_EnumSurfaces,
4551 ddraw2_FlipToGDISurface,
4552 ddraw2_GetCaps,
4553 ddraw2_GetDisplayMode,
4554 ddraw2_GetFourCCCodes,
4555 ddraw2_GetGDISurface,
4556 ddraw2_GetMonitorFrequency,
4557 ddraw2_GetScanLine,
4558 ddraw2_GetVerticalBlankStatus,
4559 ddraw2_Initialize,
4560 ddraw2_RestoreDisplayMode,
4561 ddraw2_SetCooperativeLevel,
4562 ddraw2_SetDisplayMode,
4563 ddraw2_WaitForVerticalBlank,
4564 /* IDirectDraw2 */
4565 ddraw2_GetAvailableVidMem,
4566 };
4567
4568 static const struct IDirectDrawVtbl ddraw1_vtbl =
4569 {
4570 /* IUnknown */
4571 ddraw1_QueryInterface,
4572 ddraw1_AddRef,
4573 ddraw1_Release,
4574 /* IDirectDraw */
4575 ddraw1_Compact,
4576 ddraw1_CreateClipper,
4577 ddraw1_CreatePalette,
4578 ddraw1_CreateSurface,
4579 ddraw1_DuplicateSurface,
4580 ddraw1_EnumDisplayModes,
4581 ddraw1_EnumSurfaces,
4582 ddraw1_FlipToGDISurface,
4583 ddraw1_GetCaps,
4584 ddraw1_GetDisplayMode,
4585 ddraw1_GetFourCCCodes,
4586 ddraw1_GetGDISurface,
4587 ddraw1_GetMonitorFrequency,
4588 ddraw1_GetScanLine,
4589 ddraw1_GetVerticalBlankStatus,
4590 ddraw1_Initialize,
4591 ddraw1_RestoreDisplayMode,
4592 ddraw1_SetCooperativeLevel,
4593 ddraw1_SetDisplayMode,
4594 ddraw1_WaitForVerticalBlank,
4595 };
4596
4597 static const struct IDirect3D7Vtbl d3d7_vtbl =
4598 {
4599 /* IUnknown methods */
4600 d3d7_QueryInterface,
4601 d3d7_AddRef,
4602 d3d7_Release,
4603 /* IDirect3D7 methods */
4604 d3d7_EnumDevices,
4605 d3d7_CreateDevice,
4606 d3d7_CreateVertexBuffer,
4607 d3d7_EnumZBufferFormats,
4608 d3d7_EvictManagedTextures
4609 };
4610
4611 static const struct IDirect3D3Vtbl d3d3_vtbl =
4612 {
4613 /* IUnknown methods */
4614 d3d3_QueryInterface,
4615 d3d3_AddRef,
4616 d3d3_Release,
4617 /* IDirect3D3 methods */
4618 d3d3_EnumDevices,
4619 d3d3_CreateLight,
4620 d3d3_CreateMaterial,
4621 d3d3_CreateViewport,
4622 d3d3_FindDevice,
4623 d3d3_CreateDevice,
4624 d3d3_CreateVertexBuffer,
4625 d3d3_EnumZBufferFormats,
4626 d3d3_EvictManagedTextures
4627 };
4628
4629 static const struct IDirect3D2Vtbl d3d2_vtbl =
4630 {
4631 /* IUnknown methods */
4632 d3d2_QueryInterface,
4633 d3d2_AddRef,
4634 d3d2_Release,
4635 /* IDirect3D2 methods */
4636 d3d2_EnumDevices,
4637 d3d2_CreateLight,
4638 d3d2_CreateMaterial,
4639 d3d2_CreateViewport,
4640 d3d2_FindDevice,
4641 d3d2_CreateDevice
4642 };
4643
4644 static const struct IDirect3DVtbl d3d1_vtbl =
4645 {
4646 /* IUnknown methods */
4647 d3d1_QueryInterface,
4648 d3d1_AddRef,
4649 d3d1_Release,
4650 /* IDirect3D methods */
4651 d3d1_Initialize,
4652 d3d1_EnumDevices,
4653 d3d1_CreateLight,
4654 d3d1_CreateMaterial,
4655 d3d1_CreateViewport,
4656 d3d1_FindDevice
4657 };
4658
4659 /*****************************************************************************
4660 * ddraw_find_decl
4661 *
4662 * Finds the WineD3D vertex declaration for a specific fvf, and creates one
4663 * if none was found.
4664 *
4665 * This function is in ddraw.c and the DDraw object space because D3D7
4666 * vertex buffers are created using the IDirect3D interface to the ddraw
4667 * object, so they can be valid across D3D devices(theoretically. The ddraw
4668 * object also owns the wined3d device
4669 *
4670 * Parameters:
4671 * This: Device
4672 * fvf: Fvf to find the decl for
4673 *
4674 * Returns:
4675 * NULL in case of an error, the vertex declaration for the FVF otherwise.
4676 *
4677 *****************************************************************************/
4678 struct wined3d_vertex_declaration *ddraw_find_decl(struct ddraw *This, DWORD fvf)
4679 {
4680 struct wined3d_vertex_declaration *pDecl = NULL;
4681 HRESULT hr;
4682 int p, low, high; /* deliberately signed */
4683 struct FvfToDecl *convertedDecls = This->decls;
4684
4685 TRACE("Searching for declaration for fvf %08x... ", fvf);
4686
4687 low = 0;
4688 high = This->numConvertedDecls - 1;
4689 while(low <= high) {
4690 p = (low + high) >> 1;
4691 TRACE("%d ", p);
4692 if(convertedDecls[p].fvf == fvf) {
4693 TRACE("found %p\n", convertedDecls[p].decl);
4694 return convertedDecls[p].decl;
4695 } else if(convertedDecls[p].fvf < fvf) {
4696 low = p + 1;
4697 } else {
4698 high = p - 1;
4699 }
4700 }
4701 TRACE("not found. Creating and inserting at position %d.\n", low);
4702
4703 hr = wined3d_vertex_declaration_create_from_fvf(This->wined3d_device,
4704 fvf, This, &ddraw_null_wined3d_parent_ops, &pDecl);
4705 if (hr != S_OK) return NULL;
4706
4707 if(This->declArraySize == This->numConvertedDecls) {
4708 int grow = max(This->declArraySize / 2, 8);
4709 convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls,
4710 sizeof(convertedDecls[0]) * (This->numConvertedDecls + grow));
4711 if (!convertedDecls)
4712 {
4713 wined3d_vertex_declaration_decref(pDecl);
4714 return NULL;
4715 }
4716 This->decls = convertedDecls;
4717 This->declArraySize += grow;
4718 }
4719
4720 memmove(convertedDecls + low + 1, convertedDecls + low, sizeof(convertedDecls[0]) * (This->numConvertedDecls - low));
4721 convertedDecls[low].decl = pDecl;
4722 convertedDecls[low].fvf = fvf;
4723 This->numConvertedDecls++;
4724
4725 TRACE("Returning %p. %d decls in array\n", pDecl, This->numConvertedDecls);
4726 return pDecl;
4727 }
4728
4729 static inline struct ddraw *ddraw_from_device_parent(struct wined3d_device_parent *device_parent)
4730 {
4731 return CONTAINING_RECORD(device_parent, struct ddraw, device_parent);
4732 }
4733
4734 static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent,
4735 struct wined3d_device *device)
4736 {
4737 TRACE("device_parent %p, device %p.\n", device_parent, device);
4738 }
4739
4740 /* This is run from device_process_message() in wined3d, we can't take the
4741 * wined3d mutex. */
4742 /* FIXME: We only get mode change notifications in exclusive mode, but we
4743 * should mark surfaces as lost on mode changes in DDSCL_NORMAL mode as well. */
4744 static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent)
4745 {
4746 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4747 MONITORINFO monitor_info;
4748 HMONITOR monitor;
4749 RECT *r;
4750
4751 TRACE("device_parent %p.\n", device_parent);
4752
4753 if (!(ddraw->cooperative_level & DDSCL_EXCLUSIVE) || !ddraw->swapchain_window)
4754 {
4755 TRACE("Nothing to resize.\n");
4756 return;
4757 }
4758
4759 monitor = MonitorFromWindow(ddraw->swapchain_window, MONITOR_DEFAULTTOPRIMARY);
4760 monitor_info.cbSize = sizeof(monitor_info);
4761 if (!GetMonitorInfoW(monitor, &monitor_info))
4762 {
4763 ERR("Failed to get monitor info.\n");
4764 return;
4765 }
4766
4767 r = &monitor_info.rcMonitor;
4768 TRACE("Resizing window %p to %s.\n", ddraw->swapchain_window, wine_dbgstr_rect(r));
4769
4770 if (!SetWindowPos(ddraw->swapchain_window, HWND_TOP, r->left, r->top,
4771 r->right - r->left, r->bottom - r->top, SWP_SHOWWINDOW | SWP_NOACTIVATE))
4772 ERR("Failed to resize window.\n");
4773
4774 InterlockedCompareExchange(&ddraw->device_state, DDRAW_DEVICE_STATE_NOT_RESTORED, DDRAW_DEVICE_STATE_OK);
4775 }
4776
4777 static void CDECL device_parent_activate(struct wined3d_device_parent *device_parent, BOOL activate)
4778 {
4779 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4780
4781 TRACE("device_parent %p, activate %#x.\n", device_parent, activate);
4782
4783 if (!activate)
4784 {
4785 ddraw->device_state = DDRAW_DEVICE_STATE_LOST;
4786 exclusive_window = NULL;
4787 }
4788 else
4789 {
4790 InterlockedCompareExchange(&ddraw->device_state, DDRAW_DEVICE_STATE_NOT_RESTORED, DDRAW_DEVICE_STATE_LOST);
4791 }
4792 }
4793
4794 void ddraw_update_lost_surfaces(struct ddraw *ddraw)
4795 {
4796 struct ddraw_surface *surface;
4797
4798 if (ddraw->device_state != DDRAW_DEVICE_STATE_NOT_RESTORED)
4799 return;
4800
4801 LIST_FOR_EACH_ENTRY(surface, &ddraw->surface_list, struct ddraw_surface, surface_list_entry)
4802 {
4803 surface->is_lost = TRUE;
4804 }
4805 ddraw->device_state = DDRAW_DEVICE_STATE_OK;
4806 }
4807
4808 static HRESULT CDECL device_parent_surface_created(struct wined3d_device_parent *device_parent,
4809 struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx,
4810 void **parent, const struct wined3d_parent_ops **parent_ops)
4811 {
4812 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4813 struct ddraw_surface *ddraw_surface;
4814
4815 TRACE("device_parent %p, wined3d_texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n",
4816 device_parent, wined3d_texture, sub_resource_idx, parent, parent_ops);
4817
4818 /* We have a swapchain or wined3d internal texture. */
4819 if (!wined3d_texture_get_parent(wined3d_texture) || wined3d_texture_get_parent(wined3d_texture) == ddraw)
4820 {
4821 *parent = NULL;
4822 *parent_ops = &ddraw_null_wined3d_parent_ops;
4823
4824 return DD_OK;
4825 }
4826
4827 if (!(ddraw_surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw_surface))))
4828 {
4829 ERR("Failed to allocate surface memory.\n");
4830 return DDERR_OUTOFVIDEOMEMORY;
4831 }
4832
4833 ddraw_surface_init(ddraw_surface, ddraw, wined3d_texture, sub_resource_idx, parent_ops);
4834 *parent = ddraw_surface;
4835
4836 ddraw_update_lost_surfaces(ddraw);
4837 list_add_head(&ddraw->surface_list, &ddraw_surface->surface_list_entry);
4838
4839 TRACE("Created ddraw surface %p.\n", ddraw_surface);
4840
4841 return DD_OK;
4842 }
4843
4844 static HRESULT CDECL device_parent_volume_created(struct wined3d_device_parent *device_parent,
4845 struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx,
4846 void **parent, const struct wined3d_parent_ops **parent_ops)
4847 {
4848 TRACE("device_parent %p, texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n",
4849 device_parent, wined3d_texture, sub_resource_idx, parent, parent_ops);
4850
4851 *parent = NULL;
4852 *parent_ops = &ddraw_null_wined3d_parent_ops;
4853
4854 return DD_OK;
4855 }
4856
4857 static void STDMETHODCALLTYPE ddraw_frontbuffer_destroyed(void *parent)
4858 {
4859 struct ddraw *ddraw = parent;
4860 ddraw->wined3d_frontbuffer = NULL;
4861 }
4862
4863 static const struct wined3d_parent_ops ddraw_frontbuffer_parent_ops =
4864 {
4865 ddraw_frontbuffer_destroyed,
4866 };
4867
4868 static HRESULT CDECL device_parent_create_swapchain_texture(struct wined3d_device_parent *device_parent,
4869 void *container_parent, const struct wined3d_resource_desc *desc, DWORD texture_flags,
4870 struct wined3d_texture **texture)
4871 {
4872 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4873 HRESULT hr;
4874
4875 TRACE("device_parent %p, container_parent %p, desc %p, texture flags %#x, texture %p.\n",
4876 device_parent, container_parent, desc, texture_flags, texture);
4877
4878 if (ddraw->wined3d_frontbuffer)
4879 {
4880 ERR("Frontbuffer already created.\n");
4881 return E_FAIL;
4882 }
4883
4884 if (FAILED(hr = wined3d_texture_create(ddraw->wined3d_device, desc, 1, 1,
4885 texture_flags | WINED3D_TEXTURE_CREATE_MAPPABLE, NULL, ddraw, &ddraw_frontbuffer_parent_ops, texture)))
4886 {
4887 WARN("Failed to create texture, hr %#x.\n", hr);
4888 return hr;
4889 }
4890
4891 ddraw->wined3d_frontbuffer = *texture;
4892
4893 return hr;
4894 }
4895
4896 static HRESULT CDECL device_parent_create_swapchain(struct wined3d_device_parent *device_parent,
4897 struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **swapchain)
4898 {
4899 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4900 HRESULT hr;
4901
4902 TRACE("device_parent %p, desc %p, swapchain %p.\n", device_parent, desc, swapchain);
4903
4904 if (ddraw->wined3d_swapchain)
4905 {
4906 ERR("Swapchain already created.\n");
4907 return E_FAIL;
4908 }
4909
4910 if (FAILED(hr = wined3d_swapchain_create(ddraw->wined3d_device, desc, NULL,
4911 &ddraw_null_wined3d_parent_ops, swapchain)))
4912 WARN("Failed to create swapchain, hr %#x.\n", hr);
4913
4914 return hr;
4915 }
4916
4917 static const struct wined3d_device_parent_ops ddraw_wined3d_device_parent_ops =
4918 {
4919 device_parent_wined3d_device_created,
4920 device_parent_mode_changed,
4921 device_parent_activate,
4922 device_parent_surface_created,
4923 device_parent_volume_created,
4924 device_parent_create_swapchain_texture,
4925 device_parent_create_swapchain,
4926 };
4927
4928 HRESULT ddraw_init(struct ddraw *ddraw, DWORD flags, enum wined3d_device_type device_type)
4929 {
4930 WINED3DCAPS caps;
4931 HRESULT hr;
4932
4933 ddraw->IDirectDraw7_iface.lpVtbl = &ddraw7_vtbl;
4934 ddraw->IDirectDraw_iface.lpVtbl = &ddraw1_vtbl;
4935 ddraw->IDirectDraw2_iface.lpVtbl = &ddraw2_vtbl;
4936 ddraw->IDirectDraw4_iface.lpVtbl = &ddraw4_vtbl;
4937 ddraw->IDirect3D_iface.lpVtbl = &d3d1_vtbl;
4938 ddraw->IDirect3D2_iface.lpVtbl = &d3d2_vtbl;
4939 ddraw->IDirect3D3_iface.lpVtbl = &d3d3_vtbl;
4940 ddraw->IDirect3D7_iface.lpVtbl = &d3d7_vtbl;
4941 ddraw->device_parent.ops = &ddraw_wined3d_device_parent_ops;
4942 ddraw->numIfaces = 1;
4943 ddraw->ref7 = 1;
4944
4945 flags |= DDRAW_WINED3D_FLAGS;
4946 if (!(ddraw->wined3d = wined3d_create(flags)))
4947 {
4948 flags |= WINED3D_NO3D;
4949 if (!(ddraw->wined3d = wined3d_create(flags)))
4950 {
4951 WARN("Failed to create a wined3d object.\n");
4952 return E_FAIL;
4953 }
4954 }
4955
4956 if (FAILED(hr = wined3d_get_device_caps(ddraw->wined3d, WINED3DADAPTER_DEFAULT, device_type, &caps)))
4957 {
4958 ERR("Failed to get device caps, hr %#x.\n", hr);
4959 wined3d_decref(ddraw->wined3d);
4960 return E_FAIL;
4961 }
4962
4963 if (!(caps.ddraw_caps.caps & WINEDDCAPS_3D))
4964 {
4965 WARN("Created a wined3d object without 3D support.\n");
4966 ddraw->flags |= DDRAW_NO3D;
4967 }
4968
4969 if (FAILED(hr = wined3d_device_create(ddraw->wined3d, WINED3DADAPTER_DEFAULT, device_type,
4970 NULL, 0, DDRAW_STRIDE_ALIGNMENT, &ddraw->device_parent, &ddraw->wined3d_device)))
4971 {
4972 WARN("Failed to create a wined3d device, hr %#x.\n", hr);
4973 wined3d_decref(ddraw->wined3d);
4974 return hr;
4975 }
4976
4977 list_init(&ddraw->surface_list);
4978
4979 return DD_OK;
4980 }
Windows API implementation