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