?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcrt: Add scheduler_resource_allocation_error class implementation.
[wine.git] / dlls / ddraw / ddraw.c
blob5f90a75c5849da4c5e09df69d43bc24bc624128a
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 if (wined3d_caps.MaxTextureBlendStages > 0xffff)
1424 caps->wMaxTextureBlendStages = 0xffff;
1425 else
1426 caps->wMaxTextureBlendStages = (WORD)wined3d_caps.MaxTextureBlendStages;
1427 if (wined3d_caps.MaxSimultaneousTextures > 0xffff)
1428 caps->wMaxSimultaneousTextures = 0xffff;
1429 else
1430 caps->wMaxSimultaneousTextures = (WORD)wined3d_caps.MaxSimultaneousTextures;
1431
1432 if (wined3d_caps.MaxUserClipPlanes > 0xffff)
1433 caps->wMaxUserClipPlanes = 0xffff;
1434 else
1435 caps->wMaxUserClipPlanes = (WORD)wined3d_caps.MaxUserClipPlanes;
1436 if (wined3d_caps.MaxVertexBlendMatrices > 0xffff)
1437 caps->wMaxVertexBlendMatrices = 0xffff;
1438 else
1439 caps->wMaxVertexBlendMatrices = (WORD)wined3d_caps.MaxVertexBlendMatrices;
1440
1441 caps->deviceGUID = IID_IDirect3DTnLHalDevice;
1442
1443 caps->dwReserved1 = 0;
1444 caps->dwReserved2 = 0;
1445 caps->dwReserved3 = 0;
1446 caps->dwReserved4 = 0;
1447
1448 return DD_OK;
1449 }
1450
1451 /*****************************************************************************
1452 * IDirectDraw7::GetCaps
1453 *
1454 * Returns the drives capabilities
1455 *
1456 * Used for version 1, 2, 4 and 7
1457 *
1458 * Params:
1459 * DriverCaps: Structure to write the Hardware accelerated caps to
1460 * HelCaps: Structure to write the emulation caps to
1461 *
1462 * Returns
1463 * This implementation returns DD_OK only
1464 *
1465 *****************************************************************************/
1466 static HRESULT WINAPI ddraw7_GetCaps(IDirectDraw7 *iface, DDCAPS *DriverCaps, DDCAPS *HELCaps)
1467 {
1468 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1469 DDCAPS caps;
1470 WINED3DCAPS winecaps;
1471 HRESULT hr;
1472 DDSCAPS2 ddscaps = {0, 0, 0, {0}};
1473
1474 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, DriverCaps, HELCaps);
1475
1476 /* One structure must be != NULL */
1477 if (!DriverCaps && !HELCaps)
1478 {
1479 WARN("Invalid parameters.\n");
1480 return DDERR_INVALIDPARAMS;
1481 }
1482
1483 memset(&caps, 0, sizeof(caps));
1484 memset(&winecaps, 0, sizeof(winecaps));
1485 caps.dwSize = sizeof(caps);
1486
1487 wined3d_mutex_lock();
1488 hr = wined3d_device_get_device_caps(ddraw->wined3d_device, &winecaps);
1489 if (FAILED(hr))
1490 {
1491 WARN("Failed to get device caps, %#x.\n", hr);
1492 wined3d_mutex_unlock();
1493 return hr;
1494 }
1495
1496 hr = IDirectDraw7_GetAvailableVidMem(iface, &ddscaps, &caps.dwVidMemTotal, &caps.dwVidMemFree);
1497 if (FAILED(hr))
1498 {
1499 WARN("IDirectDraw7::GetAvailableVidMem failed\n");
1500 wined3d_mutex_unlock();
1501 return hr;
1502 }
1503
1504 hr = IDirectDraw7_GetFourCCCodes(iface, &caps.dwNumFourCCCodes, NULL);
1505 wined3d_mutex_unlock();
1506 if (FAILED(hr))
1507 {
1508 WARN("IDirectDraw7::GetFourCCCodes failed\n");
1509 return hr;
1510 }
1511
1512 caps.dwCaps = winecaps.ddraw_caps.caps;
1513 caps.dwCaps2 = winecaps.ddraw_caps.caps2;
1514 caps.dwCKeyCaps = winecaps.ddraw_caps.color_key_caps;
1515 caps.dwFXCaps = winecaps.ddraw_caps.fx_caps;
1516 caps.dwPalCaps = DDPCAPS_8BIT | DDPCAPS_PRIMARYSURFACE;
1517 caps.ddsCaps.dwCaps = winecaps.ddraw_caps.dds_caps;
1518 caps.dwSVBCaps = winecaps.ddraw_caps.svb_caps;
1519 caps.dwSVBCKeyCaps = winecaps.ddraw_caps.svb_color_key_caps;
1520 caps.dwSVBFXCaps = winecaps.ddraw_caps.svb_fx_caps;
1521 caps.dwVSBCaps = winecaps.ddraw_caps.vsb_caps;
1522 caps.dwVSBCKeyCaps = winecaps.ddraw_caps.vsb_color_key_caps;
1523 caps.dwVSBFXCaps = winecaps.ddraw_caps.vsb_fx_caps;
1524 caps.dwSSBCaps = winecaps.ddraw_caps.ssb_caps;
1525 caps.dwSSBCKeyCaps = winecaps.ddraw_caps.ssb_color_key_caps;
1526 caps.dwSSBFXCaps = winecaps.ddraw_caps.ssb_fx_caps;
1527
1528 caps.dwCaps |= DDCAPS_ALIGNSTRIDE;
1529 caps.dwAlignStrideAlign = DDRAW_STRIDE_ALIGNMENT;
1530
1531 if(DriverCaps)
1532 {
1533 DD_STRUCT_COPY_BYSIZE(DriverCaps, &caps);
1534 if (TRACE_ON(ddraw))
1535 {
1536 TRACE("Driver Caps :\n");
1537 DDRAW_dump_DDCAPS(DriverCaps);
1538 }
1539
1540 }
1541 if(HELCaps)
1542 {
1543 DD_STRUCT_COPY_BYSIZE(HELCaps, &caps);
1544 if (TRACE_ON(ddraw))
1545 {
1546 TRACE("HEL Caps :\n");
1547 DDRAW_dump_DDCAPS(HELCaps);
1548 }
1549 }
1550
1551 return DD_OK;
1552 }
1553
1554 static HRESULT WINAPI ddraw4_GetCaps(IDirectDraw4 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1555 {
1556 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1557
1558 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1559
1560 return ddraw7_GetCaps(&ddraw->IDirectDraw7_iface, driver_caps, hel_caps);
1561 }
1562
1563 static HRESULT WINAPI ddraw2_GetCaps(IDirectDraw2 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1564 {
1565 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1566
1567 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1568
1569 return ddraw7_GetCaps(&ddraw->IDirectDraw7_iface, driver_caps, hel_caps);
1570 }
1571
1572 static HRESULT WINAPI ddraw1_GetCaps(IDirectDraw *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1573 {
1574 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1575
1576 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1577
1578 return ddraw7_GetCaps(&ddraw->IDirectDraw7_iface, driver_caps, hel_caps);
1579 }
1580
1581 /*****************************************************************************
1582 * IDirectDraw7::Compact
1583 *
1584 * No idea what it does, MSDN says it's not implemented.
1585 *
1586 * Returns
1587 * DD_OK, but this is unchecked
1588 *
1589 *****************************************************************************/
1590 static HRESULT WINAPI ddraw7_Compact(IDirectDraw7 *iface)
1591 {
1592 TRACE("iface %p.\n", iface);
1593
1594 return DD_OK;
1595 }
1596
1597 static HRESULT WINAPI ddraw4_Compact(IDirectDraw4 *iface)
1598 {
1599 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1600
1601 TRACE("iface %p.\n", iface);
1602
1603 return ddraw7_Compact(&ddraw->IDirectDraw7_iface);
1604 }
1605
1606 static HRESULT WINAPI ddraw2_Compact(IDirectDraw2 *iface)
1607 {
1608 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1609
1610 TRACE("iface %p.\n", iface);
1611
1612 return ddraw7_Compact(&ddraw->IDirectDraw7_iface);
1613 }
1614
1615 static HRESULT WINAPI ddraw1_Compact(IDirectDraw *iface)
1616 {
1617 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1618
1619 TRACE("iface %p.\n", iface);
1620
1621 return ddraw7_Compact(&ddraw->IDirectDraw7_iface);
1622 }
1623
1624 /*****************************************************************************
1625 * IDirectDraw7::GetDisplayMode
1626 *
1627 * Returns information about the current display mode
1628 *
1629 * Exists in versions 1, 2, 4 and 7
1630 *
1631 * Params:
1632 * DDSD: Address of a surface description structure to write the info to
1633 *
1634 * Returns
1635 * DD_OK
1636 *
1637 *****************************************************************************/
1638 static HRESULT WINAPI ddraw7_GetDisplayMode(IDirectDraw7 *iface, DDSURFACEDESC2 *DDSD)
1639 {
1640 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1641 struct wined3d_display_mode mode;
1642 HRESULT hr;
1643 DWORD Size;
1644
1645 TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
1646
1647 wined3d_mutex_lock();
1648 /* This seems sane */
1649 if (!DDSD)
1650 {
1651 wined3d_mutex_unlock();
1652 return DDERR_INVALIDPARAMS;
1653 }
1654
1655 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
1656 {
1657 ERR("Failed to get display mode, hr %#x.\n", hr);
1658 wined3d_mutex_unlock();
1659 return hr;
1660 }
1661
1662 Size = DDSD->dwSize;
1663 memset(DDSD, 0, Size);
1664
1665 DDSD->dwSize = Size;
1666 DDSD->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
1667 DDSD->dwWidth = mode.width;
1668 DDSD->dwHeight = mode.height;
1669 DDSD->u2.dwRefreshRate = 60;
1670 DDSD->ddsCaps.dwCaps = 0;
1671 DDSD->u4.ddpfPixelFormat.dwSize = sizeof(DDSD->u4.ddpfPixelFormat);
1672 ddrawformat_from_wined3dformat(&DDSD->u4.ddpfPixelFormat, mode.format_id);
1673 DDSD->u1.lPitch = mode.width * DDSD->u4.ddpfPixelFormat.u1.dwRGBBitCount / 8;
1674
1675 if(TRACE_ON(ddraw))
1676 {
1677 TRACE("Returning surface desc :\n");
1678 DDRAW_dump_surface_desc(DDSD);
1679 }
1680
1681 wined3d_mutex_unlock();
1682
1683 return DD_OK;
1684 }
1685
1686 static HRESULT WINAPI ddraw4_GetDisplayMode(IDirectDraw4 *iface, DDSURFACEDESC2 *surface_desc)
1687 {
1688 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1689
1690 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1691
1692 return ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, surface_desc);
1693 }
1694
1695 static HRESULT WINAPI ddraw2_GetDisplayMode(IDirectDraw2 *iface, DDSURFACEDESC *surface_desc)
1696 {
1697 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1698
1699 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1700
1701 /* FIXME: Test sizes, properly convert surface_desc */
1702 return ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
1703 }
1704
1705 static HRESULT WINAPI ddraw1_GetDisplayMode(IDirectDraw *iface, DDSURFACEDESC *surface_desc)
1706 {
1707 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1708
1709 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1710
1711 /* FIXME: Test sizes, properly convert surface_desc */
1712 return ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
1713 }
1714
1715 /*****************************************************************************
1716 * IDirectDraw7::GetFourCCCodes
1717 *
1718 * Returns an array of supported FourCC codes.
1719 *
1720 * Exists in versions 1, 2, 4 and 7
1721 *
1722 * Params:
1723 * NumCodes: Contains the number of Codes that Codes can carry. Returns the number
1724 * of enumerated codes
1725 * Codes: Pointer to an array of DWORDs where the supported codes are written
1726 * to
1727 *
1728 * Returns
1729 * Always returns DD_OK, as it's a stub for now
1730 *
1731 *****************************************************************************/
1732 static HRESULT WINAPI ddraw7_GetFourCCCodes(IDirectDraw7 *iface, DWORD *NumCodes, DWORD *Codes)
1733 {
1734 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1735 static const enum wined3d_format_id formats[] =
1736 {
1737 WINED3DFMT_YUY2, WINED3DFMT_UYVY, WINED3DFMT_YV12,
1738 WINED3DFMT_DXT1, WINED3DFMT_DXT2, WINED3DFMT_DXT3, WINED3DFMT_DXT4, WINED3DFMT_DXT5,
1739 WINED3DFMT_ATI2N, WINED3DFMT_NVHU, WINED3DFMT_NVHS
1740 };
1741 struct wined3d_display_mode mode;
1742 DWORD count = 0, i, outsize;
1743 HRESULT hr;
1744
1745 TRACE("iface %p, codes_count %p, codes %p.\n", iface, NumCodes, Codes);
1746
1747 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
1748 {
1749 ERR("Failed to get display mode, hr %#x.\n", hr);
1750 return hr;
1751 }
1752
1753 outsize = NumCodes && Codes ? *NumCodes : 0;
1754
1755 for (i = 0; i < (sizeof(formats) / sizeof(formats[0])); ++i)
1756 {
1757 if (SUCCEEDED(wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, WINED3D_DEVICE_TYPE_HAL,
1758 mode.format_id, 0, WINED3D_RTYPE_TEXTURE_2D, formats[i])))
1759 {
1760 if (count < outsize)
1761 Codes[count] = formats[i];
1762 ++count;
1763 }
1764 }
1765 if(NumCodes) {
1766 TRACE("Returning %u FourCC codes\n", count);
1767 *NumCodes = count;
1768 }
1769
1770 return DD_OK;
1771 }
1772
1773 static HRESULT WINAPI ddraw4_GetFourCCCodes(IDirectDraw4 *iface, DWORD *codes_count, DWORD *codes)
1774 {
1775 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1776
1777 TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1778
1779 return ddraw7_GetFourCCCodes(&ddraw->IDirectDraw7_iface, codes_count, codes);
1780 }
1781
1782 static HRESULT WINAPI ddraw2_GetFourCCCodes(IDirectDraw2 *iface, DWORD *codes_count, DWORD *codes)
1783 {
1784 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1785
1786 TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1787
1788 return ddraw7_GetFourCCCodes(&ddraw->IDirectDraw7_iface, codes_count, codes);
1789 }
1790
1791 static HRESULT WINAPI ddraw1_GetFourCCCodes(IDirectDraw *iface, DWORD *codes_count, DWORD *codes)
1792 {
1793 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1794
1795 TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1796
1797 return ddraw7_GetFourCCCodes(&ddraw->IDirectDraw7_iface, codes_count, codes);
1798 }
1799
1800 static HRESULT WINAPI ddraw7_GetMonitorFrequency(IDirectDraw7 *iface, DWORD *frequency)
1801 {
1802 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1803 struct wined3d_display_mode mode;
1804 HRESULT hr;
1805
1806 TRACE("iface %p, frequency %p.\n", iface, frequency);
1807
1808 wined3d_mutex_lock();
1809 hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL);
1810 wined3d_mutex_unlock();
1811 if (FAILED(hr))
1812 {
1813 WARN("Failed to get display mode, hr %#x.\n", hr);
1814 return hr;
1815 }
1816
1817 *frequency = mode.refresh_rate;
1818
1819 return DD_OK;
1820 }
1821
1822 static HRESULT WINAPI ddraw4_GetMonitorFrequency(IDirectDraw4 *iface, DWORD *frequency)
1823 {
1824 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1825
1826 TRACE("iface %p, frequency %p.\n", iface, frequency);
1827
1828 return ddraw7_GetMonitorFrequency(&ddraw->IDirectDraw7_iface, frequency);
1829 }
1830
1831 static HRESULT WINAPI ddraw2_GetMonitorFrequency(IDirectDraw2 *iface, DWORD *frequency)
1832 {
1833 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1834
1835 TRACE("iface %p, frequency %p.\n", iface, frequency);
1836
1837 return ddraw7_GetMonitorFrequency(&ddraw->IDirectDraw7_iface, frequency);
1838 }
1839
1840 static HRESULT WINAPI ddraw1_GetMonitorFrequency(IDirectDraw *iface, DWORD *frequency)
1841 {
1842 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1843
1844 TRACE("iface %p, frequency %p.\n", iface, frequency);
1845
1846 return ddraw7_GetMonitorFrequency(&ddraw->IDirectDraw7_iface, frequency);
1847 }
1848
1849 static HRESULT WINAPI ddraw7_GetVerticalBlankStatus(IDirectDraw7 *iface, BOOL *status)
1850 {
1851 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1852 struct wined3d_raster_status raster_status;
1853 HRESULT hr;
1854
1855 TRACE("iface %p, status %p.\n", iface, status);
1856
1857 if(!status)
1858 return DDERR_INVALIDPARAMS;
1859
1860 wined3d_mutex_lock();
1861 hr = wined3d_get_adapter_raster_status(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &raster_status);
1862 wined3d_mutex_unlock();
1863 if (FAILED(hr))
1864 {
1865 WARN("Failed to get raster status, hr %#x.\n", hr);
1866 return hr;
1867 }
1868
1869 *status = raster_status.in_vblank;
1870
1871 return DD_OK;
1872 }
1873
1874 static HRESULT WINAPI ddraw4_GetVerticalBlankStatus(IDirectDraw4 *iface, BOOL *status)
1875 {
1876 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1877
1878 TRACE("iface %p, status %p.\n", iface, status);
1879
1880 return ddraw7_GetVerticalBlankStatus(&ddraw->IDirectDraw7_iface, status);
1881 }
1882
1883 static HRESULT WINAPI ddraw2_GetVerticalBlankStatus(IDirectDraw2 *iface, BOOL *status)
1884 {
1885 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1886
1887 TRACE("iface %p, status %p.\n", iface, status);
1888
1889 return ddraw7_GetVerticalBlankStatus(&ddraw->IDirectDraw7_iface, status);
1890 }
1891
1892 static HRESULT WINAPI ddraw1_GetVerticalBlankStatus(IDirectDraw *iface, BOOL *status)
1893 {
1894 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1895
1896 TRACE("iface %p, status %p.\n", iface, status);
1897
1898 return ddraw7_GetVerticalBlankStatus(&ddraw->IDirectDraw7_iface, status);
1899 }
1900
1901 /*****************************************************************************
1902 * IDirectDraw7::GetAvailableVidMem
1903 *
1904 * Returns the total and free video memory
1905 *
1906 * Params:
1907 * caps: Specifies the memory type asked for
1908 * total: Pointer to a DWORD to be filled with the total memory
1909 * free: Pointer to a DWORD to be filled with the free memory
1910 *
1911 * Returns
1912 * DD_OK on success
1913 * DDERR_INVALIDPARAMS if free and total are NULL
1914 *
1915 *****************************************************************************/
1916 static HRESULT WINAPI ddraw7_GetAvailableVidMem(IDirectDraw7 *iface, DDSCAPS2 *caps, DWORD *total,
1917 DWORD *free)
1918 {
1919 unsigned int framebuffer_size, total_vidmem, free_vidmem;
1920 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1921 struct wined3d_display_mode mode;
1922 HRESULT hr = DD_OK;
1923
1924 TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1925
1926 if (!total && !free)
1927 return DDERR_INVALIDPARAMS;
1928
1929 if (TRACE_ON(ddraw))
1930 {
1931 TRACE("Asked for memory with description: ");
1932 DDRAW_dump_DDSCAPS2(caps);
1933 }
1934 wined3d_mutex_lock();
1935
1936 /* Todo: System memory vs local video memory vs non-local video memory
1937 * The MSDN also mentions differences between texture memory and other
1938 * resources, but that's not important
1939 */
1940
1941 /* Some applications (e.g. 3DMark 2000) assume that the reported amount of
1942 * video memory doesn't include the memory used by the default framebuffer.
1943 */
1944 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
1945 {
1946 WARN("Failed to get display mode, hr %#x.\n", hr);
1947 wined3d_mutex_unlock();
1948 return hr;
1949 }
1950 framebuffer_size = wined3d_calculate_format_pitch(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
1951 mode.format_id, mode.width);
1952 framebuffer_size *= mode.height;
1953
1954 if (free)
1955 {
1956 free_vidmem = wined3d_device_get_available_texture_mem(ddraw->wined3d_device);
1957 *free = framebuffer_size > free_vidmem ? 0 : free_vidmem - framebuffer_size;
1958 TRACE("Free video memory %#x.\n", *free);
1959 }
1960
1961 if (total)
1962 {
1963 struct wined3d_adapter_identifier desc = {0};
1964
1965 hr = wined3d_get_adapter_identifier(ddraw->wined3d, WINED3DADAPTER_DEFAULT, 0, &desc);
1966 total_vidmem = min(UINT_MAX, desc.video_memory);
1967 *total = framebuffer_size > total_vidmem ? 0 : total_vidmem - framebuffer_size;
1968 TRACE("Total video memory %#x.\n", *total);
1969 }
1970
1971 wined3d_mutex_unlock();
1972
1973 return hr;
1974 }
1975
1976 static HRESULT WINAPI ddraw4_GetAvailableVidMem(IDirectDraw4 *iface,
1977 DDSCAPS2 *caps, DWORD *total, DWORD *free)
1978 {
1979 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1980
1981 TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1982
1983 return ddraw7_GetAvailableVidMem(&ddraw->IDirectDraw7_iface, caps, total, free);
1984 }
1985
1986 static HRESULT WINAPI ddraw2_GetAvailableVidMem(IDirectDraw2 *iface,
1987 DDSCAPS *caps, DWORD *total, DWORD *free)
1988 {
1989 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1990 DDSCAPS2 caps2;
1991
1992 TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1993
1994 DDRAW_Convert_DDSCAPS_1_To_2(caps, &caps2);
1995 return ddraw7_GetAvailableVidMem(&ddraw->IDirectDraw7_iface, &caps2, total, free);
1996 }
1997
1998 /*****************************************************************************
1999 * IDirectDraw7::Initialize
2000 *
2001 * Initializes a DirectDraw interface.
2002 *
2003 * Params:
2004 * GUID: Interface identifier. Well, don't know what this is really good
2005 * for
2006 *
2007 * Returns
2008 * Returns DD_OK on the first call,
2009 * DDERR_ALREADYINITIALIZED on repeated calls
2010 *
2011 *****************************************************************************/
2012 static HRESULT WINAPI ddraw7_Initialize(IDirectDraw7 *iface, GUID *guid)
2013 {
2014 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2015
2016 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
2017
2018 if (ddraw->flags & DDRAW_INITIALIZED)
2019 return DDERR_ALREADYINITIALIZED;
2020
2021 /* FIXME: To properly take the GUID into account we should call
2022 * ddraw_init() here instead of in DDRAW_Create(). */
2023 if (guid)
2024 FIXME("Ignoring guid %s.\n", debugstr_guid(guid));
2025
2026 ddraw->flags |= DDRAW_INITIALIZED;
2027 return DD_OK;
2028 }
2029
2030 static HRESULT WINAPI ddraw4_Initialize(IDirectDraw4 *iface, GUID *guid)
2031 {
2032 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2033
2034 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
2035
2036 return ddraw7_Initialize(&ddraw->IDirectDraw7_iface, guid);
2037 }
2038
2039 static HRESULT WINAPI ddraw2_Initialize(IDirectDraw2 *iface, GUID *guid)
2040 {
2041 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2042
2043 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
2044
2045 return ddraw7_Initialize(&ddraw->IDirectDraw7_iface, guid);
2046 }
2047
2048 static HRESULT WINAPI ddraw1_Initialize(IDirectDraw *iface, GUID *guid)
2049 {
2050 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2051
2052 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
2053
2054 return ddraw7_Initialize(&ddraw->IDirectDraw7_iface, guid);
2055 }
2056
2057 static HRESULT WINAPI d3d1_Initialize(IDirect3D *iface, REFIID riid)
2058 {
2059 TRACE("iface %p, riid %s.\n", iface, debugstr_guid(riid));
2060
2061 return DDERR_ALREADYINITIALIZED;
2062 }
2063
2064 /*****************************************************************************
2065 * IDirectDraw7::FlipToGDISurface
2066 *
2067 * "Makes the surface that the GDI writes to the primary surface"
2068 * Looks like some windows specific thing we don't have to care about.
2069 * According to MSDN it permits GDI dialog boxes in FULLSCREEN mode. Good to
2070 * show error boxes ;)
2071 * Well, just return DD_OK.
2072 *
2073 * Returns:
2074 * Always returns DD_OK
2075 *
2076 *****************************************************************************/
2077 static HRESULT WINAPI ddraw7_FlipToGDISurface(IDirectDraw7 *iface)
2078 {
2079 FIXME("iface %p stub!\n", iface);
2080
2081 return DD_OK;
2082 }
2083
2084 static HRESULT WINAPI ddraw4_FlipToGDISurface(IDirectDraw4 *iface)
2085 {
2086 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2087
2088 TRACE("iface %p.\n", iface);
2089
2090 return ddraw7_FlipToGDISurface(&ddraw->IDirectDraw7_iface);
2091 }
2092
2093 static HRESULT WINAPI ddraw2_FlipToGDISurface(IDirectDraw2 *iface)
2094 {
2095 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2096
2097 TRACE("iface %p.\n", iface);
2098
2099 return ddraw7_FlipToGDISurface(&ddraw->IDirectDraw7_iface);
2100 }
2101
2102 static HRESULT WINAPI ddraw1_FlipToGDISurface(IDirectDraw *iface)
2103 {
2104 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2105
2106 TRACE("iface %p.\n", iface);
2107
2108 return ddraw7_FlipToGDISurface(&ddraw->IDirectDraw7_iface);
2109 }
2110
2111 /*****************************************************************************
2112 * IDirectDraw7::WaitForVerticalBlank
2113 *
2114 * This method allows applications to get in sync with the vertical blank
2115 * interval.
2116 * The wormhole demo in the DirectX 7 sdk uses this call, and it doesn't
2117 * redraw the screen, most likely because of this stub
2118 *
2119 * Parameters:
2120 * Flags: one of DDWAITVB_BLOCKBEGIN, DDWAITVB_BLOCKBEGINEVENT
2121 * or DDWAITVB_BLOCKEND
2122 * h: Not used, according to MSDN
2123 *
2124 * Returns:
2125 * Always returns DD_OK
2126 *
2127 *****************************************************************************/
2128 static HRESULT WINAPI ddraw7_WaitForVerticalBlank(IDirectDraw7 *iface, DWORD Flags, HANDLE event)
2129 {
2130 static BOOL hide;
2131
2132 TRACE("iface %p, flags %#x, event %p.\n", iface, Flags, event);
2133
2134 /* This function is called often, so print the fixme only once */
2135 if(!hide)
2136 {
2137 FIXME("iface %p, flags %#x, event %p stub!\n", iface, Flags, event);
2138 hide = TRUE;
2139 }
2140
2141 /* MSDN says DDWAITVB_BLOCKBEGINEVENT is not supported */
2142 if(Flags & DDWAITVB_BLOCKBEGINEVENT)
2143 return DDERR_UNSUPPORTED; /* unchecked */
2144
2145 return DD_OK;
2146 }
2147
2148 static HRESULT WINAPI ddraw4_WaitForVerticalBlank(IDirectDraw4 *iface, DWORD flags, HANDLE event)
2149 {
2150 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2151
2152 TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
2153
2154 return ddraw7_WaitForVerticalBlank(&ddraw->IDirectDraw7_iface, flags, event);
2155 }
2156
2157 static HRESULT WINAPI ddraw2_WaitForVerticalBlank(IDirectDraw2 *iface, DWORD flags, HANDLE event)
2158 {
2159 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2160
2161 TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
2162
2163 return ddraw7_WaitForVerticalBlank(&ddraw->IDirectDraw7_iface, flags, event);
2164 }
2165
2166 static HRESULT WINAPI ddraw1_WaitForVerticalBlank(IDirectDraw *iface, DWORD flags, HANDLE event)
2167 {
2168 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2169
2170 TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
2171
2172 return ddraw7_WaitForVerticalBlank(&ddraw->IDirectDraw7_iface, flags, event);
2173 }
2174
2175 static HRESULT WINAPI ddraw7_GetScanLine(IDirectDraw7 *iface, DWORD *Scanline)
2176 {
2177 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2178 struct wined3d_raster_status raster_status;
2179 HRESULT hr;
2180
2181 TRACE("iface %p, line %p.\n", iface, Scanline);
2182
2183 wined3d_mutex_lock();
2184 hr = wined3d_get_adapter_raster_status(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &raster_status);
2185 wined3d_mutex_unlock();
2186 if (FAILED(hr))
2187 {
2188 WARN("Failed to get raster status, hr %#x.\n", hr);
2189 return hr;
2190 }
2191
2192 *Scanline = raster_status.scan_line;
2193
2194 if (raster_status.in_vblank)
2195 return DDERR_VERTICALBLANKINPROGRESS;
2196
2197 return DD_OK;
2198 }
2199
2200 static HRESULT WINAPI ddraw4_GetScanLine(IDirectDraw4 *iface, DWORD *line)
2201 {
2202 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2203
2204 TRACE("iface %p, line %p.\n", iface, line);
2205
2206 return ddraw7_GetScanLine(&ddraw->IDirectDraw7_iface, line);
2207 }
2208
2209 static HRESULT WINAPI ddraw2_GetScanLine(IDirectDraw2 *iface, DWORD *line)
2210 {
2211 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2212
2213 TRACE("iface %p, line %p.\n", iface, line);
2214
2215 return ddraw7_GetScanLine(&ddraw->IDirectDraw7_iface, line);
2216 }
2217
2218 static HRESULT WINAPI ddraw1_GetScanLine(IDirectDraw *iface, DWORD *line)
2219 {
2220 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2221
2222 TRACE("iface %p, line %p.\n", iface, line);
2223
2224 return ddraw7_GetScanLine(&ddraw->IDirectDraw7_iface, line);
2225 }
2226
2227 static HRESULT WINAPI ddraw7_TestCooperativeLevel(IDirectDraw7 *iface)
2228 {
2229 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2230
2231 TRACE("iface %p.\n", iface);
2232
2233 return ddraw->device_state == DDRAW_DEVICE_STATE_LOST ? DDERR_NOEXCLUSIVEMODE : DD_OK;
2234 }
2235
2236 static HRESULT WINAPI ddraw4_TestCooperativeLevel(IDirectDraw4 *iface)
2237 {
2238 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2239
2240 TRACE("iface %p.\n", iface);
2241
2242 return ddraw7_TestCooperativeLevel(&ddraw->IDirectDraw7_iface);
2243 }
2244
2245 /*****************************************************************************
2246 * IDirectDraw7::GetGDISurface
2247 *
2248 * Returns the surface that GDI is treating as the primary surface.
2249 * For Wine this is the front buffer
2250 *
2251 * Params:
2252 * GDISurface: Address to write the surface pointer to
2253 *
2254 * Returns:
2255 * DD_OK if the surface was found
2256 * DDERR_NOTFOUND if the GDI surface wasn't found
2257 *
2258 *****************************************************************************/
2259 static HRESULT WINAPI ddraw7_GetGDISurface(IDirectDraw7 *iface, IDirectDrawSurface7 **GDISurface)
2260 {
2261 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2262
2263 TRACE("iface %p, surface %p.\n", iface, GDISurface);
2264
2265 wined3d_mutex_lock();
2266
2267 if (!(*GDISurface = &ddraw->primary->IDirectDrawSurface7_iface))
2268 {
2269 WARN("Primary not created yet.\n");
2270 wined3d_mutex_unlock();
2271 return DDERR_NOTFOUND;
2272 }
2273 IDirectDrawSurface7_AddRef(*GDISurface);
2274
2275 wined3d_mutex_unlock();
2276
2277 return DD_OK;
2278 }
2279
2280 static HRESULT WINAPI ddraw4_GetGDISurface(IDirectDraw4 *iface, IDirectDrawSurface4 **surface)
2281 {
2282 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2283 struct ddraw_surface *surface_impl;
2284 IDirectDrawSurface7 *surface7;
2285 HRESULT hr;
2286
2287 TRACE("iface %p, surface %p.\n", iface, surface);
2288
2289 hr = ddraw7_GetGDISurface(&ddraw->IDirectDraw7_iface, &surface7);
2290 if (FAILED(hr))
2291 {
2292 *surface = NULL;
2293 return hr;
2294 }
2295 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2296 *surface = &surface_impl->IDirectDrawSurface4_iface;
2297 IDirectDrawSurface4_AddRef(*surface);
2298 IDirectDrawSurface7_Release(surface7);
2299
2300 return hr;
2301 }
2302
2303 static HRESULT WINAPI ddraw2_GetGDISurface(IDirectDraw2 *iface, IDirectDrawSurface **surface)
2304 {
2305 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2306 struct ddraw_surface *surface_impl;
2307 IDirectDrawSurface7 *surface7;
2308 HRESULT hr;
2309
2310 TRACE("iface %p, surface %p.\n", iface, surface);
2311
2312 hr = ddraw7_GetGDISurface(&ddraw->IDirectDraw7_iface, &surface7);
2313 if (FAILED(hr))
2314 {
2315 *surface = NULL;
2316 return hr;
2317 }
2318 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2319 *surface = &surface_impl->IDirectDrawSurface_iface;
2320 IDirectDrawSurface_AddRef(*surface);
2321 IDirectDrawSurface7_Release(surface7);
2322
2323 return hr;
2324 }
2325
2326 static HRESULT WINAPI ddraw1_GetGDISurface(IDirectDraw *iface, IDirectDrawSurface **surface)
2327 {
2328 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2329 struct ddraw_surface *surface_impl;
2330 IDirectDrawSurface7 *surface7;
2331 HRESULT hr;
2332
2333 TRACE("iface %p, surface %p.\n", iface, surface);
2334
2335 hr = ddraw7_GetGDISurface(&ddraw->IDirectDraw7_iface, &surface7);
2336 if (FAILED(hr))
2337 {
2338 *surface = NULL;
2339 return hr;
2340 }
2341 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2342 *surface = &surface_impl->IDirectDrawSurface_iface;
2343 IDirectDrawSurface_AddRef(*surface);
2344 IDirectDrawSurface7_Release(surface7);
2345
2346 return hr;
2347 }
2348
2349 struct displaymodescallback_context
2350 {
2351 LPDDENUMMODESCALLBACK func;
2352 void *context;
2353 };
2354
2355 static HRESULT CALLBACK EnumDisplayModesCallbackThunk(DDSURFACEDESC2 *surface_desc, void *context)
2356 {
2357 struct displaymodescallback_context *cbcontext = context;
2358 DDSURFACEDESC desc;
2359
2360 DDSD2_to_DDSD(surface_desc, &desc);
2361 return cbcontext->func(&desc, cbcontext->context);
2362 }
2363
2364 /*****************************************************************************
2365 * IDirectDraw7::EnumDisplayModes
2366 *
2367 * Enumerates the supported Display modes. The modes can be filtered with
2368 * the DDSD parameter.
2369 *
2370 * Params:
2371 * Flags: can be DDEDM_REFRESHRATES and DDEDM_STANDARDVGAMODES. For old ddraw
2372 * versions (3 and older?) this is reserved and must be 0.
2373 * DDSD: Surface description to filter the modes
2374 * Context: Pointer passed back to the callback function
2375 * cb: Application-provided callback function
2376 *
2377 * Returns:
2378 * DD_OK on success
2379 * DDERR_INVALIDPARAMS if the callback wasn't set
2380 *
2381 *****************************************************************************/
2382 static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags,
2383 DDSURFACEDESC2 *DDSD, void *Context, LPDDENUMMODESCALLBACK2 cb)
2384 {
2385 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2386 struct wined3d_display_mode *enum_modes = NULL;
2387 struct wined3d_display_mode mode;
2388 unsigned int modenum, fmt;
2389 DDSURFACEDESC2 callback_sd;
2390 unsigned enum_mode_count = 0, enum_mode_array_size = 16;
2391 DDPIXELFORMAT pixelformat;
2392
2393 static const enum wined3d_format_id checkFormatList[] =
2394 {
2395 WINED3DFMT_B8G8R8X8_UNORM,
2396 WINED3DFMT_B5G6R5_UNORM,
2397 WINED3DFMT_P8_UINT,
2398 };
2399
2400 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2401 iface, Flags, DDSD, Context, cb);
2402
2403 if (!cb)
2404 return DDERR_INVALIDPARAMS;
2405
2406 enum_modes = HeapAlloc(GetProcessHeap(), 0, sizeof(*enum_modes) * enum_mode_array_size);
2407 if (!enum_modes) return DDERR_OUTOFMEMORY;
2408
2409 wined3d_mutex_lock();
2410
2411 pixelformat.dwSize = sizeof(pixelformat);
2412 for(fmt = 0; fmt < (sizeof(checkFormatList) / sizeof(checkFormatList[0])); fmt++)
2413 {
2414 modenum = 0;
2415 while (wined3d_enum_adapter_modes(ddraw->wined3d, WINED3DADAPTER_DEFAULT, checkFormatList[fmt],
2416 WINED3D_SCANLINE_ORDERING_UNKNOWN, modenum++, &mode) == WINED3D_OK)
2417 {
2418 BOOL found = FALSE;
2419 unsigned i;
2420
2421 ddrawformat_from_wined3dformat(&pixelformat, mode.format_id);
2422 if (DDSD)
2423 {
2424 if (DDSD->dwFlags & DDSD_WIDTH && mode.width != DDSD->dwWidth)
2425 continue;
2426 if (DDSD->dwFlags & DDSD_HEIGHT && mode.height != DDSD->dwHeight)
2427 continue;
2428 if (DDSD->dwFlags & DDSD_REFRESHRATE && mode.refresh_rate != DDSD->u2.dwRefreshRate)
2429 continue;
2430 if (DDSD->dwFlags & DDSD_PIXELFORMAT
2431 && pixelformat.u1.dwRGBBitCount != DDSD->u4.ddpfPixelFormat.u1.dwRGBBitCount)
2432 continue;
2433 }
2434
2435 /* DX docs state EnumDisplayMode should return only unique modes */
2436 for (i = 0; i < enum_mode_count; i++)
2437 {
2438 if (enum_modes[i].width == mode.width && enum_modes[i].height == mode.height
2439 && enum_modes[i].format_id == mode.format_id
2440 && (enum_modes[i].refresh_rate == mode.refresh_rate || !(Flags & DDEDM_REFRESHRATES)))
2441 {
2442 found = TRUE;
2443 break;
2444 }
2445 }
2446 if(found) continue;
2447
2448 memset(&callback_sd, 0, sizeof(callback_sd));
2449 callback_sd.dwSize = sizeof(callback_sd);
2450 callback_sd.u4.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
2451
2452 callback_sd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|DDSD_PITCH|DDSD_REFRESHRATE;
2453 if (Flags & DDEDM_REFRESHRATES)
2454 callback_sd.u2.dwRefreshRate = mode.refresh_rate;
2455
2456 callback_sd.dwWidth = mode.width;
2457 callback_sd.dwHeight = mode.height;
2458
2459 callback_sd.u4.ddpfPixelFormat=pixelformat;
2460
2461 /* Calc pitch and DWORD align like MSDN says */
2462 callback_sd.u1.lPitch = (callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount / 8) * mode.width;
2463 callback_sd.u1.lPitch = (callback_sd.u1.lPitch + 3) & ~3;
2464
2465 TRACE("Enumerating %dx%dx%d @%d\n", callback_sd.dwWidth, callback_sd.dwHeight, callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount,
2466 callback_sd.u2.dwRefreshRate);
2467
2468 if(cb(&callback_sd, Context) == DDENUMRET_CANCEL)
2469 {
2470 TRACE("Application asked to terminate the enumeration\n");
2471 HeapFree(GetProcessHeap(), 0, enum_modes);
2472 wined3d_mutex_unlock();
2473 return DD_OK;
2474 }
2475
2476 if (enum_mode_count == enum_mode_array_size)
2477 {
2478 struct wined3d_display_mode *new_enum_modes;
2479
2480 enum_mode_array_size *= 2;
2481 new_enum_modes = HeapReAlloc(GetProcessHeap(), 0, enum_modes,
2482 sizeof(*new_enum_modes) * enum_mode_array_size);
2483 if (!new_enum_modes)
2484 {
2485 HeapFree(GetProcessHeap(), 0, enum_modes);
2486 wined3d_mutex_unlock();
2487 return DDERR_OUTOFMEMORY;
2488 }
2489
2490 enum_modes = new_enum_modes;
2491 }
2492 enum_modes[enum_mode_count++] = mode;
2493 }
2494 }
2495
2496 TRACE("End of enumeration\n");
2497 HeapFree(GetProcessHeap(), 0, enum_modes);
2498 wined3d_mutex_unlock();
2499
2500 return DD_OK;
2501 }
2502
2503 static HRESULT WINAPI ddraw4_EnumDisplayModes(IDirectDraw4 *iface, DWORD flags,
2504 DDSURFACEDESC2 *surface_desc, void *context, LPDDENUMMODESCALLBACK2 callback)
2505 {
2506 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2507
2508 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2509 iface, flags, surface_desc, context, callback);
2510
2511 return ddraw7_EnumDisplayModes(&ddraw->IDirectDraw7_iface, flags, surface_desc, context, callback);
2512 }
2513
2514 static HRESULT WINAPI ddraw2_EnumDisplayModes(IDirectDraw2 *iface, DWORD flags,
2515 DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2516 {
2517 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2518 struct displaymodescallback_context cbcontext;
2519 DDSURFACEDESC2 surface_desc2;
2520
2521 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2522 iface, flags, surface_desc, context, callback);
2523
2524 cbcontext.func = callback;
2525 cbcontext.context = context;
2526
2527 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
2528 return ddraw7_EnumDisplayModes(&ddraw->IDirectDraw7_iface, flags,
2529 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumDisplayModesCallbackThunk);
2530 }
2531
2532 static HRESULT WINAPI ddraw1_EnumDisplayModes(IDirectDraw *iface, DWORD flags,
2533 DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2534 {
2535 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2536 struct displaymodescallback_context cbcontext;
2537 DDSURFACEDESC2 surface_desc2;
2538
2539 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2540 iface, flags, surface_desc, context, callback);
2541
2542 cbcontext.func = callback;
2543 cbcontext.context = context;
2544
2545 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
2546 return ddraw7_EnumDisplayModes(&ddraw->IDirectDraw7_iface, flags,
2547 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumDisplayModesCallbackThunk);
2548 }
2549
2550 /*****************************************************************************
2551 * IDirectDraw7::EvaluateMode
2552 *
2553 * Used with IDirectDraw7::StartModeTest to test video modes.
2554 * EvaluateMode is used to pass or fail a mode, and continue with the next
2555 * mode
2556 *
2557 * Params:
2558 * Flags: DDEM_MODEPASSED or DDEM_MODEFAILED
2559 * Timeout: Returns the amount of seconds left before the mode would have
2560 * been failed automatically
2561 *
2562 * Returns:
2563 * This implementation always DD_OK, because it's a stub
2564 *
2565 *****************************************************************************/
2566 static HRESULT WINAPI ddraw7_EvaluateMode(IDirectDraw7 *iface, DWORD Flags, DWORD *Timeout)
2567 {
2568 FIXME("iface %p, flags %#x, timeout %p stub!\n", iface, Flags, Timeout);
2569
2570 /* When implementing this, implement it in WineD3D */
2571
2572 return DD_OK;
2573 }
2574
2575 /*****************************************************************************
2576 * IDirectDraw7::GetDeviceIdentifier
2577 *
2578 * Returns the device identifier, which gives information about the driver
2579 * Our device identifier is defined at the beginning of this file.
2580 *
2581 * Params:
2582 * DDDI: Address for the returned structure
2583 * Flags: Can be DDGDI_GETHOSTIDENTIFIER
2584 *
2585 * Returns:
2586 * On success it returns DD_OK
2587 * DDERR_INVALIDPARAMS if DDDI is NULL
2588 *
2589 *****************************************************************************/
2590 static HRESULT WINAPI ddraw7_GetDeviceIdentifier(IDirectDraw7 *iface,
2591 DDDEVICEIDENTIFIER2 *DDDI, DWORD Flags)
2592 {
2593 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2594 struct wined3d_adapter_identifier adapter_id;
2595 HRESULT hr = S_OK;
2596
2597 TRACE("iface %p, device_identifier %p, flags %#x.\n", iface, DDDI, Flags);
2598
2599 if (!DDDI)
2600 return DDERR_INVALIDPARAMS;
2601
2602 if (Flags & DDGDI_GETHOSTIDENTIFIER)
2603 {
2604 /* The DDGDI_GETHOSTIDENTIFIER returns the information about the 2D
2605 * host adapter, if there's a secondary 3D adapter. This doesn't apply
2606 * to any modern hardware, nor is it interesting for Wine, so ignore it.
2607 * Size of DDDEVICEIDENTIFIER2 may be aligned to 8 bytes and thus 4
2608 * bytes too long. So only copy the relevant part of the structure
2609 */
2610
2611 memcpy(DDDI, &deviceidentifier, FIELD_OFFSET(DDDEVICEIDENTIFIER2, dwWHQLLevel) + sizeof(DWORD));
2612 return DD_OK;
2613 }
2614
2615 /* Drakan: Order of the Flame expects accurate D3D device information from ddraw */
2616 adapter_id.driver = DDDI->szDriver;
2617 adapter_id.driver_size = sizeof(DDDI->szDriver);
2618 adapter_id.description = DDDI->szDescription;
2619 adapter_id.description_size = sizeof(DDDI->szDescription);
2620 adapter_id.device_name_size = 0;
2621 wined3d_mutex_lock();
2622 hr = wined3d_get_adapter_identifier(ddraw->wined3d, WINED3DADAPTER_DEFAULT, 0x0, &adapter_id);
2623 wined3d_mutex_unlock();
2624 if (FAILED(hr)) return hr;
2625
2626 DDDI->liDriverVersion = adapter_id.driver_version;
2627 DDDI->dwVendorId = adapter_id.vendor_id;
2628 DDDI->dwDeviceId = adapter_id.device_id;
2629 DDDI->dwSubSysId = adapter_id.subsystem_id;
2630 DDDI->dwRevision = adapter_id.revision;
2631 DDDI->guidDeviceIdentifier = adapter_id.device_identifier;
2632 DDDI->dwWHQLLevel = adapter_id.whql_level;
2633 return DD_OK;
2634 }
2635
2636 static HRESULT WINAPI ddraw4_GetDeviceIdentifier(IDirectDraw4 *iface,
2637 DDDEVICEIDENTIFIER *identifier, DWORD flags)
2638 {
2639 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2640 DDDEVICEIDENTIFIER2 identifier2;
2641 HRESULT hr;
2642
2643 TRACE("iface %p, identifier %p, flags %#x.\n", iface, identifier, flags);
2644
2645 hr = ddraw7_GetDeviceIdentifier(&ddraw->IDirectDraw7_iface, &identifier2, flags);
2646 DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1(&identifier2, identifier);
2647
2648 return hr;
2649 }
2650
2651 /*****************************************************************************
2652 * IDirectDraw7::GetSurfaceFromDC
2653 *
2654 * Returns the Surface for a GDI device context handle.
2655 * Is this related to IDirectDrawSurface::GetDC ???
2656 *
2657 * Params:
2658 * hdc: hdc to return the surface for
2659 * Surface: Address to write the surface pointer to
2660 *
2661 * Returns:
2662 * Always returns DD_OK because it's a stub
2663 *
2664 *****************************************************************************/
2665 static HRESULT WINAPI ddraw7_GetSurfaceFromDC(IDirectDraw7 *iface,
2666 HDC dc, IDirectDrawSurface7 **surface)
2667 {
2668 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2669 struct ddraw_surface *surface_impl;
2670
2671 TRACE("iface %p, dc %p, surface %p.\n", iface, dc, surface);
2672
2673 if (!surface)
2674 return E_INVALIDARG;
2675
2676 if (!dc)
2677 goto done;
2678
2679 wined3d_mutex_lock();
2680 LIST_FOR_EACH_ENTRY(surface_impl, &ddraw->surface_list, struct ddraw_surface, surface_list_entry)
2681 {
2682 if (surface_impl->dc != dc)
2683 continue;
2684
2685 TRACE("Found surface %p for dc %p.\n", surface_impl, dc);
2686 *surface = &surface_impl->IDirectDrawSurface7_iface;
2687 IDirectDrawSurface7_AddRef(*surface);
2688 wined3d_mutex_unlock();
2689 return DD_OK;
2690 }
2691 wined3d_mutex_unlock();
2692
2693 done:
2694 TRACE("No surface found for dc %p.\n", dc);
2695 *surface = NULL;
2696 return DDERR_NOTFOUND;
2697 }
2698
2699 static HRESULT WINAPI ddraw4_GetSurfaceFromDC(IDirectDraw4 *iface, HDC dc,
2700 IDirectDrawSurface4 **surface)
2701 {
2702 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2703 struct ddraw_surface *surface_impl;
2704 IDirectDrawSurface7 *surface7;
2705 HRESULT hr;
2706
2707 TRACE("iface %p, dc %p, surface %p.\n", iface, dc, surface);
2708
2709 if (!surface) return E_INVALIDARG;
2710
2711 hr = ddraw7_GetSurfaceFromDC(&ddraw->IDirectDraw7_iface, dc, &surface7);
2712 if (FAILED(hr))
2713 {
2714 *surface = NULL;
2715 return hr;
2716 }
2717 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2718 /* Tests say this is true */
2719 *surface = (IDirectDrawSurface4 *)&surface_impl->IDirectDrawSurface_iface;
2720 IDirectDrawSurface_AddRef(&surface_impl->IDirectDrawSurface_iface);
2721 IDirectDrawSurface7_Release(surface7);
2722
2723 return hr;
2724 }
2725
2726 static HRESULT CALLBACK restore_callback(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *desc, void *context)
2727 {
2728 IDirectDrawSurface_Restore(surface);
2729 IDirectDrawSurface_Release(surface);
2730
2731 return DDENUMRET_OK;
2732 }
2733
2734 static HRESULT WINAPI ddraw7_RestoreAllSurfaces(IDirectDraw7 *iface)
2735 {
2736 TRACE("iface %p.\n", iface);
2737
2738 return IDirectDraw7_EnumSurfaces(iface, DDENUMSURFACES_ALL | DDENUMSURFACES_DOESEXIST,
2739 NULL, NULL, restore_callback);
2740 }
2741
2742 static HRESULT WINAPI ddraw4_RestoreAllSurfaces(IDirectDraw4 *iface)
2743 {
2744 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2745
2746 TRACE("iface %p.\n", iface);
2747
2748 return ddraw7_RestoreAllSurfaces(&ddraw->IDirectDraw7_iface);
2749 }
2750
2751 /*****************************************************************************
2752 * IDirectDraw7::StartModeTest
2753 *
2754 * Tests the specified video modes to update the system registry with
2755 * refresh rate information. StartModeTest starts the mode test,
2756 * EvaluateMode is used to fail or pass a mode. If EvaluateMode
2757 * isn't called within 15 seconds, the mode is failed automatically
2758 *
2759 * As refresh rates are handled by the X server, I don't think this
2760 * Method is important
2761 *
2762 * Params:
2763 * Modes: An array of mode specifications
2764 * NumModes: The number of modes in Modes
2765 * Flags: Some flags...
2766 *
2767 * Returns:
2768 * Returns DDERR_TESTFINISHED if flags contains DDSMT_ISTESTREQUIRED,
2769 * if no modes are passed, DDERR_INVALIDPARAMS is returned,
2770 * otherwise DD_OK
2771 *
2772 *****************************************************************************/
2773 static HRESULT WINAPI ddraw7_StartModeTest(IDirectDraw7 *iface, SIZE *Modes, DWORD NumModes, DWORD Flags)
2774 {
2775 FIXME("iface %p, modes %p, mode_count %u, flags %#x partial stub!\n",
2776 iface, Modes, NumModes, Flags);
2777
2778 /* This looks sane */
2779 if( (!Modes) || (NumModes == 0) ) return DDERR_INVALIDPARAMS;
2780
2781 /* DDSMT_ISTESTREQUIRED asks if a mode test is necessary.
2782 * As it is not, DDERR_TESTFINISHED is returned
2783 * (hopefully that's correct
2784 *
2785 if(Flags & DDSMT_ISTESTREQUIRED) return DDERR_TESTFINISHED;
2786 * well, that value doesn't (yet) exist in the wine headers, so ignore it
2787 */
2788
2789 return DD_OK;
2790 }
2791
2792 static HRESULT WINAPI ddraw7_CreateSurface(IDirectDraw7 *iface, DDSURFACEDESC2 *surface_desc,
2793 IDirectDrawSurface7 **surface, IUnknown *outer_unknown)
2794 {
2795 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2796 struct ddraw_surface *impl;
2797 HRESULT hr;
2798
2799 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2800 iface, surface_desc, surface, outer_unknown);
2801
2802 wined3d_mutex_lock();
2803
2804 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
2805 {
2806 WARN("Cooperative level not set.\n");
2807 wined3d_mutex_unlock();
2808 return DDERR_NOCOOPERATIVELEVELSET;
2809 }
2810
2811 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC2))
2812 {
2813 WARN("Application supplied invalid surface descriptor\n");
2814 wined3d_mutex_unlock();
2815 return DDERR_INVALIDPARAMS;
2816 }
2817
2818 __TRY
2819 {
2820 *surface = NULL;
2821 }
2822 __EXCEPT_PAGE_FAULT
2823 {
2824 WARN("Surface pointer %p is invalid.\n", surface);
2825 wined3d_mutex_unlock();
2826 return DDERR_INVALIDPARAMS;
2827 }
2828 __ENDTRY;
2829
2830 if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
2831 {
2832 if (TRACE_ON(ddraw))
2833 {
2834 TRACE(" (%p) Requesting surface desc :\n", iface);
2835 DDRAW_dump_surface_desc(surface_desc);
2836 }
2837
2838 WARN("Application tried to create an explicit front or back buffer\n");
2839 wined3d_mutex_unlock();
2840 return DDERR_INVALIDCAPS;
2841 }
2842
2843 hr = ddraw_surface_create(ddraw, surface_desc, &impl, outer_unknown, 7);
2844 wined3d_mutex_unlock();
2845 if (FAILED(hr))
2846 return hr;
2847
2848 *surface = &impl->IDirectDrawSurface7_iface;
2849 IDirectDraw7_AddRef(iface);
2850 impl->ifaceToRelease = (IUnknown *)iface;
2851
2852 return hr;
2853 }
2854
2855 static HRESULT WINAPI ddraw4_CreateSurface(IDirectDraw4 *iface,
2856 DDSURFACEDESC2 *surface_desc, IDirectDrawSurface4 **surface, IUnknown *outer_unknown)
2857 {
2858 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2859 struct ddraw_surface *impl;
2860 HRESULT hr;
2861
2862 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2863 iface, surface_desc, surface, outer_unknown);
2864
2865 wined3d_mutex_lock();
2866
2867 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
2868 {
2869 WARN("Cooperative level not set.\n");
2870 wined3d_mutex_unlock();
2871 return DDERR_NOCOOPERATIVELEVELSET;
2872 }
2873
2874 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC2))
2875 {
2876 WARN("Application supplied invalid surface descriptor\n");
2877 wined3d_mutex_unlock();
2878 return DDERR_INVALIDPARAMS;
2879 }
2880
2881 __TRY
2882 {
2883 *surface = NULL;
2884 }
2885 __EXCEPT_PAGE_FAULT
2886 {
2887 WARN("Surface pointer %p is invalid.\n", surface);
2888 wined3d_mutex_unlock();
2889 return DDERR_INVALIDPARAMS;
2890 }
2891 __ENDTRY;
2892
2893 if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
2894 {
2895 if (TRACE_ON(ddraw))
2896 {
2897 TRACE(" (%p) Requesting surface desc :\n", iface);
2898 DDRAW_dump_surface_desc(surface_desc);
2899 }
2900
2901 WARN("Application tried to create an explicit front or back buffer\n");
2902 wined3d_mutex_unlock();
2903 return DDERR_INVALIDCAPS;
2904 }
2905
2906 hr = ddraw_surface_create(ddraw, surface_desc, &impl, outer_unknown, 4);
2907 wined3d_mutex_unlock();
2908 if (FAILED(hr))
2909 return hr;
2910
2911 *surface = &impl->IDirectDrawSurface4_iface;
2912 IDirectDraw4_AddRef(iface);
2913 impl->ifaceToRelease = (IUnknown *)iface;
2914
2915 return hr;
2916 }
2917
2918 static HRESULT WINAPI ddraw2_CreateSurface(IDirectDraw2 *iface,
2919 DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
2920 {
2921 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2922 struct ddraw_surface *impl;
2923 HRESULT hr;
2924 DDSURFACEDESC2 surface_desc2;
2925
2926 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2927 iface, surface_desc, surface, outer_unknown);
2928
2929 wined3d_mutex_lock();
2930
2931 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
2932 {
2933 WARN("Cooperative level not set.\n");
2934 wined3d_mutex_unlock();
2935 return DDERR_NOCOOPERATIVELEVELSET;
2936 }
2937
2938 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
2939 {
2940 WARN("Application supplied invalid surface descriptor\n");
2941 wined3d_mutex_unlock();
2942 return DDERR_INVALIDPARAMS;
2943 }
2944
2945 __TRY
2946 {
2947 *surface = NULL;
2948 }
2949 __EXCEPT_PAGE_FAULT
2950 {
2951 WARN("Surface pointer %p is invalid.\n", surface);
2952 wined3d_mutex_unlock();
2953 return DDERR_INVALIDPARAMS;
2954 }
2955 __ENDTRY;
2956
2957 DDSD_to_DDSD2(surface_desc, &surface_desc2);
2958 if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
2959 {
2960 if (TRACE_ON(ddraw))
2961 {
2962 TRACE(" (%p) Requesting surface desc :\n", iface);
2963 DDRAW_dump_surface_desc((DDSURFACEDESC2 *)surface_desc);
2964 }
2965
2966 WARN("Application tried to create an explicit front or back buffer\n");
2967 wined3d_mutex_unlock();
2968 return DDERR_INVALIDCAPS;
2969 }
2970
2971 hr = ddraw_surface_create(ddraw, &surface_desc2, &impl, outer_unknown, 2);
2972 wined3d_mutex_unlock();
2973 if (FAILED(hr))
2974 return hr;
2975
2976 *surface = &impl->IDirectDrawSurface_iface;
2977 impl->ifaceToRelease = NULL;
2978
2979 return hr;
2980 }
2981
2982 static HRESULT WINAPI ddraw1_CreateSurface(IDirectDraw *iface,
2983 DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
2984 {
2985 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2986 struct ddraw_surface *impl;
2987 HRESULT hr;
2988 DDSURFACEDESC2 surface_desc2;
2989
2990 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2991 iface, surface_desc, surface, outer_unknown);
2992
2993 wined3d_mutex_lock();
2994
2995 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
2996 {
2997 WARN("Cooperative level not set.\n");
2998 wined3d_mutex_unlock();
2999 return DDERR_NOCOOPERATIVELEVELSET;
3000 }
3001
3002 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
3003 {
3004 WARN("Application supplied invalid surface descriptor\n");
3005 wined3d_mutex_unlock();
3006 return DDERR_INVALIDPARAMS;
3007 }
3008
3009 __TRY
3010 {
3011 *surface = NULL;
3012 }
3013 __EXCEPT_PAGE_FAULT
3014 {
3015 WARN("Surface pointer %p is invalid.\n", surface);
3016 wined3d_mutex_unlock();
3017 return DDERR_INVALIDPARAMS;
3018 }
3019 __ENDTRY;
3020
3021 if ((surface_desc->ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_BACKBUFFER))
3022 == (DDSCAPS_PRIMARYSURFACE | DDSCAPS_BACKBUFFER)
3023 || (surface_desc->ddsCaps.dwCaps & (DDSCAPS_FLIP | DDSCAPS_FRONTBUFFER))
3024 == ((DDSCAPS_FLIP | DDSCAPS_FRONTBUFFER)))
3025 {
3026 WARN("Application tried to create an explicit front or back buffer.\n");
3027 wined3d_mutex_unlock();
3028 return DDERR_INVALIDCAPS;
3029 }
3030
3031 DDSD_to_DDSD2(surface_desc, &surface_desc2);
3032 hr = ddraw_surface_create(ddraw, &surface_desc2, &impl, outer_unknown, 1);
3033 wined3d_mutex_unlock();
3034 if (FAILED(hr))
3035 return hr;
3036
3037 *surface = &impl->IDirectDrawSurface_iface;
3038 impl->ifaceToRelease = NULL;
3039
3040 return hr;
3041 }
3042
3043 static BOOL
3044 Main_DirectDraw_DDPIXELFORMAT_Match(const DDPIXELFORMAT *requested,
3045 const DDPIXELFORMAT *provided)
3046 {
3047 /* Some flags must be present in both or neither for a match. */
3048 static const DWORD must_match = DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2
3049 | DDPF_PALETTEINDEXED4 | DDPF_PALETTEINDEXED8 | DDPF_FOURCC
3050 | DDPF_ZBUFFER | DDPF_STENCILBUFFER;
3051
3052 if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
3053 return FALSE;
3054
3055 if ((requested->dwFlags & must_match) != (provided->dwFlags & must_match))
3056 return FALSE;
3057
3058 if (requested->dwFlags & DDPF_FOURCC)
3059 if (requested->dwFourCC != provided->dwFourCC)
3060 return FALSE;
3061
3062 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_ALPHA
3063 |DDPF_LUMINANCE|DDPF_BUMPDUDV))
3064 if (requested->u1.dwRGBBitCount != provided->u1.dwRGBBitCount)
3065 return FALSE;
3066
3067 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
3068 |DDPF_LUMINANCE|DDPF_BUMPDUDV))
3069 if (requested->u2.dwRBitMask != provided->u2.dwRBitMask)
3070 return FALSE;
3071
3072 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_BUMPDUDV))
3073 if (requested->u3.dwGBitMask != provided->u3.dwGBitMask)
3074 return FALSE;
3075
3076 /* I could be wrong about the bumpmapping. MSDN docs are vague. */
3077 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
3078 |DDPF_BUMPDUDV))
3079 if (requested->u4.dwBBitMask != provided->u4.dwBBitMask)
3080 return FALSE;
3081
3082 if (requested->dwFlags & (DDPF_ALPHAPIXELS|DDPF_ZPIXELS))
3083 if (requested->u5.dwRGBAlphaBitMask != provided->u5.dwRGBAlphaBitMask)
3084 return FALSE;
3085
3086 return TRUE;
3087 }
3088
3089 static BOOL ddraw_match_surface_desc(const DDSURFACEDESC2 *requested, const DDSURFACEDESC2 *provided)
3090 {
3091 struct compare_info
3092 {
3093 DWORD flag;
3094 ptrdiff_t offset;
3095 size_t size;
3096 };
3097
3098 #define CMP(FLAG, FIELD) \
3099 { DDSD_##FLAG, offsetof(DDSURFACEDESC2, FIELD), \
3100 sizeof(((DDSURFACEDESC2 *)(NULL))->FIELD) }
3101
3102 static const struct compare_info compare[] =
3103 {
3104 CMP(ALPHABITDEPTH, dwAlphaBitDepth),
3105 CMP(BACKBUFFERCOUNT, u5.dwBackBufferCount),
3106 CMP(CAPS, ddsCaps),
3107 CMP(CKDESTBLT, ddckCKDestBlt),
3108 CMP(CKDESTOVERLAY, u3 /* ddckCKDestOverlay */),
3109 CMP(CKSRCBLT, ddckCKSrcBlt),
3110 CMP(CKSRCOVERLAY, ddckCKSrcOverlay),
3111 CMP(HEIGHT, dwHeight),
3112 CMP(LINEARSIZE, u1 /* dwLinearSize */),
3113 CMP(LPSURFACE, lpSurface),
3114 CMP(MIPMAPCOUNT, u2 /* dwMipMapCount */),
3115 CMP(PITCH, u1 /* lPitch */),
3116 /* PIXELFORMAT: manual */
3117 CMP(REFRESHRATE, u2 /* dwRefreshRate */),
3118 CMP(TEXTURESTAGE, dwTextureStage),
3119 CMP(WIDTH, dwWidth),
3120 /* ZBUFFERBITDEPTH: "obsolete" */
3121 };
3122
3123 #undef CMP
3124
3125 unsigned int i;
3126
3127 if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
3128 return FALSE;
3129
3130 for (i=0; i < sizeof(compare)/sizeof(compare[0]); i++)
3131 {
3132 if (requested->dwFlags & compare[i].flag
3133 && memcmp((const char *)provided + compare[i].offset,
3134 (const char *)requested + compare[i].offset,
3135 compare[i].size) != 0)
3136 return FALSE;
3137 }
3138
3139 if (requested->dwFlags & DDSD_PIXELFORMAT)
3140 {
3141 if (!Main_DirectDraw_DDPIXELFORMAT_Match(&requested->u4.ddpfPixelFormat,
3142 &provided->u4.ddpfPixelFormat))
3143 return FALSE;
3144 }
3145
3146 return TRUE;
3147 }
3148
3149 struct surfacescallback2_context
3150 {
3151 LPDDENUMSURFACESCALLBACK2 func;
3152 void *context;
3153 };
3154
3155 struct surfacescallback_context
3156 {
3157 LPDDENUMSURFACESCALLBACK func;
3158 void *context;
3159 };
3160
3161 static HRESULT CALLBACK EnumSurfacesCallback2Thunk(IDirectDrawSurface7 *surface,
3162 DDSURFACEDESC2 *surface_desc, void *context)
3163 {
3164 struct ddraw_surface *surface_impl = impl_from_IDirectDrawSurface7(surface);
3165 struct surfacescallback2_context *cbcontext = context;
3166
3167 IDirectDrawSurface4_AddRef(&surface_impl->IDirectDrawSurface4_iface);
3168 IDirectDrawSurface7_Release(surface);
3169
3170 return cbcontext->func(&surface_impl->IDirectDrawSurface4_iface,
3171 surface_desc, cbcontext->context);
3172 }
3173
3174 static HRESULT CALLBACK EnumSurfacesCallbackThunk(IDirectDrawSurface7 *surface,
3175 DDSURFACEDESC2 *surface_desc, void *context)
3176 {
3177 struct ddraw_surface *surface_impl = impl_from_IDirectDrawSurface7(surface);
3178 struct surfacescallback_context *cbcontext = context;
3179
3180 IDirectDrawSurface_AddRef(&surface_impl->IDirectDrawSurface_iface);
3181 IDirectDrawSurface7_Release(surface);
3182
3183 return cbcontext->func(&surface_impl->IDirectDrawSurface_iface,
3184 (DDSURFACEDESC *)surface_desc, cbcontext->context);
3185 }
3186
3187 /*****************************************************************************
3188 * IDirectDraw7::EnumSurfaces
3189 *
3190 * Loops through all surfaces attached to this device and calls the
3191 * application callback. This can't be relayed to WineD3DDevice,
3192 * because some WineD3DSurfaces' parents are IParent objects
3193 *
3194 * Params:
3195 * Flags: Some filtering flags. See IDirectDrawImpl_EnumSurfacesCallback
3196 * DDSD: Description to filter for
3197 * Context: Application-provided pointer, it's passed unmodified to the
3198 * Callback function
3199 * Callback: Address to call for each surface
3200 *
3201 * Returns:
3202 * DDERR_INVALIDPARAMS if the callback is NULL
3203 * DD_OK on success
3204 *
3205 *****************************************************************************/
3206 static HRESULT WINAPI ddraw7_EnumSurfaces(IDirectDraw7 *iface, DWORD Flags,
3207 DDSURFACEDESC2 *DDSD, void *Context, LPDDENUMSURFACESCALLBACK7 Callback)
3208 {
3209 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
3210 struct ddraw_surface *surf;
3211 BOOL all, nomatch;
3212 DDSURFACEDESC2 desc;
3213 struct list *entry, *entry2;
3214
3215 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3216 iface, Flags, DDSD, Context, Callback);
3217
3218 all = Flags & DDENUMSURFACES_ALL;
3219 nomatch = Flags & DDENUMSURFACES_NOMATCH;
3220
3221 if (!Callback)
3222 return DDERR_INVALIDPARAMS;
3223
3224 wined3d_mutex_lock();
3225
3226 /* Use the _SAFE enumeration, the app may destroy enumerated surfaces */
3227 LIST_FOR_EACH_SAFE(entry, entry2, &ddraw->surface_list)
3228 {
3229 surf = LIST_ENTRY(entry, struct ddraw_surface, surface_list_entry);
3230
3231 if (!surf->iface_count)
3232 {
3233 WARN("Not enumerating surface %p because it doesn't have any references.\n", surf);
3234 continue;
3235 }
3236
3237 if (all || (nomatch != ddraw_match_surface_desc(DDSD, &surf->surface_desc)))
3238 {
3239 TRACE("Enumerating surface %p.\n", surf);
3240 desc = surf->surface_desc;
3241 IDirectDrawSurface7_AddRef(&surf->IDirectDrawSurface7_iface);
3242 if (Callback(&surf->IDirectDrawSurface7_iface, &desc, Context) != DDENUMRET_OK)
3243 {
3244 wined3d_mutex_unlock();
3245 return DD_OK;
3246 }
3247 }
3248 }
3249
3250 wined3d_mutex_unlock();
3251
3252 return DD_OK;
3253 }
3254
3255 static HRESULT WINAPI ddraw4_EnumSurfaces(IDirectDraw4 *iface, DWORD flags,
3256 DDSURFACEDESC2 *surface_desc, void *context, LPDDENUMSURFACESCALLBACK2 callback)
3257 {
3258 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3259 struct surfacescallback2_context cbcontext;
3260
3261 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3262 iface, flags, surface_desc, context, callback);
3263
3264 cbcontext.func = callback;
3265 cbcontext.context = context;
3266
3267 return ddraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, flags, surface_desc,
3268 &cbcontext, EnumSurfacesCallback2Thunk);
3269 }
3270
3271 static HRESULT WINAPI ddraw2_EnumSurfaces(IDirectDraw2 *iface, DWORD flags,
3272 DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3273 {
3274 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3275 struct surfacescallback_context cbcontext;
3276 DDSURFACEDESC2 surface_desc2;
3277
3278 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3279 iface, flags, surface_desc, context, callback);
3280
3281 cbcontext.func = callback;
3282 cbcontext.context = context;
3283
3284 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3285 return ddraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, flags,
3286 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumSurfacesCallbackThunk);
3287 }
3288
3289 static HRESULT WINAPI ddraw1_EnumSurfaces(IDirectDraw *iface, DWORD flags,
3290 DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3291 {
3292 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3293 struct surfacescallback_context cbcontext;
3294 DDSURFACEDESC2 surface_desc2;
3295
3296 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3297 iface, flags, surface_desc, context, callback);
3298
3299 cbcontext.func = callback;
3300 cbcontext.context = context;
3301
3302 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3303 return ddraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, flags,
3304 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumSurfacesCallbackThunk);
3305 }
3306
3307 /*****************************************************************************
3308 * DirectDrawCreateClipper (DDRAW.@)
3309 *
3310 * Creates a new IDirectDrawClipper object.
3311 *
3312 * Params:
3313 * Clipper: Address to write the interface pointer to
3314 * UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3315 * NULL
3316 *
3317 * Returns:
3318 * CLASS_E_NOAGGREGATION if UnkOuter != NULL
3319 * E_OUTOFMEMORY if allocating the object failed
3320 *
3321 *****************************************************************************/
3322 HRESULT WINAPI DirectDrawCreateClipper(DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3323 {
3324 struct ddraw_clipper *object;
3325 HRESULT hr;
3326
3327 TRACE("flags %#x, clipper %p, outer_unknown %p.\n",
3328 flags, clipper, outer_unknown);
3329
3330 if (outer_unknown)
3331 return CLASS_E_NOAGGREGATION;
3332
3333 wined3d_mutex_lock();
3334
3335 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3336 if (!object)
3337 {
3338 wined3d_mutex_unlock();
3339 return E_OUTOFMEMORY;
3340 }
3341
3342 hr = ddraw_clipper_init(object);
3343 if (FAILED(hr))
3344 {
3345 WARN("Failed to initialize clipper, hr %#x.\n", hr);
3346 HeapFree(GetProcessHeap(), 0, object);
3347 wined3d_mutex_unlock();
3348 return hr;
3349 }
3350
3351 TRACE("Created clipper %p.\n", object);
3352 *clipper = &object->IDirectDrawClipper_iface;
3353 wined3d_mutex_unlock();
3354
3355 return DD_OK;
3356 }
3357
3358 /*****************************************************************************
3359 * IDirectDraw7::CreateClipper
3360 *
3361 * Creates a DDraw clipper. See DirectDrawCreateClipper for details
3362 *
3363 *****************************************************************************/
3364 static HRESULT WINAPI ddraw7_CreateClipper(IDirectDraw7 *iface, DWORD Flags,
3365 IDirectDrawClipper **Clipper, IUnknown *UnkOuter)
3366 {
3367 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3368 iface, Flags, Clipper, UnkOuter);
3369
3370 return DirectDrawCreateClipper(Flags, Clipper, UnkOuter);
3371 }
3372
3373 static HRESULT WINAPI ddraw4_CreateClipper(IDirectDraw4 *iface, DWORD flags,
3374 IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3375 {
3376 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3377
3378 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3379 iface, flags, clipper, outer_unknown);
3380
3381 return ddraw7_CreateClipper(&ddraw->IDirectDraw7_iface, flags, clipper, outer_unknown);
3382 }
3383
3384 static HRESULT WINAPI ddraw2_CreateClipper(IDirectDraw2 *iface,
3385 DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3386 {
3387 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3388
3389 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3390 iface, flags, clipper, outer_unknown);
3391
3392 return ddraw7_CreateClipper(&ddraw->IDirectDraw7_iface, flags, clipper, outer_unknown);
3393 }
3394
3395 static HRESULT WINAPI ddraw1_CreateClipper(IDirectDraw *iface,
3396 DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3397 {
3398 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3399
3400 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3401 iface, flags, clipper, outer_unknown);
3402
3403 return ddraw7_CreateClipper(&ddraw->IDirectDraw7_iface, flags, clipper, outer_unknown);
3404 }
3405
3406 /*****************************************************************************
3407 * IDirectDraw7::CreatePalette
3408 *
3409 * Creates a new IDirectDrawPalette object
3410 *
3411 * Params:
3412 * Flags: The flags for the new clipper
3413 * ColorTable: Color table to assign to the new clipper
3414 * Palette: Address to write the interface pointer to
3415 * UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3416 * NULL
3417 *
3418 * Returns:
3419 * CLASS_E_NOAGGREGATION if UnkOuter != NULL
3420 * E_OUTOFMEMORY if allocating the object failed
3421 *
3422 *****************************************************************************/
3423 static HRESULT WINAPI ddraw7_CreatePalette(IDirectDraw7 *iface, DWORD Flags,
3424 PALETTEENTRY *ColorTable, IDirectDrawPalette **Palette, IUnknown *pUnkOuter)
3425 {
3426 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
3427 struct ddraw_palette *object;
3428 HRESULT hr;
3429
3430 TRACE("iface %p, flags %#x, color_table %p, palette %p, outer_unknown %p.\n",
3431 iface, Flags, ColorTable, Palette, pUnkOuter);
3432
3433 if (pUnkOuter)
3434 return CLASS_E_NOAGGREGATION;
3435
3436 wined3d_mutex_lock();
3437
3438 /* The refcount test shows that a cooplevel is required for this */
3439 if (!ddraw->cooperative_level)
3440 {
3441 WARN("No cooperative level set, returning DDERR_NOCOOPERATIVELEVELSET\n");
3442 wined3d_mutex_unlock();
3443 return DDERR_NOCOOPERATIVELEVELSET;
3444 }
3445
3446 object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object));
3447 if (!object)
3448 {
3449 ERR("Out of memory when allocating memory for a palette implementation\n");
3450 wined3d_mutex_unlock();
3451 return E_OUTOFMEMORY;
3452 }
3453
3454 hr = ddraw_palette_init(object, ddraw, Flags, ColorTable);
3455 if (FAILED(hr))
3456 {
3457 WARN("Failed to initialize palette, hr %#x.\n", hr);
3458 HeapFree(GetProcessHeap(), 0, object);
3459 wined3d_mutex_unlock();
3460 return hr;
3461 }
3462
3463 TRACE("Created palette %p.\n", object);
3464 *Palette = &object->IDirectDrawPalette_iface;
3465 wined3d_mutex_unlock();
3466
3467 return DD_OK;
3468 }
3469
3470 static HRESULT WINAPI ddraw4_CreatePalette(IDirectDraw4 *iface, DWORD flags, PALETTEENTRY *entries,
3471 IDirectDrawPalette **palette, IUnknown *outer_unknown)
3472 {
3473 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3474 HRESULT hr;
3475
3476 TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3477 iface, flags, entries, palette, outer_unknown);
3478
3479 hr = ddraw7_CreatePalette(&ddraw->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3480 if (SUCCEEDED(hr) && *palette)
3481 {
3482 struct ddraw_palette *impl = impl_from_IDirectDrawPalette(*palette);
3483 IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
3484 IDirectDraw4_AddRef(iface);
3485 impl->ifaceToRelease = (IUnknown *)iface;
3486 }
3487 return hr;
3488 }
3489
3490 static HRESULT WINAPI ddraw2_CreatePalette(IDirectDraw2 *iface, DWORD flags,
3491 PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3492 {
3493 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3494 HRESULT hr;
3495
3496 TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3497 iface, flags, entries, palette, outer_unknown);
3498
3499 hr = ddraw7_CreatePalette(&ddraw->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3500 if (SUCCEEDED(hr) && *palette)
3501 {
3502 struct ddraw_palette *impl = impl_from_IDirectDrawPalette(*palette);
3503 IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
3504 impl->ifaceToRelease = NULL;
3505 }
3506
3507 return hr;
3508 }
3509
3510 static HRESULT WINAPI ddraw1_CreatePalette(IDirectDraw *iface, DWORD flags,
3511 PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3512 {
3513 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3514 HRESULT hr;
3515
3516 TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3517 iface, flags, entries, palette, outer_unknown);
3518
3519 hr = ddraw7_CreatePalette(&ddraw->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3520 if (SUCCEEDED(hr) && *palette)
3521 {
3522 struct ddraw_palette *impl = impl_from_IDirectDrawPalette(*palette);
3523 IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
3524 impl->ifaceToRelease = NULL;
3525 }
3526
3527 return hr;
3528 }
3529
3530 /*****************************************************************************
3531 * IDirectDraw7::DuplicateSurface
3532 *
3533 * Duplicates a surface. The surface memory points to the same memory as
3534 * the original surface, and it's released when the last surface referencing
3535 * it is released. I guess that's beyond Wine's surface management right now
3536 * (Idea: create a new DDraw surface with the same WineD3DSurface. I need a
3537 * test application to implement this)
3538 *
3539 * Params:
3540 * Src: Address of the source surface
3541 * Dest: Address to write the new surface pointer to
3542 *
3543 * Returns:
3544 * See IDirectDraw7::CreateSurface
3545 *
3546 *****************************************************************************/
3547 static HRESULT WINAPI ddraw7_DuplicateSurface(IDirectDraw7 *iface,
3548 IDirectDrawSurface7 *Src, IDirectDrawSurface7 **Dest)
3549 {
3550 struct ddraw_surface *src_surface = unsafe_impl_from_IDirectDrawSurface7(Src);
3551
3552 FIXME("iface %p, src %p, dst %p partial stub!\n", iface, Src, Dest);
3553
3554 /* For now, simply create a new, independent surface */
3555 return IDirectDraw7_CreateSurface(iface, &src_surface->surface_desc, Dest, NULL);
3556 }
3557
3558 static HRESULT WINAPI ddraw4_DuplicateSurface(IDirectDraw4 *iface, IDirectDrawSurface4 *src,
3559 IDirectDrawSurface4 **dst)
3560 {
3561 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface4(src);
3562 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3563 struct ddraw_surface *dst_impl;
3564 IDirectDrawSurface7 *dst7;
3565 HRESULT hr;
3566
3567 TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3568
3569 hr = ddraw7_DuplicateSurface(&ddraw->IDirectDraw7_iface,
3570 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3571 if (FAILED(hr))
3572 {
3573 *dst = NULL;
3574 return hr;
3575 }
3576 dst_impl = impl_from_IDirectDrawSurface7(dst7);
3577 *dst = &dst_impl->IDirectDrawSurface4_iface;
3578 IDirectDrawSurface4_AddRef(*dst);
3579 IDirectDrawSurface7_Release(dst7);
3580
3581 return hr;
3582 }
3583
3584 static HRESULT WINAPI ddraw2_DuplicateSurface(IDirectDraw2 *iface,
3585 IDirectDrawSurface *src, IDirectDrawSurface **dst)
3586 {
3587 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface(src);
3588 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3589 struct ddraw_surface *dst_impl;
3590 IDirectDrawSurface7 *dst7;
3591 HRESULT hr;
3592
3593 TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3594
3595 hr = ddraw7_DuplicateSurface(&ddraw->IDirectDraw7_iface,
3596 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3597 if (FAILED(hr))
3598 return hr;
3599 dst_impl = impl_from_IDirectDrawSurface7(dst7);
3600 *dst = &dst_impl->IDirectDrawSurface_iface;
3601 IDirectDrawSurface_AddRef(*dst);
3602 IDirectDrawSurface7_Release(dst7);
3603
3604 return hr;
3605 }
3606
3607 static HRESULT WINAPI ddraw1_DuplicateSurface(IDirectDraw *iface, IDirectDrawSurface *src,
3608 IDirectDrawSurface **dst)
3609 {
3610 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface(src);
3611 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3612 struct ddraw_surface *dst_impl;
3613 IDirectDrawSurface7 *dst7;
3614 HRESULT hr;
3615
3616 TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3617
3618 hr = ddraw7_DuplicateSurface(&ddraw->IDirectDraw7_iface,
3619 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3620 if (FAILED(hr))
3621 return hr;
3622 dst_impl = impl_from_IDirectDrawSurface7(dst7);
3623 *dst = &dst_impl->IDirectDrawSurface_iface;
3624 IDirectDrawSurface_AddRef(*dst);
3625 IDirectDrawSurface7_Release(dst7);
3626
3627 return hr;
3628 }
3629
3630 /*****************************************************************************
3631 * IDirect3D7::EnumDevices
3632 *
3633 * The EnumDevices method for IDirect3D7. It enumerates all supported
3634 * D3D7 devices. Currently the T&L, HAL and RGB devices are enumerated.
3635 *
3636 * Params:
3637 * callback: Function to call for each enumerated device
3638 * context: Pointer to pass back to the app
3639 *
3640 * Returns:
3641 * D3D_OK, or the return value of the GetCaps call
3642 *
3643 *****************************************************************************/
3644 static HRESULT WINAPI d3d7_EnumDevices(IDirect3D7 *iface, LPD3DENUMDEVICESCALLBACK7 callback, void *context)
3645 {
3646 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
3647 D3DDEVICEDESC7 device_desc7;
3648 HRESULT hr;
3649 size_t i;
3650
3651 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3652
3653 if (!callback)
3654 return DDERR_INVALIDPARAMS;
3655
3656 wined3d_mutex_lock();
3657
3658 if (FAILED(hr = ddraw_get_d3dcaps(ddraw, &device_desc7)))
3659 {
3660 wined3d_mutex_unlock();
3661 return hr;
3662 }
3663
3664 for (i = 0; i < sizeof(device_list7)/sizeof(device_list7[0]); i++)
3665 {
3666 HRESULT ret;
3667
3668 device_desc7.deviceGUID = *device_list7[i].device_guid;
3669 ret = callback(device_list7[i].interface_name, device_list7[i].device_name, &device_desc7, context);
3670 if (ret != DDENUMRET_OK)
3671 {
3672 TRACE("Application cancelled the enumeration.\n");
3673 wined3d_mutex_unlock();
3674 return D3D_OK;
3675 }
3676 }
3677
3678 TRACE("End of enumeration.\n");
3679
3680 wined3d_mutex_unlock();
3681
3682 return D3D_OK;
3683 }
3684
3685 /*****************************************************************************
3686 * IDirect3D3::EnumDevices
3687 *
3688 * Enumerates all supported Direct3DDevice interfaces. This is the
3689 * implementation for Direct3D 1 to Direc3D 3, Version 7 has its own.
3690 *
3691 * Versions 1, 2 and 3
3692 *
3693 * Params:
3694 * callback: Application-provided routine to call for each enumerated device
3695 * Context: Pointer to pass to the callback
3696 *
3697 * Returns:
3698 * D3D_OK on success,
3699 * The result of IDirect3DImpl_GetCaps if it failed
3700 *
3701 *****************************************************************************/
3702 static HRESULT WINAPI d3d3_EnumDevices(IDirect3D3 *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
3703 {
3704 static CHAR wined3d_description[] = "Wine D3DDevice using WineD3D and OpenGL";
3705
3706 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3707 D3DDEVICEDESC device_desc1, hal_desc, hel_desc;
3708 D3DDEVICEDESC7 device_desc7;
3709 HRESULT hr;
3710
3711 /* Some games (Motoracer 2 demo) have the bad idea to modify the device
3712 * name string. Let's put the string in a sufficiently sized array in
3713 * writable memory. */
3714 char device_name[50];
3715 strcpy(device_name,"Direct3D HEL");
3716
3717 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3718
3719 if (!callback)
3720 return DDERR_INVALIDPARAMS;
3721
3722 wined3d_mutex_lock();
3723
3724 if (FAILED(hr = ddraw_get_d3dcaps(ddraw, &device_desc7)))
3725 {
3726 wined3d_mutex_unlock();
3727 return hr;
3728 }
3729 ddraw_d3dcaps1_from_7(&device_desc1, &device_desc7);
3730
3731 /* Do I have to enumerate the reference id? Note from old d3d7:
3732 * "It seems that enumerating the reference IID on Direct3D 1 games
3733 * (AvP / Motoracer2) breaks them". So do not enumerate this iid in V1
3734 *
3735 * There's a registry key HKLM\Software\Microsoft\Direct3D\Drivers,
3736 * EnumReference which enables / disables enumerating the reference
3737 * rasterizer. It's a DWORD, 0 means disabled, 2 means enabled. The
3738 * enablerefrast.reg and disablerefrast.reg files in the DirectX 7.0 sdk
3739 * demo directory suggest this.
3740 *
3741 * Some games(GTA 2) seem to use the second enumerated device, so I have
3742 * to enumerate at least 2 devices. So enumerate the reference device to
3743 * have 2 devices.
3744 *
3745 * Other games (Rollcage) tell emulation and hal device apart by certain
3746 * flags. Rollcage expects D3DPTEXTURECAPS_POW2 to be set (yeah, it is a
3747 * limitation flag), and it refuses all devices that have the perspective
3748 * flag set. This way it refuses the emulation device, and HAL devices
3749 * never have POW2 unset in d3d7 on windows. */
3750 if (ddraw->d3dversion != 1)
3751 {
3752 static CHAR reference_description[] = "RGB Direct3D emulation";
3753
3754 TRACE("Enumerating WineD3D D3DDevice interface.\n");
3755 hal_desc = device_desc1;
3756 hel_desc = device_desc1;
3757 /* The rgb device has the pow2 flag set in the hel caps, but not in the hal caps. */
3758 hal_desc.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
3759 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
3760 hal_desc.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
3761 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
3762 /* RGB, RAMP and MMX devices have a HAL dcmColorModel of 0 */
3763 hal_desc.dcmColorModel = 0;
3764 /* RGB, RAMP and MMX devices cannot report HAL hardware flags */
3765 hal_desc.dwFlags = 0;
3766
3767 hr = callback((GUID *)&IID_IDirect3DRGBDevice, reference_description,
3768 device_name, &hal_desc, &hel_desc, context);
3769 if (hr != D3DENUMRET_OK)
3770 {
3771 TRACE("Application cancelled the enumeration.\n");
3772 wined3d_mutex_unlock();
3773 return D3D_OK;
3774 }
3775 }
3776
3777 strcpy(device_name,"Direct3D HAL");
3778
3779 TRACE("Enumerating HAL Direct3D device.\n");
3780 hal_desc = device_desc1;
3781 hel_desc = device_desc1;
3782
3783 /* The hal device does not have the pow2 flag set in hel, but in hal. */
3784 hel_desc.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
3785 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
3786 hel_desc.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
3787 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
3788 /* HAL devices have a HEL dcmColorModel of 0 */
3789 hel_desc.dcmColorModel = 0;
3790
3791 hr = callback((GUID *)&IID_IDirect3DHALDevice, wined3d_description,
3792 device_name, &hal_desc, &hel_desc, context);
3793 if (hr != D3DENUMRET_OK)
3794 {
3795 TRACE("Application cancelled the enumeration.\n");
3796 wined3d_mutex_unlock();
3797 return D3D_OK;
3798 }
3799
3800 TRACE("End of enumeration.\n");
3801
3802 wined3d_mutex_unlock();
3803
3804 return D3D_OK;
3805 }
3806
3807 static HRESULT WINAPI d3d2_EnumDevices(IDirect3D2 *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
3808 {
3809 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
3810
3811 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3812
3813 return d3d3_EnumDevices(&ddraw->IDirect3D3_iface, callback, context);
3814 }
3815
3816 static HRESULT WINAPI d3d1_EnumDevices(IDirect3D *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
3817 {
3818 struct ddraw *ddraw = impl_from_IDirect3D(iface);
3819
3820 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3821
3822 return d3d3_EnumDevices(&ddraw->IDirect3D3_iface, callback, context);
3823 }
3824
3825 /*****************************************************************************
3826 * IDirect3D3::CreateLight
3827 *
3828 * Creates an IDirect3DLight interface. This interface is used in
3829 * Direct3D3 or earlier for lighting. In Direct3D7 it has been replaced
3830 * by the DIRECT3DLIGHT7 structure. Wine's Direct3DLight implementation
3831 * uses the IDirect3DDevice7 interface with D3D7 lights.
3832 *
3833 * Versions 1, 2 and 3
3834 *
3835 * Params:
3836 * light: Address to store the new interface pointer
3837 * outer_unknown: Basically for aggregation, but ddraw doesn't support it.
3838 * Must be NULL
3839 *
3840 * Returns:
3841 * D3D_OK on success
3842 * DDERR_OUTOFMEMORY if memory allocation failed
3843 * CLASS_E_NOAGGREGATION if outer_unknown != NULL
3844 *
3845 *****************************************************************************/
3846 static HRESULT WINAPI d3d3_CreateLight(IDirect3D3 *iface, IDirect3DLight **light,
3847 IUnknown *outer_unknown)
3848 {
3849 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3850 struct d3d_light *object;
3851
3852 TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
3853
3854 if (outer_unknown) return CLASS_E_NOAGGREGATION;
3855
3856 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3857 if (!object)
3858 {
3859 ERR("Failed to allocate light memory.\n");
3860 return DDERR_OUTOFMEMORY;
3861 }
3862
3863 d3d_light_init(object, ddraw);
3864
3865 TRACE("Created light %p.\n", object);
3866 *light = &object->IDirect3DLight_iface;
3867
3868 return D3D_OK;
3869 }
3870
3871 static HRESULT WINAPI d3d2_CreateLight(IDirect3D2 *iface, IDirect3DLight **light, IUnknown *outer_unknown)
3872 {
3873 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
3874
3875 TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
3876
3877 return d3d3_CreateLight(&ddraw->IDirect3D3_iface, light, outer_unknown);
3878 }
3879
3880 static HRESULT WINAPI d3d1_CreateLight(IDirect3D *iface, IDirect3DLight **light, IUnknown *outer_unknown)
3881 {
3882 struct ddraw *ddraw = impl_from_IDirect3D(iface);
3883
3884 TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
3885
3886 return d3d3_CreateLight(&ddraw->IDirect3D3_iface, light, outer_unknown);
3887 }
3888
3889 /*****************************************************************************
3890 * IDirect3D3::CreateMaterial
3891 *
3892 * Creates an IDirect3DMaterial interface. This interface is used by Direct3D3
3893 * and older versions. The IDirect3DMaterial implementation wraps its
3894 * functionality to IDirect3DDevice7::SetMaterial and friends.
3895 *
3896 * Versions 1, 2 and 3
3897 *
3898 * Params:
3899 * material: Address to store the new interface's pointer to
3900 * outer_unknown: Basically for aggregation, but ddraw doesn't support it.
3901 * Must be NULL
3902 *
3903 * Returns:
3904 * D3D_OK on success
3905 * DDERR_OUTOFMEMORY if memory allocation failed
3906 * CLASS_E_NOAGGREGATION if outer_unknown != NULL
3907 *
3908 *****************************************************************************/
3909 static HRESULT WINAPI d3d3_CreateMaterial(IDirect3D3 *iface, IDirect3DMaterial3 **material,
3910 IUnknown *outer_unknown)
3911 {
3912 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3913 struct d3d_material *object;
3914
3915 TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
3916
3917 if (outer_unknown) return CLASS_E_NOAGGREGATION;
3918
3919 object = d3d_material_create(ddraw);
3920 if (!object)
3921 {
3922 ERR("Failed to allocate material memory.\n");
3923 return DDERR_OUTOFMEMORY;
3924 }
3925
3926 TRACE("Created material %p.\n", object);
3927 *material = &object->IDirect3DMaterial3_iface;
3928
3929 return D3D_OK;
3930 }
3931
3932 static HRESULT WINAPI d3d2_CreateMaterial(IDirect3D2 *iface, IDirect3DMaterial2 **material,
3933 IUnknown *outer_unknown)
3934 {
3935 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
3936 struct d3d_material *object;
3937
3938 TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
3939
3940 object = d3d_material_create(ddraw);
3941 if (!object)
3942 {
3943 ERR("Failed to allocate material memory.\n");
3944 return DDERR_OUTOFMEMORY;
3945 }
3946
3947 TRACE("Created material %p.\n", object);
3948 *material = &object->IDirect3DMaterial2_iface;
3949
3950 return D3D_OK;
3951 }
3952
3953 static HRESULT WINAPI d3d1_CreateMaterial(IDirect3D *iface, IDirect3DMaterial **material,
3954 IUnknown *outer_unknown)
3955 {
3956 struct ddraw *ddraw = impl_from_IDirect3D(iface);
3957 struct d3d_material *object;
3958
3959 TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
3960
3961 object = d3d_material_create(ddraw);
3962 if (!object)
3963 {
3964 ERR("Failed to allocate material memory.\n");
3965 return DDERR_OUTOFMEMORY;
3966 }
3967
3968 TRACE("Created material %p.\n", object);
3969 *material = &object->IDirect3DMaterial_iface;
3970
3971 return D3D_OK;
3972 }
3973
3974 /*****************************************************************************
3975 * IDirect3D3::CreateViewport
3976 *
3977 * Creates an IDirect3DViewport interface. This interface is used
3978 * by Direct3D and earlier versions for Viewport management. In Direct3D7
3979 * it has been replaced by a viewport structure and
3980 * IDirect3DDevice7::*Viewport. Wine's IDirect3DViewport implementation
3981 * uses the IDirect3DDevice7 methods for its functionality
3982 *
3983 * Params:
3984 * Viewport: Address to store the new interface pointer
3985 * outer_unknown: Basically for aggregation, but ddraw doesn't support it.
3986 * Must be NULL
3987 *
3988 * Returns:
3989 * D3D_OK on success
3990 * DDERR_OUTOFMEMORY if memory allocation failed
3991 * CLASS_E_NOAGGREGATION if outer_unknown != NULL
3992 *
3993 *****************************************************************************/
3994 static HRESULT WINAPI d3d3_CreateViewport(IDirect3D3 *iface, IDirect3DViewport3 **viewport,
3995 IUnknown *outer_unknown)
3996 {
3997 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3998 struct d3d_viewport *object;
3999
4000 TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4001
4002 if (outer_unknown) return CLASS_E_NOAGGREGATION;
4003
4004 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4005 if (!object)
4006 {
4007 ERR("Failed to allocate viewport memory.\n");
4008 return DDERR_OUTOFMEMORY;
4009 }
4010
4011 d3d_viewport_init(object, ddraw);
4012
4013 TRACE("Created viewport %p.\n", object);
4014 *viewport = &object->IDirect3DViewport3_iface;
4015
4016 return D3D_OK;
4017 }
4018
4019 static HRESULT WINAPI d3d2_CreateViewport(IDirect3D2 *iface, IDirect3DViewport2 **viewport, IUnknown *outer_unknown)
4020 {
4021 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4022
4023 TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4024
4025 return d3d3_CreateViewport(&ddraw->IDirect3D3_iface, (IDirect3DViewport3 **)viewport,
4026 outer_unknown);
4027 }
4028
4029 static HRESULT WINAPI d3d1_CreateViewport(IDirect3D *iface, IDirect3DViewport **viewport, IUnknown *outer_unknown)
4030 {
4031 struct ddraw *ddraw = impl_from_IDirect3D(iface);
4032
4033 TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4034
4035 return d3d3_CreateViewport(&ddraw->IDirect3D3_iface, (IDirect3DViewport3 **)viewport,
4036 outer_unknown);
4037 }
4038
4039 /*****************************************************************************
4040 * IDirect3D3::FindDevice
4041 *
4042 * This method finds a device with the requested properties and returns a
4043 * device description
4044 *
4045 * Versions 1, 2 and 3
4046 * Params:
4047 * fds: Describes the requested device characteristics
4048 * fdr: Returns the device description
4049 *
4050 * Returns:
4051 * D3D_OK on success
4052 * DDERR_INVALIDPARAMS if no device was found
4053 *
4054 *****************************************************************************/
4055 static HRESULT WINAPI d3d3_FindDevice(IDirect3D3 *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4056 {
4057 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4058 D3DDEVICEDESC7 desc7;
4059 D3DDEVICEDESC desc1;
4060 HRESULT hr;
4061
4062 TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4063
4064 if (!fds || !fdr) return DDERR_INVALIDPARAMS;
4065
4066 if (fds->dwSize != sizeof(D3DFINDDEVICESEARCH)
4067 || fdr->dwSize != sizeof(D3DFINDDEVICERESULT))
4068 return DDERR_INVALIDPARAMS;
4069
4070 if ((fds->dwFlags & D3DFDS_COLORMODEL)
4071 && fds->dcmColorModel != D3DCOLOR_RGB)
4072 {
4073 WARN("Trying to request a non-RGB D3D color model. Not supported.\n");
4074 return DDERR_INVALIDPARAMS; /* No real idea what to return here :-) */
4075 }
4076
4077 if (fds->dwFlags & D3DFDS_GUID)
4078 {
4079 TRACE("Trying to match guid %s.\n", debugstr_guid(&(fds->guid)));
4080 if (!IsEqualGUID(&IID_D3DDEVICE_WineD3D, &fds->guid)
4081 && !IsEqualGUID(&IID_IDirect3DHALDevice, &fds->guid)
4082 && !IsEqualGUID(&IID_IDirect3DRGBDevice, &fds->guid))
4083 {
4084 WARN("No match for this GUID.\n");
4085 return DDERR_NOTFOUND;
4086 }
4087 }
4088
4089 /* Get the caps */
4090 if (FAILED(hr = ddraw_get_d3dcaps(ddraw, &desc7)))
4091 return hr;
4092
4093 /* Now return our own GUID */
4094 ddraw_d3dcaps1_from_7(&desc1, &desc7);
4095 fdr->guid = IID_D3DDEVICE_WineD3D;
4096 fdr->ddHwDesc = desc1;
4097 fdr->ddSwDesc = desc1;
4098
4099 TRACE("Returning Wine's wined3d device with (undumped) capabilities.\n");
4100
4101 return D3D_OK;
4102 }
4103
4104 static HRESULT WINAPI d3d2_FindDevice(IDirect3D2 *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4105 {
4106 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4107
4108 TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4109
4110 return d3d3_FindDevice(&ddraw->IDirect3D3_iface, fds, fdr);
4111 }
4112
4113 static HRESULT WINAPI d3d1_FindDevice(IDirect3D *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4114 {
4115 struct ddraw *ddraw = impl_from_IDirect3D(iface);
4116
4117 TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4118
4119 return d3d3_FindDevice(&ddraw->IDirect3D3_iface, fds, fdr);
4120 }
4121
4122 /*****************************************************************************
4123 * IDirect3D7::CreateDevice
4124 *
4125 * Creates an IDirect3DDevice7 interface.
4126 *
4127 * Versions 2, 3 and 7. IDirect3DDevice 1 interfaces are interfaces to
4128 * DirectDraw surfaces and are created with
4129 * IDirectDrawSurface::QueryInterface. This method uses CreateDevice to
4130 * create the device object and QueryInterfaces for IDirect3DDevice
4131 *
4132 * Params:
4133 * refiid: IID of the device to create
4134 * Surface: Initial rendertarget
4135 * Device: Address to return the interface pointer
4136 *
4137 * Returns:
4138 * D3D_OK on success
4139 * DDERR_OUTOFMEMORY if memory allocation failed
4140 * DDERR_INVALIDPARAMS if a device exists already
4141 *
4142 *****************************************************************************/
4143 static HRESULT WINAPI d3d7_CreateDevice(IDirect3D7 *iface, REFCLSID riid,
4144 IDirectDrawSurface7 *surface, IDirect3DDevice7 **device)
4145 {
4146 struct ddraw_surface *target = unsafe_impl_from_IDirectDrawSurface7(surface);
4147 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4148 struct d3d_device *object;
4149 HRESULT hr;
4150
4151 TRACE("iface %p, riid %s, surface %p, device %p.\n", iface, debugstr_guid(riid), surface, device);
4152
4153 wined3d_mutex_lock();
4154 if (SUCCEEDED(hr = d3d_device_create(ddraw, target, (IUnknown *)surface, 7, &object, NULL)))
4155 {
4156 *device = &object->IDirect3DDevice7_iface;
4157 }
4158 else
4159 {
4160 WARN("Failed to create device, hr %#x.\n", hr);
4161 *device = NULL;
4162 }
4163 wined3d_mutex_unlock();
4164
4165 return hr;
4166 }
4167
4168 static HRESULT WINAPI d3d3_CreateDevice(IDirect3D3 *iface, REFCLSID riid,
4169 IDirectDrawSurface4 *surface, IDirect3DDevice3 **device, IUnknown *outer_unknown)
4170 {
4171 struct ddraw_surface *surface_impl = unsafe_impl_from_IDirectDrawSurface4(surface);
4172 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4173 struct d3d_device *device_impl;
4174 HRESULT hr;
4175
4176 TRACE("iface %p, riid %s, surface %p, device %p, outer_unknown %p.\n",
4177 iface, debugstr_guid(riid), surface, device, outer_unknown);
4178
4179 if (outer_unknown)
4180 return CLASS_E_NOAGGREGATION;
4181
4182 wined3d_mutex_lock();
4183 if (SUCCEEDED(hr = d3d_device_create(ddraw, surface_impl, (IUnknown *)surface, 3, &device_impl, NULL)))
4184 {
4185 *device = &device_impl->IDirect3DDevice3_iface;
4186 }
4187 else
4188 {
4189 WARN("Failed to create device, hr %#x.\n", hr);
4190 *device = NULL;
4191 }
4192 wined3d_mutex_unlock();
4193
4194 return hr;
4195 }
4196
4197 static HRESULT WINAPI d3d2_CreateDevice(IDirect3D2 *iface, REFCLSID riid,
4198 IDirectDrawSurface *surface, IDirect3DDevice2 **device)
4199 {
4200 struct ddraw_surface *surface_impl = unsafe_impl_from_IDirectDrawSurface(surface);
4201 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4202 struct d3d_device *device_impl;
4203 HRESULT hr;
4204
4205 TRACE("iface %p, riid %s, surface %p, device %p.\n",
4206 iface, debugstr_guid(riid), surface, device);
4207
4208 wined3d_mutex_lock();
4209 if (SUCCEEDED(hr = d3d_device_create(ddraw, surface_impl, (IUnknown *)surface, 2, &device_impl, NULL)))
4210 {
4211 *device = &device_impl->IDirect3DDevice2_iface;
4212 }
4213 else
4214 {
4215 WARN("Failed to create device, hr %#x.\n", hr);
4216 *device = NULL;
4217 }
4218 wined3d_mutex_unlock();
4219
4220 return hr;
4221 }
4222
4223 /*****************************************************************************
4224 * IDirect3D7::CreateVertexBuffer
4225 *
4226 * Creates a new vertex buffer object and returns a IDirect3DVertexBuffer7
4227 * interface.
4228 *
4229 * Versions 3 and 7
4230 *
4231 * Params:
4232 * desc: Requested Vertex buffer properties
4233 * vertex_buffer: Address to return the interface pointer at
4234 * flags: Some flags, should be 0
4235 *
4236 * Returns
4237 * D3D_OK on success
4238 * DDERR_OUTOFMEMORY if memory allocation failed
4239 * DDERR_INVALIDPARAMS if desc or vertex_buffer is NULL
4240 *
4241 *****************************************************************************/
4242 static HRESULT WINAPI d3d7_CreateVertexBuffer(IDirect3D7 *iface, D3DVERTEXBUFFERDESC *desc,
4243 IDirect3DVertexBuffer7 **vertex_buffer, DWORD flags)
4244 {
4245 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4246 struct d3d_vertex_buffer *object;
4247 HRESULT hr;
4248
4249 TRACE("iface %p, desc %p, vertex_buffer %p, flags %#x.\n",
4250 iface, desc, vertex_buffer, flags);
4251
4252 if (!vertex_buffer || !desc) return DDERR_INVALIDPARAMS;
4253
4254 hr = d3d_vertex_buffer_create(&object, ddraw, desc);
4255 if (hr == D3D_OK)
4256 {
4257 TRACE("Created vertex buffer %p.\n", object);
4258 *vertex_buffer = &object->IDirect3DVertexBuffer7_iface;
4259 }
4260 else
4261 WARN("Failed to create vertex buffer, hr %#x.\n", hr);
4262
4263 return hr;
4264 }
4265
4266 static HRESULT WINAPI d3d3_CreateVertexBuffer(IDirect3D3 *iface, D3DVERTEXBUFFERDESC *desc,
4267 IDirect3DVertexBuffer **vertex_buffer, DWORD flags, IUnknown *outer_unknown)
4268 {
4269 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4270 struct d3d_vertex_buffer *object;
4271 HRESULT hr;
4272
4273 TRACE("iface %p, desc %p, vertex_buffer %p, flags %#x, outer_unknown %p.\n",
4274 iface, desc, vertex_buffer, flags, outer_unknown);
4275
4276 if (outer_unknown)
4277 return CLASS_E_NOAGGREGATION;
4278 if (!vertex_buffer || !desc)
4279 return DDERR_INVALIDPARAMS;
4280
4281 hr = d3d_vertex_buffer_create(&object, ddraw, desc);
4282 if (hr == D3D_OK)
4283 {
4284 TRACE("Created vertex buffer %p.\n", object);
4285 *vertex_buffer = (IDirect3DVertexBuffer *)&object->IDirect3DVertexBuffer7_iface;
4286 }
4287 else
4288 WARN("Failed to create vertex buffer, hr %#x.\n", hr);
4289
4290 return hr;
4291 }
4292
4293 /*****************************************************************************
4294 * IDirect3D7::EnumZBufferFormats
4295 *
4296 * Enumerates all supported Z buffer pixel formats
4297 *
4298 * Versions 3 and 7
4299 *
4300 * Params:
4301 * device_iid:
4302 * callback: callback to call for each pixel format
4303 * context: Pointer to pass back to the callback
4304 *
4305 * Returns:
4306 * D3D_OK on success
4307 * DDERR_INVALIDPARAMS if callback is NULL
4308 *
4309 *****************************************************************************/
4310 static HRESULT WINAPI d3d7_EnumZBufferFormats(IDirect3D7 *iface, REFCLSID device_iid,
4311 LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
4312 {
4313 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4314 struct wined3d_display_mode mode;
4315 enum wined3d_device_type type;
4316 unsigned int i;
4317 HRESULT hr;
4318
4319 /* Order matters. Specifically, BattleZone II (full version) expects the
4320 * 16-bit depth formats to be listed before the 24 and 32 ones. */
4321 static const enum wined3d_format_id formats[] =
4322 {
4323 WINED3DFMT_S1_UINT_D15_UNORM,
4324 WINED3DFMT_D16_UNORM,
4325 WINED3DFMT_X8D24_UNORM,
4326 WINED3DFMT_S4X4_UINT_D24_UNORM,
4327 WINED3DFMT_D24_UNORM_S8_UINT,
4328 WINED3DFMT_D32_UNORM,
4329 };
4330
4331 TRACE("iface %p, device_iid %s, callback %p, context %p.\n",
4332 iface, debugstr_guid(device_iid), callback, context);
4333
4334 if (!callback) return DDERR_INVALIDPARAMS;
4335
4336 if (IsEqualGUID(device_iid, &IID_IDirect3DHALDevice)
4337 || IsEqualGUID(device_iid, &IID_IDirect3DTnLHalDevice)
4338 || IsEqualGUID(device_iid, &IID_D3DDEVICE_WineD3D))
4339 {
4340 TRACE("Asked for HAL device.\n");
4341 type = WINED3D_DEVICE_TYPE_HAL;
4342 }
4343 else if (IsEqualGUID(device_iid, &IID_IDirect3DRGBDevice)
4344 || IsEqualGUID(device_iid, &IID_IDirect3DMMXDevice))
4345 {
4346 TRACE("Asked for SW device.\n");
4347 type = WINED3D_DEVICE_TYPE_SW;
4348 }
4349 else if (IsEqualGUID(device_iid, &IID_IDirect3DRefDevice))
4350 {
4351 TRACE("Asked for REF device.\n");
4352 type = WINED3D_DEVICE_TYPE_REF;
4353 }
4354 else if (IsEqualGUID(device_iid, &IID_IDirect3DNullDevice))
4355 {
4356 TRACE("Asked for NULLREF device.\n");
4357 type = WINED3D_DEVICE_TYPE_NULLREF;
4358 }
4359 else
4360 {
4361 FIXME("Unexpected device GUID %s.\n", debugstr_guid(device_iid));
4362 type = WINED3D_DEVICE_TYPE_HAL;
4363 }
4364
4365 wined3d_mutex_lock();
4366 /* We need an adapter format from somewhere to please wined3d and WGL.
4367 * Use the current display mode. So far all cards offer the same depth
4368 * stencil format for all modes, but if some do not and applications do
4369 * not like that we'll have to find some workaround, like iterating over
4370 * all imaginable formats and collecting all the depth stencil formats we
4371 * can get. */
4372 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
4373 {
4374 ERR("Failed to get display mode, hr %#x.\n", hr);
4375 wined3d_mutex_unlock();
4376 return hr;
4377 }
4378
4379 for (i = 0; i < (sizeof(formats) / sizeof(*formats)); ++i)
4380 {
4381 if (SUCCEEDED(wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, type, mode.format_id,
4382 WINED3DUSAGE_DEPTHSTENCIL, WINED3D_RTYPE_TEXTURE_2D, formats[i])))
4383 {
4384 DDPIXELFORMAT pformat;
4385
4386 memset(&pformat, 0, sizeof(pformat));
4387 pformat.dwSize = sizeof(pformat);
4388 ddrawformat_from_wined3dformat(&pformat, formats[i]);
4389
4390 TRACE("Enumerating wined3d format %#x.\n", formats[i]);
4391 hr = callback(&pformat, context);
4392 if (hr != DDENUMRET_OK)
4393 {
4394 TRACE("Format enumeration cancelled by application.\n");
4395 wined3d_mutex_unlock();
4396 return D3D_OK;
4397 }
4398 }
4399 }
4400
4401 /* Historically some windows drivers used dwZBufferBitDepth=24 for WINED3DFMT_X8D24_UNORM,
4402 * while others used dwZBufferBitDepth=32. In either case the pitch matches a 32 bits per
4403 * pixel format, so we use dwZBufferBitDepth=32. Some games expect 24. Windows Vista and
4404 * newer enumerate both versions, so we do the same(bug 22434) */
4405 if (SUCCEEDED(wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, type, mode.format_id,
4406 WINED3DUSAGE_DEPTHSTENCIL, WINED3D_RTYPE_TEXTURE_2D, WINED3DFMT_X8D24_UNORM)))
4407 {
4408 DDPIXELFORMAT x8d24 =
4409 {
4410 sizeof(x8d24), DDPF_ZBUFFER, 0,
4411 {24}, {0x00000000}, {0x00ffffff}, {0x00000000}
4412 };
4413 TRACE("Enumerating WINED3DFMT_X8D24_UNORM, dwZBufferBitDepth=24 version\n");
4414 callback(&x8d24, context);
4415 }
4416
4417 TRACE("End of enumeration.\n");
4418
4419 wined3d_mutex_unlock();
4420
4421 return D3D_OK;
4422 }
4423
4424 static HRESULT WINAPI d3d3_EnumZBufferFormats(IDirect3D3 *iface, REFCLSID device_iid,
4425 LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
4426 {
4427 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4428
4429 TRACE("iface %p, device_iid %s, callback %p, context %p.\n",
4430 iface, debugstr_guid(device_iid), callback, context);
4431
4432 return d3d7_EnumZBufferFormats(&ddraw->IDirect3D7_iface, device_iid, callback, context);
4433 }
4434
4435 /*****************************************************************************
4436 * IDirect3D7::EvictManagedTextures
4437 *
4438 * Removes all managed textures (=surfaces with DDSCAPS2_TEXTUREMANAGE or
4439 * DDSCAPS2_D3DTEXTUREMANAGE caps) to be removed from video memory.
4440 *
4441 * Versions 3 and 7
4442 *
4443 * Returns:
4444 * D3D_OK, because it's a stub
4445 *
4446 *****************************************************************************/
4447 static HRESULT WINAPI d3d7_EvictManagedTextures(IDirect3D7 *iface)
4448 {
4449 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4450
4451 TRACE("iface %p!\n", iface);
4452
4453 wined3d_mutex_lock();
4454 if (ddraw->flags & DDRAW_D3D_INITIALIZED)
4455 wined3d_device_evict_managed_resources(ddraw->wined3d_device);
4456 wined3d_mutex_unlock();
4457
4458 return D3D_OK;
4459 }
4460
4461 static HRESULT WINAPI d3d3_EvictManagedTextures(IDirect3D3 *iface)
4462 {
4463 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4464
4465 TRACE("iface %p.\n", iface);
4466
4467 return d3d7_EvictManagedTextures(&ddraw->IDirect3D7_iface);
4468 }
4469
4470 /*****************************************************************************
4471 * IDirectDraw7 VTable
4472 *****************************************************************************/
4473 static const struct IDirectDraw7Vtbl ddraw7_vtbl =
4474 {
4475 /* IUnknown */
4476 ddraw7_QueryInterface,
4477 ddraw7_AddRef,
4478 ddraw7_Release,
4479 /* IDirectDraw */
4480 ddraw7_Compact,
4481 ddraw7_CreateClipper,
4482 ddraw7_CreatePalette,
4483 ddraw7_CreateSurface,
4484 ddraw7_DuplicateSurface,
4485 ddraw7_EnumDisplayModes,
4486 ddraw7_EnumSurfaces,
4487 ddraw7_FlipToGDISurface,
4488 ddraw7_GetCaps,
4489 ddraw7_GetDisplayMode,
4490 ddraw7_GetFourCCCodes,
4491 ddraw7_GetGDISurface,
4492 ddraw7_GetMonitorFrequency,
4493 ddraw7_GetScanLine,
4494 ddraw7_GetVerticalBlankStatus,
4495 ddraw7_Initialize,
4496 ddraw7_RestoreDisplayMode,
4497 ddraw7_SetCooperativeLevel,
4498 ddraw7_SetDisplayMode,
4499 ddraw7_WaitForVerticalBlank,
4500 /* IDirectDraw2 */
4501 ddraw7_GetAvailableVidMem,
4502 /* IDirectDraw3 */
4503 ddraw7_GetSurfaceFromDC,
4504 /* IDirectDraw4 */
4505 ddraw7_RestoreAllSurfaces,
4506 ddraw7_TestCooperativeLevel,
4507 ddraw7_GetDeviceIdentifier,
4508 /* IDirectDraw7 */
4509 ddraw7_StartModeTest,
4510 ddraw7_EvaluateMode
4511 };
4512
4513 static const struct IDirectDraw4Vtbl ddraw4_vtbl =
4514 {
4515 /* IUnknown */
4516 ddraw4_QueryInterface,
4517 ddraw4_AddRef,
4518 ddraw4_Release,
4519 /* IDirectDraw */
4520 ddraw4_Compact,
4521 ddraw4_CreateClipper,
4522 ddraw4_CreatePalette,
4523 ddraw4_CreateSurface,
4524 ddraw4_DuplicateSurface,
4525 ddraw4_EnumDisplayModes,
4526 ddraw4_EnumSurfaces,
4527 ddraw4_FlipToGDISurface,
4528 ddraw4_GetCaps,
4529 ddraw4_GetDisplayMode,
4530 ddraw4_GetFourCCCodes,
4531 ddraw4_GetGDISurface,
4532 ddraw4_GetMonitorFrequency,
4533 ddraw4_GetScanLine,
4534 ddraw4_GetVerticalBlankStatus,
4535 ddraw4_Initialize,
4536 ddraw4_RestoreDisplayMode,
4537 ddraw4_SetCooperativeLevel,
4538 ddraw4_SetDisplayMode,
4539 ddraw4_WaitForVerticalBlank,
4540 /* IDirectDraw2 */
4541 ddraw4_GetAvailableVidMem,
4542 /* IDirectDraw3 */
4543 ddraw4_GetSurfaceFromDC,
4544 /* IDirectDraw4 */
4545 ddraw4_RestoreAllSurfaces,
4546 ddraw4_TestCooperativeLevel,
4547 ddraw4_GetDeviceIdentifier,
4548 };
4549
4550 static const struct IDirectDraw2Vtbl ddraw2_vtbl =
4551 {
4552 /* IUnknown */
4553 ddraw2_QueryInterface,
4554 ddraw2_AddRef,
4555 ddraw2_Release,
4556 /* IDirectDraw */
4557 ddraw2_Compact,
4558 ddraw2_CreateClipper,
4559 ddraw2_CreatePalette,
4560 ddraw2_CreateSurface,
4561 ddraw2_DuplicateSurface,
4562 ddraw2_EnumDisplayModes,
4563 ddraw2_EnumSurfaces,
4564 ddraw2_FlipToGDISurface,
4565 ddraw2_GetCaps,
4566 ddraw2_GetDisplayMode,
4567 ddraw2_GetFourCCCodes,
4568 ddraw2_GetGDISurface,
4569 ddraw2_GetMonitorFrequency,
4570 ddraw2_GetScanLine,
4571 ddraw2_GetVerticalBlankStatus,
4572 ddraw2_Initialize,
4573 ddraw2_RestoreDisplayMode,
4574 ddraw2_SetCooperativeLevel,
4575 ddraw2_SetDisplayMode,
4576 ddraw2_WaitForVerticalBlank,
4577 /* IDirectDraw2 */
4578 ddraw2_GetAvailableVidMem,
4579 };
4580
4581 static const struct IDirectDrawVtbl ddraw1_vtbl =
4582 {
4583 /* IUnknown */
4584 ddraw1_QueryInterface,
4585 ddraw1_AddRef,
4586 ddraw1_Release,
4587 /* IDirectDraw */
4588 ddraw1_Compact,
4589 ddraw1_CreateClipper,
4590 ddraw1_CreatePalette,
4591 ddraw1_CreateSurface,
4592 ddraw1_DuplicateSurface,
4593 ddraw1_EnumDisplayModes,
4594 ddraw1_EnumSurfaces,
4595 ddraw1_FlipToGDISurface,
4596 ddraw1_GetCaps,
4597 ddraw1_GetDisplayMode,
4598 ddraw1_GetFourCCCodes,
4599 ddraw1_GetGDISurface,
4600 ddraw1_GetMonitorFrequency,
4601 ddraw1_GetScanLine,
4602 ddraw1_GetVerticalBlankStatus,
4603 ddraw1_Initialize,
4604 ddraw1_RestoreDisplayMode,
4605 ddraw1_SetCooperativeLevel,
4606 ddraw1_SetDisplayMode,
4607 ddraw1_WaitForVerticalBlank,
4608 };
4609
4610 static const struct IDirect3D7Vtbl d3d7_vtbl =
4611 {
4612 /* IUnknown methods */
4613 d3d7_QueryInterface,
4614 d3d7_AddRef,
4615 d3d7_Release,
4616 /* IDirect3D7 methods */
4617 d3d7_EnumDevices,
4618 d3d7_CreateDevice,
4619 d3d7_CreateVertexBuffer,
4620 d3d7_EnumZBufferFormats,
4621 d3d7_EvictManagedTextures
4622 };
4623
4624 static const struct IDirect3D3Vtbl d3d3_vtbl =
4625 {
4626 /* IUnknown methods */
4627 d3d3_QueryInterface,
4628 d3d3_AddRef,
4629 d3d3_Release,
4630 /* IDirect3D3 methods */
4631 d3d3_EnumDevices,
4632 d3d3_CreateLight,
4633 d3d3_CreateMaterial,
4634 d3d3_CreateViewport,
4635 d3d3_FindDevice,
4636 d3d3_CreateDevice,
4637 d3d3_CreateVertexBuffer,
4638 d3d3_EnumZBufferFormats,
4639 d3d3_EvictManagedTextures
4640 };
4641
4642 static const struct IDirect3D2Vtbl d3d2_vtbl =
4643 {
4644 /* IUnknown methods */
4645 d3d2_QueryInterface,
4646 d3d2_AddRef,
4647 d3d2_Release,
4648 /* IDirect3D2 methods */
4649 d3d2_EnumDevices,
4650 d3d2_CreateLight,
4651 d3d2_CreateMaterial,
4652 d3d2_CreateViewport,
4653 d3d2_FindDevice,
4654 d3d2_CreateDevice
4655 };
4656
4657 static const struct IDirect3DVtbl d3d1_vtbl =
4658 {
4659 /* IUnknown methods */
4660 d3d1_QueryInterface,
4661 d3d1_AddRef,
4662 d3d1_Release,
4663 /* IDirect3D methods */
4664 d3d1_Initialize,
4665 d3d1_EnumDevices,
4666 d3d1_CreateLight,
4667 d3d1_CreateMaterial,
4668 d3d1_CreateViewport,
4669 d3d1_FindDevice
4670 };
4671
4672 /*****************************************************************************
4673 * ddraw_find_decl
4674 *
4675 * Finds the WineD3D vertex declaration for a specific fvf, and creates one
4676 * if none was found.
4677 *
4678 * This function is in ddraw.c and the DDraw object space because D3D7
4679 * vertex buffers are created using the IDirect3D interface to the ddraw
4680 * object, so they can be valid across D3D devices(theoretically. The ddraw
4681 * object also owns the wined3d device
4682 *
4683 * Parameters:
4684 * This: Device
4685 * fvf: Fvf to find the decl for
4686 *
4687 * Returns:
4688 * NULL in case of an error, the vertex declaration for the FVF otherwise.
4689 *
4690 *****************************************************************************/
4691 struct wined3d_vertex_declaration *ddraw_find_decl(struct ddraw *This, DWORD fvf)
4692 {
4693 struct wined3d_vertex_declaration *pDecl = NULL;
4694 HRESULT hr;
4695 int p, low, high; /* deliberately signed */
4696 struct FvfToDecl *convertedDecls = This->decls;
4697
4698 TRACE("Searching for declaration for fvf %08x... ", fvf);
4699
4700 low = 0;
4701 high = This->numConvertedDecls - 1;
4702 while(low <= high) {
4703 p = (low + high) >> 1;
4704 TRACE("%d ", p);
4705 if(convertedDecls[p].fvf == fvf) {
4706 TRACE("found %p\n", convertedDecls[p].decl);
4707 return convertedDecls[p].decl;
4708 } else if(convertedDecls[p].fvf < fvf) {
4709 low = p + 1;
4710 } else {
4711 high = p - 1;
4712 }
4713 }
4714 TRACE("not found. Creating and inserting at position %d.\n", low);
4715
4716 hr = wined3d_vertex_declaration_create_from_fvf(This->wined3d_device,
4717 fvf, This, &ddraw_null_wined3d_parent_ops, &pDecl);
4718 if (hr != S_OK) return NULL;
4719
4720 if(This->declArraySize == This->numConvertedDecls) {
4721 int grow = max(This->declArraySize / 2, 8);
4722 convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls,
4723 sizeof(convertedDecls[0]) * (This->numConvertedDecls + grow));
4724 if (!convertedDecls)
4725 {
4726 wined3d_vertex_declaration_decref(pDecl);
4727 return NULL;
4728 }
4729 This->decls = convertedDecls;
4730 This->declArraySize += grow;
4731 }
4732
4733 memmove(convertedDecls + low + 1, convertedDecls + low, sizeof(convertedDecls[0]) * (This->numConvertedDecls - low));
4734 convertedDecls[low].decl = pDecl;
4735 convertedDecls[low].fvf = fvf;
4736 This->numConvertedDecls++;
4737
4738 TRACE("Returning %p. %d decls in array\n", pDecl, This->numConvertedDecls);
4739 return pDecl;
4740 }
4741
4742 static inline struct ddraw *ddraw_from_device_parent(struct wined3d_device_parent *device_parent)
4743 {
4744 return CONTAINING_RECORD(device_parent, struct ddraw, device_parent);
4745 }
4746
4747 static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent,
4748 struct wined3d_device *device)
4749 {
4750 TRACE("device_parent %p, device %p.\n", device_parent, device);
4751 }
4752
4753 /* This is run from device_process_message() in wined3d, we can't take the
4754 * wined3d mutex. */
4755 /* FIXME: We only get mode change notifications in exclusive mode, but we
4756 * should mark surfaces as lost on mode changes in DDSCL_NORMAL mode as well. */
4757 static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent)
4758 {
4759 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4760 MONITORINFO monitor_info;
4761 HMONITOR monitor;
4762 RECT *r;
4763
4764 TRACE("device_parent %p.\n", device_parent);
4765
4766 if (!(ddraw->cooperative_level & DDSCL_EXCLUSIVE) || !ddraw->swapchain_window)
4767 {
4768 TRACE("Nothing to resize.\n");
4769 return;
4770 }
4771
4772 monitor = MonitorFromWindow(ddraw->swapchain_window, MONITOR_DEFAULTTOPRIMARY);
4773 monitor_info.cbSize = sizeof(monitor_info);
4774 if (!GetMonitorInfoW(monitor, &monitor_info))
4775 {
4776 ERR("Failed to get monitor info.\n");
4777 return;
4778 }
4779
4780 r = &monitor_info.rcMonitor;
4781 TRACE("Resizing window %p to %s.\n", ddraw->swapchain_window, wine_dbgstr_rect(r));
4782
4783 if (!SetWindowPos(ddraw->swapchain_window, HWND_TOP, r->left, r->top,
4784 r->right - r->left, r->bottom - r->top, SWP_SHOWWINDOW | SWP_NOACTIVATE))
4785 ERR("Failed to resize window.\n");
4786
4787 InterlockedCompareExchange(&ddraw->device_state, DDRAW_DEVICE_STATE_NOT_RESTORED, DDRAW_DEVICE_STATE_OK);
4788 }
4789
4790 static void CDECL device_parent_activate(struct wined3d_device_parent *device_parent, BOOL activate)
4791 {
4792 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4793
4794 TRACE("device_parent %p, activate %#x.\n", device_parent, activate);
4795
4796 if (!activate)
4797 {
4798 ddraw->device_state = DDRAW_DEVICE_STATE_LOST;
4799 exclusive_window = NULL;
4800 }
4801 else
4802 {
4803 InterlockedCompareExchange(&ddraw->device_state, DDRAW_DEVICE_STATE_NOT_RESTORED, DDRAW_DEVICE_STATE_LOST);
4804 }
4805 }
4806
4807 void ddraw_update_lost_surfaces(struct ddraw *ddraw)
4808 {
4809 struct ddraw_surface *surface;
4810
4811 if (ddraw->device_state != DDRAW_DEVICE_STATE_NOT_RESTORED)
4812 return;
4813
4814 LIST_FOR_EACH_ENTRY(surface, &ddraw->surface_list, struct ddraw_surface, surface_list_entry)
4815 {
4816 surface->is_lost = TRUE;
4817 }
4818 ddraw->device_state = DDRAW_DEVICE_STATE_OK;
4819 }
4820
4821 static HRESULT CDECL device_parent_surface_created(struct wined3d_device_parent *device_parent,
4822 struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx,
4823 void **parent, const struct wined3d_parent_ops **parent_ops)
4824 {
4825 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4826 struct ddraw_surface *ddraw_surface;
4827
4828 TRACE("device_parent %p, wined3d_texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n",
4829 device_parent, wined3d_texture, sub_resource_idx, parent, parent_ops);
4830
4831 /* We have a swapchain or wined3d internal texture. */
4832 if (!wined3d_texture_get_parent(wined3d_texture) || wined3d_texture_get_parent(wined3d_texture) == ddraw)
4833 {
4834 *parent = NULL;
4835 *parent_ops = &ddraw_null_wined3d_parent_ops;
4836
4837 return DD_OK;
4838 }
4839
4840 if (!(ddraw_surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw_surface))))
4841 {
4842 ERR("Failed to allocate surface memory.\n");
4843 return DDERR_OUTOFVIDEOMEMORY;
4844 }
4845
4846 ddraw_surface_init(ddraw_surface, ddraw, wined3d_texture, sub_resource_idx, parent_ops);
4847 *parent = ddraw_surface;
4848
4849 ddraw_update_lost_surfaces(ddraw);
4850 list_add_head(&ddraw->surface_list, &ddraw_surface->surface_list_entry);
4851
4852 TRACE("Created ddraw surface %p.\n", ddraw_surface);
4853
4854 return DD_OK;
4855 }
4856
4857 static HRESULT CDECL device_parent_volume_created(struct wined3d_device_parent *device_parent,
4858 struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx,
4859 void **parent, const struct wined3d_parent_ops **parent_ops)
4860 {
4861 TRACE("device_parent %p, texture %p, sub_resource_idx %u, parent %p, parent_ops %p.\n",
4862 device_parent, wined3d_texture, sub_resource_idx, parent, parent_ops);
4863
4864 *parent = NULL;
4865 *parent_ops = &ddraw_null_wined3d_parent_ops;
4866
4867 return DD_OK;
4868 }
4869
4870 static void STDMETHODCALLTYPE ddraw_frontbuffer_destroyed(void *parent)
4871 {
4872 struct ddraw *ddraw = parent;
4873 ddraw->wined3d_frontbuffer = NULL;
4874 }
4875
4876 static const struct wined3d_parent_ops ddraw_frontbuffer_parent_ops =
4877 {
4878 ddraw_frontbuffer_destroyed,
4879 };
4880
4881 static HRESULT CDECL device_parent_create_swapchain_texture(struct wined3d_device_parent *device_parent,
4882 void *container_parent, const struct wined3d_resource_desc *desc, DWORD texture_flags,
4883 struct wined3d_texture **texture)
4884 {
4885 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4886 HRESULT hr;
4887
4888 TRACE("device_parent %p, container_parent %p, desc %p, texture flags %#x, texture %p.\n",
4889 device_parent, container_parent, desc, texture_flags, texture);
4890
4891 if (ddraw->wined3d_frontbuffer)
4892 {
4893 ERR("Frontbuffer already created.\n");
4894 return E_FAIL;
4895 }
4896
4897 if (FAILED(hr = wined3d_texture_create(ddraw->wined3d_device, desc, 1, 1,
4898 texture_flags | WINED3D_TEXTURE_CREATE_MAPPABLE, NULL, ddraw, &ddraw_frontbuffer_parent_ops, texture)))
4899 {
4900 WARN("Failed to create texture, hr %#x.\n", hr);
4901 return hr;
4902 }
4903
4904 ddraw->wined3d_frontbuffer = *texture;
4905
4906 return hr;
4907 }
4908
4909 static HRESULT CDECL device_parent_create_swapchain(struct wined3d_device_parent *device_parent,
4910 struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **swapchain)
4911 {
4912 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
4913 HRESULT hr;
4914
4915 TRACE("device_parent %p, desc %p, swapchain %p.\n", device_parent, desc, swapchain);
4916
4917 if (ddraw->wined3d_swapchain)
4918 {
4919 ERR("Swapchain already created.\n");
4920 return E_FAIL;
4921 }
4922
4923 if (FAILED(hr = wined3d_swapchain_create(ddraw->wined3d_device, desc, NULL,
4924 &ddraw_null_wined3d_parent_ops, swapchain)))
4925 WARN("Failed to create swapchain, hr %#x.\n", hr);
4926
4927 return hr;
4928 }
4929
4930 static const struct wined3d_device_parent_ops ddraw_wined3d_device_parent_ops =
4931 {
4932 device_parent_wined3d_device_created,
4933 device_parent_mode_changed,
4934 device_parent_activate,
4935 device_parent_surface_created,
4936 device_parent_volume_created,
4937 device_parent_create_swapchain_texture,
4938 device_parent_create_swapchain,
4939 };
4940
4941 HRESULT ddraw_init(struct ddraw *ddraw, DWORD flags, enum wined3d_device_type device_type)
4942 {
4943 WINED3DCAPS caps;
4944 HRESULT hr;
4945
4946 ddraw->IDirectDraw7_iface.lpVtbl = &ddraw7_vtbl;
4947 ddraw->IDirectDraw_iface.lpVtbl = &ddraw1_vtbl;
4948 ddraw->IDirectDraw2_iface.lpVtbl = &ddraw2_vtbl;
4949 ddraw->IDirectDraw4_iface.lpVtbl = &ddraw4_vtbl;
4950 ddraw->IDirect3D_iface.lpVtbl = &d3d1_vtbl;
4951 ddraw->IDirect3D2_iface.lpVtbl = &d3d2_vtbl;
4952 ddraw->IDirect3D3_iface.lpVtbl = &d3d3_vtbl;
4953 ddraw->IDirect3D7_iface.lpVtbl = &d3d7_vtbl;
4954 ddraw->device_parent.ops = &ddraw_wined3d_device_parent_ops;
4955 ddraw->numIfaces = 1;
4956 ddraw->ref7 = 1;
4957
4958 flags |= DDRAW_WINED3D_FLAGS;
4959 if (!(ddraw->wined3d = wined3d_create(flags)))
4960 {
4961 flags |= WINED3D_NO3D;
4962 if (!(ddraw->wined3d = wined3d_create(flags)))
4963 {
4964 WARN("Failed to create a wined3d object.\n");
4965 return E_FAIL;
4966 }
4967 }
4968
4969 if (FAILED(hr = wined3d_get_device_caps(ddraw->wined3d, WINED3DADAPTER_DEFAULT, device_type, &caps)))
4970 {
4971 ERR("Failed to get device caps, hr %#x.\n", hr);
4972 wined3d_decref(ddraw->wined3d);
4973 return E_FAIL;
4974 }
4975
4976 if (!(caps.ddraw_caps.caps & WINEDDCAPS_3D))
4977 {
4978 WARN("Created a wined3d object without 3D support.\n");
4979 ddraw->flags |= DDRAW_NO3D;
4980 }
4981
4982 if (FAILED(hr = wined3d_device_create(ddraw->wined3d, WINED3DADAPTER_DEFAULT, device_type,
4983 NULL, 0, DDRAW_STRIDE_ALIGNMENT, &ddraw->device_parent, &ddraw->wined3d_device)))
4984 {
4985 WARN("Failed to create a wined3d device, hr %#x.\n", hr);
4986 wined3d_decref(ddraw->wined3d);
4987 return hr;
4988 }
4989
4990 list_init(&ddraw->surface_list);
4991
4992 return DD_OK;
4993 }
Windows API implementation