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
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #include "wine/port.h"
26 #include "ddraw_private.h"
28 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
30 /* Device identifier. Don't relay it to WineD3D */
31 static const DDDEVICEIDENTIFIER2 deviceidentifier =
35 { { 0x00010001, 0x00010001 } },
37 /* a8373c10-7ac4-4deb-849a-009844d08b2d */
38 {0xa8373c10,0x7ac4,0x4deb, {0x84,0x9a,0x00,0x98,0x44,0xd0,0x8b,0x2d}},
42 static struct enum_device_entry
44 char interface_name[100];
45 char device_name[100];
46 const GUID *device_guid;
51 "WINE Direct3D7 Hardware Transform and Lighting acceleration using WineD3D",
53 &IID_IDirect3DTnLHalDevice,
58 "WINE Direct3D7 Hardware acceleration using WineD3D",
60 &IID_IDirect3DHALDevice,
65 "WINE Direct3D7 RGB Software Emulation using WineD3D",
67 &IID_IDirect3DRGBDevice,
71 static void STDMETHODCALLTYPE ddraw_null_wined3d_object_destroyed(void *parent) {}
73 const struct wined3d_parent_ops ddraw_null_wined3d_parent_ops =
75 ddraw_null_wined3d_object_destroyed,
78 static inline struct ddraw *impl_from_IDirectDraw(IDirectDraw *iface)
80 return CONTAINING_RECORD(iface, struct ddraw, IDirectDraw_iface);
83 static inline struct ddraw *impl_from_IDirectDraw2(IDirectDraw2 *iface)
85 return CONTAINING_RECORD(iface, struct ddraw, IDirectDraw2_iface);
88 static inline struct ddraw *impl_from_IDirectDraw4(IDirectDraw4 *iface)
90 return CONTAINING_RECORD(iface, struct ddraw, IDirectDraw4_iface);
93 static inline struct ddraw *impl_from_IDirectDraw7(IDirectDraw7 *iface)
95 return CONTAINING_RECORD(iface, struct ddraw, IDirectDraw7_iface);
98 static inline struct ddraw *impl_from_IDirect3D(IDirect3D *iface)
100 return CONTAINING_RECORD(iface, struct ddraw, IDirect3D_iface);
103 static inline struct ddraw *impl_from_IDirect3D2(IDirect3D2 *iface)
105 return CONTAINING_RECORD(iface, struct ddraw, IDirect3D2_iface);
108 static inline struct ddraw *impl_from_IDirect3D3(IDirect3D3 *iface)
110 return CONTAINING_RECORD(iface, struct ddraw, IDirect3D3_iface);
113 static inline struct ddraw *impl_from_IDirect3D7(IDirect3D7 *iface)
115 return CONTAINING_RECORD(iface, struct ddraw, IDirect3D7_iface);
118 /*****************************************************************************
120 *****************************************************************************/
122 /*****************************************************************************
123 * IDirectDraw7::QueryInterface
125 * Queries different interfaces of the DirectDraw object. It can return
126 * IDirectDraw interfaces in version 1, 2, 4 and 7, and IDirect3D interfaces
127 * in version 1, 2, 3 and 7. An IDirect3DDevice can be created with this
129 * The returned interface is AddRef()-ed before it's returned
131 * Used for version 1, 2, 4 and 7
134 * refiid: Interface ID asked for
135 * obj: Used to return the interface pointer
138 * S_OK if an interface was found
139 * E_NOINTERFACE if the requested interface wasn't found
141 *****************************************************************************/
142 static HRESULT WINAPI ddraw7_QueryInterface(IDirectDraw7 *iface, REFIID refiid, void **obj)
144 struct ddraw *This = impl_from_IDirectDraw7(iface);
146 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(refiid), obj);
148 /* Can change surface impl type */
149 wined3d_mutex_lock();
151 /* According to COM docs, if the QueryInterface fails, obj should be set to NULL */
156 wined3d_mutex_unlock();
157 return DDERR_INVALIDPARAMS;
160 /* Check DirectDraw Interfaces */
161 if ( IsEqualGUID( &IID_IUnknown, refiid ) ||
162 IsEqualGUID( &IID_IDirectDraw7, refiid ) )
164 *obj = &This->IDirectDraw7_iface;
165 TRACE("(%p) Returning IDirectDraw7 interface at %p\n", This, *obj);
167 else if ( IsEqualGUID( &IID_IDirectDraw4, refiid ) )
169 *obj = &This->IDirectDraw4_iface;
170 TRACE("(%p) Returning IDirectDraw4 interface at %p\n", This, *obj);
172 else if ( IsEqualGUID( &IID_IDirectDraw3, refiid ) )
174 /* This Interface exists in ddrawex.dll, it is implemented in a wrapper */
175 WARN("IDirectDraw3 is not valid in ddraw.dll\n");
177 wined3d_mutex_unlock();
178 return E_NOINTERFACE;
180 else if ( IsEqualGUID( &IID_IDirectDraw2, refiid ) )
182 *obj = &This->IDirectDraw2_iface;
183 TRACE("(%p) Returning IDirectDraw2 interface at %p\n", This, *obj);
185 else if ( IsEqualGUID( &IID_IDirectDraw, refiid ) )
187 *obj = &This->IDirectDraw_iface;
188 TRACE("(%p) Returning IDirectDraw interface at %p\n", This, *obj);
192 * The refcount unit test revealed that an IDirect3D7 interface can only be queried
193 * from a DirectDraw object that was created as an IDirectDraw7 interface. No idea
194 * who had this idea and why. The older interfaces can query and IDirect3D version
195 * because they are all created as IDirectDraw(1). This isn't really crucial behavior,
196 * and messy to implement with the common creation function, so it has been left out here.
198 else if ( IsEqualGUID( &IID_IDirect3D , refiid ) ||
199 IsEqualGUID( &IID_IDirect3D2 , refiid ) ||
200 IsEqualGUID( &IID_IDirect3D3 , refiid ) ||
201 IsEqualGUID( &IID_IDirect3D7 , refiid ) )
203 /* Check the surface implementation */
204 if (DefaultSurfaceType != WINED3D_SURFACE_TYPE_OPENGL)
206 WARN("The app requests a Direct3D interface, but non-opengl surfaces where set in winecfg\n");
207 /* Do not abort here, only reject 3D Device creation */
210 if ( IsEqualGUID( &IID_IDirect3D , refiid ) )
212 This->d3dversion = 1;
213 *obj = &This->IDirect3D_iface;
214 TRACE(" returning Direct3D interface at %p.\n", *obj);
216 else if ( IsEqualGUID( &IID_IDirect3D2 , refiid ) )
218 This->d3dversion = 2;
219 *obj = &This->IDirect3D2_iface;
220 TRACE(" returning Direct3D2 interface at %p.\n", *obj);
222 else if ( IsEqualGUID( &IID_IDirect3D3 , refiid ) )
224 This->d3dversion = 3;
225 *obj = &This->IDirect3D3_iface;
226 TRACE(" returning Direct3D3 interface at %p.\n", *obj);
228 else if(IsEqualGUID( &IID_IDirect3D7 , refiid ))
230 This->d3dversion = 7;
231 *obj = &This->IDirect3D7_iface;
232 TRACE(" returning Direct3D7 interface at %p.\n", *obj);
235 /* Unknown interface */
238 ERR("(%p)->(%s, %p): No interface found\n", This, debugstr_guid(refiid), obj);
239 wined3d_mutex_unlock();
240 return E_NOINTERFACE;
243 IUnknown_AddRef( (IUnknown *) *obj );
244 wined3d_mutex_unlock();
249 static HRESULT WINAPI ddraw4_QueryInterface(IDirectDraw4 *iface, REFIID riid, void **object)
251 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
253 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
255 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
258 static HRESULT WINAPI ddraw2_QueryInterface(IDirectDraw2 *iface, REFIID riid, void **object)
260 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
262 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
264 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
267 static HRESULT WINAPI ddraw1_QueryInterface(IDirectDraw *iface, REFIID riid, void **object)
269 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
271 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
273 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
276 static HRESULT WINAPI d3d7_QueryInterface(IDirect3D7 *iface, REFIID riid, void **object)
278 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
280 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
282 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
285 static HRESULT WINAPI d3d3_QueryInterface(IDirect3D3 *iface, REFIID riid, void **object)
287 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
289 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
291 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
294 static HRESULT WINAPI d3d2_QueryInterface(IDirect3D2 *iface, REFIID riid, void **object)
296 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
298 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
300 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
303 static HRESULT WINAPI d3d1_QueryInterface(IDirect3D *iface, REFIID riid, void **object)
305 struct ddraw *ddraw = impl_from_IDirect3D(iface);
307 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
309 return ddraw7_QueryInterface(&ddraw->IDirectDraw7_iface, riid, object);
312 /*****************************************************************************
313 * IDirectDraw7::AddRef
315 * Increases the interfaces refcount, basically
317 * DDraw refcounting is a bit tricky. The different DirectDraw interface
318 * versions have individual refcounts, but the IDirect3D interfaces do not.
319 * All interfaces are from one object, that means calling QueryInterface on an
320 * IDirectDraw7 interface for an IDirectDraw4 interface does not create a new
323 * That means all AddRef and Release implementations of IDirectDrawX work
324 * with their own counter, and IDirect3DX::AddRef thunk to IDirectDraw (1),
325 * except of IDirect3D7 which thunks to IDirectDraw7
327 * Returns: The new refcount
329 *****************************************************************************/
330 static ULONG WINAPI ddraw7_AddRef(IDirectDraw7 *iface)
332 struct ddraw *This = impl_from_IDirectDraw7(iface);
333 ULONG ref = InterlockedIncrement(&This->ref7);
335 TRACE("%p increasing refcount to %u.\n", This, ref);
337 if(ref == 1) InterlockedIncrement(&This->numIfaces);
342 static ULONG WINAPI ddraw4_AddRef(IDirectDraw4 *iface)
344 struct ddraw *This = impl_from_IDirectDraw4(iface);
345 ULONG ref = InterlockedIncrement(&This->ref4);
347 TRACE("%p increasing refcount to %u.\n", This, ref);
349 if (ref == 1) InterlockedIncrement(&This->numIfaces);
354 static ULONG WINAPI ddraw2_AddRef(IDirectDraw2 *iface)
356 struct ddraw *This = impl_from_IDirectDraw2(iface);
357 ULONG ref = InterlockedIncrement(&This->ref2);
359 TRACE("%p increasing refcount to %u.\n", This, ref);
361 if (ref == 1) InterlockedIncrement(&This->numIfaces);
366 static ULONG WINAPI ddraw1_AddRef(IDirectDraw *iface)
368 struct ddraw *This = impl_from_IDirectDraw(iface);
369 ULONG ref = InterlockedIncrement(&This->ref1);
371 TRACE("%p increasing refcount to %u.\n", This, ref);
373 if (ref == 1) InterlockedIncrement(&This->numIfaces);
378 static ULONG WINAPI d3d7_AddRef(IDirect3D7 *iface)
380 struct ddraw *This = impl_from_IDirect3D7(iface);
382 TRACE("iface %p.\n", iface);
384 return ddraw7_AddRef(&This->IDirectDraw7_iface);
387 static ULONG WINAPI d3d3_AddRef(IDirect3D3 *iface)
389 struct ddraw *This = impl_from_IDirect3D3(iface);
391 TRACE("iface %p.\n", iface);
393 return ddraw1_AddRef(&This->IDirectDraw_iface);
396 static ULONG WINAPI d3d2_AddRef(IDirect3D2 *iface)
398 struct ddraw *This = impl_from_IDirect3D2(iface);
400 TRACE("iface %p.\n", iface);
402 return ddraw1_AddRef(&This->IDirectDraw_iface);
405 static ULONG WINAPI d3d1_AddRef(IDirect3D *iface)
407 struct ddraw *This = impl_from_IDirect3D(iface);
409 TRACE("iface %p.\n", iface);
411 return ddraw1_AddRef(&This->IDirectDraw_iface);
414 void ddraw_destroy_swapchain(struct ddraw *ddraw)
416 TRACE("Destroying the swapchain.\n");
418 wined3d_swapchain_decref(ddraw->wined3d_swapchain);
419 ddraw->wined3d_swapchain = NULL;
421 if (DefaultSurfaceType == WINED3D_SURFACE_TYPE_OPENGL)
425 for (i = 0; i < ddraw->numConvertedDecls; ++i)
427 wined3d_vertex_declaration_decref(ddraw->decls[i].decl);
429 HeapFree(GetProcessHeap(), 0, ddraw->decls);
430 ddraw->numConvertedDecls = 0;
432 if (FAILED(wined3d_device_uninit_3d(ddraw->wined3d_device)))
434 ERR("Failed to uninit 3D.\n");
438 /* Free the d3d window if one was created. */
439 if (ddraw->d3d_window && ddraw->d3d_window != ddraw->dest_window)
441 TRACE("Destroying the hidden render window %p.\n", ddraw->d3d_window);
442 DestroyWindow(ddraw->d3d_window);
443 ddraw->d3d_window = 0;
447 ddraw->d3d_initialized = FALSE;
451 wined3d_device_uninit_gdi(ddraw->wined3d_device);
454 ddraw_set_swapchain_window(ddraw, NULL);
456 TRACE("Swapchain destroyed.\n");
459 /*****************************************************************************
462 * Destroys a ddraw object if all refcounts are 0. This is to share code
463 * between the IDirectDrawX::Release functions
466 * This: DirectDraw object to destroy
468 *****************************************************************************/
469 static void ddraw_destroy(struct ddraw *This)
471 IDirectDraw7_SetCooperativeLevel(&This->IDirectDraw7_iface, NULL, DDSCL_NORMAL);
472 IDirectDraw7_RestoreDisplayMode(&This->IDirectDraw7_iface);
474 /* Destroy the device window if we created one */
475 if(This->devicewindow != 0)
477 TRACE(" (%p) Destroying the device window %p\n", This, This->devicewindow);
478 DestroyWindow(This->devicewindow);
479 This->devicewindow = 0;
482 wined3d_mutex_lock();
483 list_remove(&This->ddraw_list_entry);
484 wined3d_mutex_unlock();
486 if (This->wined3d_swapchain)
487 ddraw_destroy_swapchain(This);
488 wined3d_device_decref(This->wined3d_device);
489 wined3d_decref(This->wined3d);
491 /* Now free the object */
492 HeapFree(GetProcessHeap(), 0, This);
495 /*****************************************************************************
496 * IDirectDraw7::Release
498 * Decreases the refcount. If the refcount falls to 0, the object is destroyed
500 * Returns: The new refcount
501 *****************************************************************************/
502 static ULONG WINAPI ddraw7_Release(IDirectDraw7 *iface)
504 struct ddraw *This = impl_from_IDirectDraw7(iface);
505 ULONG ref = InterlockedDecrement(&This->ref7);
507 TRACE("%p decreasing refcount to %u.\n", This, ref);
509 if (!ref && !InterlockedDecrement(&This->numIfaces))
515 static ULONG WINAPI ddraw4_Release(IDirectDraw4 *iface)
517 struct ddraw *This = impl_from_IDirectDraw4(iface);
518 ULONG ref = InterlockedDecrement(&This->ref4);
520 TRACE("%p decreasing refcount to %u.\n", This, ref);
522 if (!ref && !InterlockedDecrement(&This->numIfaces))
528 static ULONG WINAPI ddraw2_Release(IDirectDraw2 *iface)
530 struct ddraw *This = impl_from_IDirectDraw2(iface);
531 ULONG ref = InterlockedDecrement(&This->ref2);
533 TRACE("%p decreasing refcount to %u.\n", This, ref);
535 if (!ref && !InterlockedDecrement(&This->numIfaces))
541 static ULONG WINAPI ddraw1_Release(IDirectDraw *iface)
543 struct ddraw *This = impl_from_IDirectDraw(iface);
544 ULONG ref = InterlockedDecrement(&This->ref1);
546 TRACE("%p decreasing refcount to %u.\n", This, ref);
548 if (!ref && !InterlockedDecrement(&This->numIfaces))
554 static ULONG WINAPI d3d7_Release(IDirect3D7 *iface)
556 struct ddraw *This = impl_from_IDirect3D7(iface);
558 TRACE("iface %p.\n", iface);
560 return ddraw7_Release(&This->IDirectDraw7_iface);
563 static ULONG WINAPI d3d3_Release(IDirect3D3 *iface)
565 struct ddraw *This = impl_from_IDirect3D3(iface);
567 TRACE("iface %p.\n", iface);
569 return ddraw1_Release(&This->IDirectDraw_iface);
572 static ULONG WINAPI d3d2_Release(IDirect3D2 *iface)
574 struct ddraw *This = impl_from_IDirect3D2(iface);
576 TRACE("iface %p.\n", iface);
578 return ddraw1_Release(&This->IDirectDraw_iface);
581 static ULONG WINAPI d3d1_Release(IDirect3D *iface)
583 struct ddraw *This = impl_from_IDirect3D(iface);
585 TRACE("iface %p.\n", iface);
587 return ddraw1_Release(&This->IDirectDraw_iface);
590 /*****************************************************************************
591 * IDirectDraw methods
592 *****************************************************************************/
594 static HRESULT ddraw_set_focus_window(struct ddraw *ddraw, HWND window)
596 /* FIXME: This looks wrong, exclusive mode should imply a destination
598 if ((ddraw->cooperative_level & DDSCL_EXCLUSIVE) && ddraw->dest_window)
600 TRACE("Setting DDSCL_SETFOCUSWINDOW with an already set window, returning DDERR_HWNDALREADYSET.\n");
601 return DDERR_HWNDALREADYSET;
604 ddraw->focuswindow = window;
606 /* Use the focus window for drawing too. */
607 ddraw->dest_window = ddraw->focuswindow;
612 static HRESULT ddraw_attach_d3d_device(struct ddraw *ddraw,
613 struct wined3d_swapchain_desc *swapchain_desc)
615 HWND window = swapchain_desc->device_window;
618 TRACE("ddraw %p.\n", ddraw);
620 if (!window || window == GetDesktopWindow())
622 window = CreateWindowExA(0, DDRAW_WINDOW_CLASS_NAME, "Hidden D3D Window",
623 WS_DISABLED, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
624 NULL, NULL, NULL, NULL);
627 ERR("Failed to create window, last error %#x.\n", GetLastError());
631 ShowWindow(window, SW_HIDE); /* Just to be sure */
632 WARN("No window for the Direct3DDevice, created hidden window %p.\n", window);
634 swapchain_desc->device_window = window;
638 TRACE("Using existing window %p for Direct3D rendering.\n", window);
640 ddraw->d3d_window = window;
642 /* Set this NOW, otherwise creating the depth stencil surface will cause a
643 * recursive loop until ram or emulated video memory is full. */
644 ddraw->d3d_initialized = TRUE;
645 hr = wined3d_device_init_3d(ddraw->wined3d_device, swapchain_desc);
648 ddraw->d3d_initialized = FALSE;
652 ddraw->declArraySize = 2;
653 ddraw->decls = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw->decls) * ddraw->declArraySize);
656 ERR("Error allocating an array for the converted vertex decls.\n");
657 ddraw->declArraySize = 0;
658 hr = wined3d_device_uninit_3d(ddraw->wined3d_device);
659 return E_OUTOFMEMORY;
662 TRACE("Successfully initialized 3D.\n");
667 static HRESULT ddraw_create_swapchain(struct ddraw *ddraw, HWND window, BOOL windowed)
669 struct wined3d_swapchain_desc swapchain_desc;
670 struct wined3d_display_mode mode;
671 HRESULT hr = WINED3D_OK;
673 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode)))
675 ERR("Failed to get display mode.\n");
679 memset(&swapchain_desc, 0, sizeof(swapchain_desc));
680 swapchain_desc.backbuffer_width = mode.width;
681 swapchain_desc.backbuffer_height = mode.height;
682 swapchain_desc.backbuffer_format = mode.format_id;
683 swapchain_desc.swap_effect = WINED3D_SWAP_EFFECT_COPY;
684 swapchain_desc.device_window = window;
685 swapchain_desc.windowed = windowed;
687 if (DefaultSurfaceType == WINED3D_SURFACE_TYPE_OPENGL)
688 hr = ddraw_attach_d3d_device(ddraw, &swapchain_desc);
690 hr = wined3d_device_init_gdi(ddraw->wined3d_device, &swapchain_desc);
694 ERR("Failed to create swapchain, hr %#x.\n", hr);
698 if (FAILED(hr = wined3d_device_get_swapchain(ddraw->wined3d_device, 0, &ddraw->wined3d_swapchain)))
700 ERR("Failed to get swapchain, hr %#x.\n", hr);
701 ddraw->wined3d_swapchain = NULL;
705 ddraw_set_swapchain_window(ddraw, window);
710 /*****************************************************************************
711 * IDirectDraw7::SetCooperativeLevel
713 * Sets the cooperative level for the DirectDraw object, and the window
714 * assigned to it. The cooperative level determines the general behavior
715 * of the DirectDraw application
717 * Warning: This is quite tricky, as it's not really documented which
718 * cooperative levels can be combined with each other. If a game fails
719 * after this function, try to check the cooperative levels passed on
720 * Windows, and if it returns something different.
722 * If you think that this function caused the failure because it writes a
723 * fixme, be sure to run again with a +ddraw trace.
725 * What is known about cooperative levels (See the ddraw modes test):
726 * DDSCL_EXCLUSIVE and DDSCL_FULLSCREEN must be used with each other
727 * DDSCL_NORMAL is not compatible with DDSCL_EXCLUSIVE or DDSCL_FULLSCREEN
728 * DDSCL_SETFOCUSWINDOW can be passed only in DDSCL_NORMAL mode, but after that
729 * DDSCL_FULLSCREEN can be activated
730 * DDSCL_SETFOCUSWINDOW may only be used with DDSCL_NOWINDOWCHANGES
732 * Handled flags: DDSCL_NORMAL, DDSCL_FULLSCREEN, DDSCL_EXCLUSIVE,
733 * DDSCL_SETFOCUSWINDOW (partially),
734 * DDSCL_MULTITHREADED (work in progress)
736 * Unhandled flags, which should be implemented
737 * DDSCL_SETDEVICEWINDOW: Sets a window specially used for rendering (I don't
738 * expect any difference to a normal window for wine)
739 * DDSCL_CREATEDEVICEWINDOW: Tells ddraw to create its own window for
740 * rendering (Possible test case: Half-Life)
742 * Unsure about these: DDSCL_FPUSETUP DDSCL_FPURESERVE
744 * These don't seem very important for wine:
745 * DDSCL_ALLOWREBOOT, DDSCL_NOWINDOWCHANGES, DDSCL_ALLOWMODEX
748 * DD_OK if the cooperative level was set successfully
749 * DDERR_INVALIDPARAMS if the passed cooperative level combination is invalid
750 * DDERR_HWNDALREADYSET if DDSCL_SETFOCUSWINDOW is passed in exclusive mode
751 * (Probably others too, have to investigate)
753 *****************************************************************************/
754 static HRESULT WINAPI ddraw7_SetCooperativeLevel(IDirectDraw7 *iface, HWND hwnd, DWORD cooplevel)
756 struct ddraw *This = impl_from_IDirectDraw7(iface);
757 struct wined3d_stateblock *stateblock;
758 struct wined3d_surface *rt, *ds;
759 BOOL restore_state = FALSE;
763 TRACE("iface %p, window %p, flags %#x.\n", iface, hwnd, cooplevel);
764 DDRAW_dump_cooperativelevel(cooplevel);
766 wined3d_mutex_lock();
768 /* Get the old window */
769 window = This->dest_window;
771 /* Tests suggest that we need one of them: */
772 if(!(cooplevel & (DDSCL_SETFOCUSWINDOW |
776 TRACE("Incorrect cooplevel flags, returning DDERR_INVALIDPARAMS\n");
777 wined3d_mutex_unlock();
778 return DDERR_INVALIDPARAMS;
781 if ((cooplevel & DDSCL_CREATEDEVICEWINDOW) && !(cooplevel & DDSCL_EXCLUSIVE))
783 WARN("DDSCL_CREATEDEVICEWINDOW requires DDSCL_EXCLUSIVE.\n");
784 wined3d_mutex_unlock();
785 return DDERR_INVALIDPARAMS;
788 /* Handle those levels first which set various hwnds */
789 if ((cooplevel & DDSCL_SETFOCUSWINDOW) && !(cooplevel & DDSCL_CREATEDEVICEWINDOW))
791 /* This isn't compatible with a lot of flags */
792 if (cooplevel & (DDSCL_MULTITHREADED
797 | DDSCL_SETDEVICEWINDOW
802 WARN("Called with incompatible flags, returning DDERR_INVALIDPARAMS.\n");
803 wined3d_mutex_unlock();
804 return DDERR_INVALIDPARAMS;
807 hr = ddraw_set_focus_window(This, hwnd);
808 wined3d_mutex_unlock();
812 if (cooplevel & DDSCL_EXCLUSIVE)
814 if (!(cooplevel & DDSCL_FULLSCREEN) || !(hwnd || (cooplevel & DDSCL_CREATEDEVICEWINDOW)))
816 WARN("DDSCL_EXCLUSIVE requires DDSCL_FULLSCREEN and a window.\n");
817 wined3d_mutex_unlock();
818 return DDERR_INVALIDPARAMS;
821 if (cooplevel & DDSCL_CREATEDEVICEWINDOW)
825 if (!This->focuswindow && !(cooplevel & DDSCL_SETFOCUSWINDOW))
827 WARN("No focus window set.\n");
828 wined3d_mutex_unlock();
829 return DDERR_NOFOCUSWINDOW;
832 device_window = CreateWindowExA(0, DDRAW_WINDOW_CLASS_NAME, "DirectDrawDeviceWnd",
833 WS_POPUP, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
834 NULL, NULL, NULL, NULL);
837 ERR("Failed to create window, last error %#x.\n", GetLastError());
838 wined3d_mutex_unlock();
842 ShowWindow(device_window, SW_SHOW);
843 TRACE("Created a device window %p.\n", device_window);
845 /* Native apparently leaks the created device window if setting the
846 * focus window below fails. */
847 This->cooperative_level |= DDSCL_CREATEDEVICEWINDOW;
848 This->devicewindow = device_window;
850 if (cooplevel & DDSCL_SETFOCUSWINDOW)
854 wined3d_mutex_unlock();
858 if (FAILED(hr = ddraw_set_focus_window(This, hwnd)))
860 wined3d_mutex_unlock();
865 hwnd = device_window;
870 if (This->cooperative_level & DDSCL_CREATEDEVICEWINDOW)
871 DestroyWindow(This->devicewindow);
872 This->devicewindow = NULL;
873 This->focuswindow = NULL;
876 if ((This->cooperative_level & DDSCL_EXCLUSIVE)
877 && (hwnd != window || !(cooplevel & DDSCL_EXCLUSIVE)))
878 wined3d_device_release_focus_window(This->wined3d_device);
880 if ((cooplevel & DDSCL_FULLSCREEN) != (This->cooperative_level & DDSCL_FULLSCREEN) || hwnd != window)
882 if (This->cooperative_level & DDSCL_FULLSCREEN)
883 wined3d_device_restore_fullscreen_window(This->wined3d_device, window);
885 if (cooplevel & DDSCL_FULLSCREEN)
887 struct wined3d_display_mode display_mode;
889 wined3d_get_adapter_display_mode(This->wined3d, WINED3DADAPTER_DEFAULT, &display_mode);
890 wined3d_device_setup_fullscreen_window(This->wined3d_device, hwnd,
891 display_mode.width, display_mode.height);
895 if ((cooplevel & DDSCL_EXCLUSIVE)
896 && (hwnd != window || !(This->cooperative_level & DDSCL_EXCLUSIVE)))
898 hr = wined3d_device_acquire_focus_window(This->wined3d_device, hwnd);
901 ERR("Failed to acquire focus window, hr %#x.\n", hr);
902 wined3d_mutex_unlock();
907 /* Don't override focus windows or private device windows */
908 if (hwnd && !This->focuswindow && !This->devicewindow && (hwnd != window))
909 This->dest_window = hwnd;
911 if (cooplevel & DDSCL_MULTITHREADED && !(This->cooperative_level & DDSCL_MULTITHREADED))
912 wined3d_device_set_multithreaded(This->wined3d_device);
914 if (This->wined3d_swapchain)
916 if (DefaultSurfaceType != WINED3D_SURFACE_TYPE_GDI)
918 restore_state = TRUE;
920 if (FAILED(hr = wined3d_stateblock_create(This->wined3d_device, WINED3D_SBT_ALL, &stateblock)))
922 ERR("Failed to create stateblock, hr %#x.\n", hr);
923 wined3d_mutex_unlock();
927 if (FAILED(hr = wined3d_stateblock_capture(stateblock)))
929 ERR("Failed to capture stateblock, hr %#x.\n", hr);
930 wined3d_stateblock_decref(stateblock);
931 wined3d_mutex_unlock();
935 wined3d_device_get_render_target(This->wined3d_device, 0, &rt);
936 if (rt == This->wined3d_frontbuffer)
938 wined3d_surface_decref(rt);
942 wined3d_device_get_depth_stencil(This->wined3d_device, &ds);
945 ddraw_destroy_swapchain(This);
948 if (FAILED(hr = ddraw_create_swapchain(This, This->dest_window, !(cooplevel & DDSCL_FULLSCREEN))))
949 ERR("Failed to create swapchain, hr %#x.\n", hr);
955 wined3d_device_set_depth_stencil(This->wined3d_device, ds);
956 wined3d_surface_decref(ds);
961 wined3d_device_set_render_target(This->wined3d_device, 0, rt, FALSE);
962 wined3d_surface_decref(rt);
965 hr = wined3d_stateblock_apply(stateblock);
966 wined3d_stateblock_decref(stateblock);
969 ERR("Failed to apply stateblock, hr %#x.\n", hr);
970 wined3d_mutex_unlock();
975 /* Unhandled flags */
976 if(cooplevel & DDSCL_ALLOWREBOOT)
977 WARN("(%p) Unhandled flag DDSCL_ALLOWREBOOT, harmless\n", This);
978 if(cooplevel & DDSCL_ALLOWMODEX)
979 WARN("(%p) Unhandled flag DDSCL_ALLOWMODEX, harmless\n", This);
980 if(cooplevel & DDSCL_FPUSETUP)
981 WARN("(%p) Unhandled flag DDSCL_FPUSETUP, harmless\n", This);
983 /* Store the cooperative_level */
984 This->cooperative_level = cooplevel;
985 TRACE("SetCooperativeLevel retuning DD_OK\n");
986 wined3d_mutex_unlock();
991 static HRESULT WINAPI ddraw4_SetCooperativeLevel(IDirectDraw4 *iface, HWND window, DWORD flags)
993 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
995 TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
997 return ddraw7_SetCooperativeLevel(&ddraw->IDirectDraw7_iface, window, flags);
1000 static HRESULT WINAPI ddraw2_SetCooperativeLevel(IDirectDraw2 *iface, HWND window, DWORD flags)
1002 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1004 TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1006 return ddraw7_SetCooperativeLevel(&ddraw->IDirectDraw7_iface, window, flags);
1009 static HRESULT WINAPI ddraw1_SetCooperativeLevel(IDirectDraw *iface, HWND window, DWORD flags)
1011 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1013 TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
1015 return ddraw7_SetCooperativeLevel(&ddraw->IDirectDraw7_iface, window, flags);
1018 /*****************************************************************************
1020 * Helper function for SetDisplayMode and RestoreDisplayMode
1022 * Implements DirectDraw's SetDisplayMode, but ignores the value of
1023 * ForceRefreshRate, since it is already handled by
1024 * ddraw7_SetDisplayMode. RestoreDisplayMode can use this function
1025 * without worrying that ForceRefreshRate will override the refresh rate. For
1026 * argument and return value documentation, see
1027 * ddraw7_SetDisplayMode.
1029 *****************************************************************************/
1030 static HRESULT ddraw_set_display_mode(struct ddraw *ddraw, DWORD Width, DWORD Height,
1031 DWORD BPP, DWORD RefreshRate, DWORD Flags)
1033 struct wined3d_display_mode mode;
1034 enum wined3d_format_id format;
1037 TRACE("ddraw %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n", ddraw, Width,
1038 Height, BPP, RefreshRate, Flags);
1040 wined3d_mutex_lock();
1041 if( !Width || !Height )
1043 ERR("Width %u, Height %u, what to do?\n", Width, Height);
1044 /* It looks like Need for Speed Porsche Unleashed expects DD_OK here */
1045 wined3d_mutex_unlock();
1051 case 8: format = WINED3DFMT_P8_UINT; break;
1052 case 15: format = WINED3DFMT_B5G5R5X1_UNORM; break;
1053 case 16: format = WINED3DFMT_B5G6R5_UNORM; break;
1054 case 24: format = WINED3DFMT_B8G8R8_UNORM; break;
1055 case 32: format = WINED3DFMT_B8G8R8X8_UNORM; break;
1056 default: format = WINED3DFMT_UNKNOWN; break;
1059 /* Check the exclusive mode
1060 if(!(ddraw->cooperative_level & DDSCL_EXCLUSIVE))
1061 return DDERR_NOEXCLUSIVEMODE;
1062 * This is WRONG. Don't know if the SDK is completely
1063 * wrong and if there are any conditions when DDERR_NOEXCLUSIVE
1064 * is returned, but Half-Life 1.1.1.1 (Steam version)
1069 mode.height = Height;
1070 mode.refresh_rate = RefreshRate;
1071 mode.format_id = format;
1073 /* TODO: The possible return values from msdn suggest that
1074 * the screen mode can't be changed if a surface is locked
1075 * or some drawing is in progress
1078 /* TODO: Lose the primary surface */
1079 hr = wined3d_device_set_display_mode(ddraw->wined3d_device, 0, &mode);
1081 wined3d_mutex_unlock();
1085 case WINED3DERR_NOTAVAILABLE: return DDERR_UNSUPPORTED;
1090 /*****************************************************************************
1091 * IDirectDraw7::SetDisplayMode
1093 * Sets the display screen resolution, color depth and refresh frequency
1094 * when in fullscreen mode (in theory).
1095 * Possible return values listed in the SDK suggest that this method fails
1096 * when not in fullscreen mode, but this is wrong. Windows 2000 happily sets
1097 * the display mode in DDSCL_NORMAL mode without an hwnd specified.
1098 * It seems to be valid to pass 0 for With and Height, this has to be tested
1099 * It could mean that the current video mode should be left as-is. (But why
1103 * Height, Width: Screen dimension
1104 * BPP: Color depth in Bits per pixel
1105 * Refreshrate: Screen refresh rate
1106 * Flags: Other stuff
1111 *****************************************************************************/
1112 static HRESULT WINAPI ddraw7_SetDisplayMode(IDirectDraw7 *iface, DWORD Width, DWORD Height,
1113 DWORD BPP, DWORD RefreshRate, DWORD Flags)
1115 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1117 TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
1118 iface, Width, Height, BPP, RefreshRate, Flags);
1120 if (force_refresh_rate != 0)
1122 TRACE("ForceRefreshRate overriding passed-in refresh rate (%u Hz) to %u Hz\n",
1123 RefreshRate, force_refresh_rate);
1124 RefreshRate = force_refresh_rate;
1127 return ddraw_set_display_mode(ddraw, Width, Height, BPP, RefreshRate, Flags);
1130 static HRESULT WINAPI ddraw4_SetDisplayMode(IDirectDraw4 *iface, DWORD width, DWORD height,
1131 DWORD bpp, DWORD refresh_rate, DWORD flags)
1133 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1135 TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
1136 iface, width, height, bpp, refresh_rate, flags);
1138 return ddraw7_SetDisplayMode(&ddraw->IDirectDraw7_iface, width, height, bpp, refresh_rate, flags);
1141 static HRESULT WINAPI ddraw2_SetDisplayMode(IDirectDraw2 *iface,
1142 DWORD width, DWORD height, DWORD bpp, DWORD refresh_rate, DWORD flags)
1144 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1146 TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
1147 iface, width, height, bpp, refresh_rate, flags);
1149 return ddraw7_SetDisplayMode(&ddraw->IDirectDraw7_iface, width, height, bpp, refresh_rate, flags);
1152 static HRESULT WINAPI ddraw1_SetDisplayMode(IDirectDraw *iface, DWORD width, DWORD height, DWORD bpp)
1154 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1156 TRACE("iface %p, width %u, height %u, bpp %u.\n", iface, width, height, bpp);
1158 return ddraw7_SetDisplayMode(&ddraw->IDirectDraw7_iface, width, height, bpp, 0, 0);
1161 /*****************************************************************************
1162 * IDirectDraw7::RestoreDisplayMode
1164 * Restores the display mode to what it was at creation time. Basically.
1166 * A problem arises when there are 2 DirectDraw objects using the same hwnd:
1167 * -> DD_1 finds the screen at 1400x1050x32 when created, sets it to 640x480x16
1168 * -> DD_2 is created, finds the screen at 640x480x16, sets it to 1024x768x32
1169 * -> DD_1 is released. The screen should be left at 1024x768x32.
1170 * -> DD_2 is released. The screen should be set to 1400x1050x32
1171 * This case is unhandled right now, but Empire Earth does it this way.
1172 * (But perhaps there is something in SetCooperativeLevel to prevent this)
1174 * The msdn says that this method resets the display mode to what it was before
1175 * SetDisplayMode was called. What if SetDisplayModes is called 2 times??
1179 * DDERR_NOEXCLUSIVE mode if the device isn't in fullscreen mode
1181 *****************************************************************************/
1182 static HRESULT WINAPI ddraw7_RestoreDisplayMode(IDirectDraw7 *iface)
1184 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1186 TRACE("iface %p.\n", iface);
1188 return ddraw_set_display_mode(ddraw, ddraw->orig_width, ddraw->orig_height, ddraw->orig_bpp, 0, 0);
1191 static HRESULT WINAPI ddraw4_RestoreDisplayMode(IDirectDraw4 *iface)
1193 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1195 TRACE("iface %p.\n", iface);
1197 return ddraw7_RestoreDisplayMode(&ddraw->IDirectDraw7_iface);
1200 static HRESULT WINAPI ddraw2_RestoreDisplayMode(IDirectDraw2 *iface)
1202 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1204 TRACE("iface %p.\n", iface);
1206 return ddraw7_RestoreDisplayMode(&ddraw->IDirectDraw7_iface);
1209 static HRESULT WINAPI ddraw1_RestoreDisplayMode(IDirectDraw *iface)
1211 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1213 TRACE("iface %p.\n", iface);
1215 return ddraw7_RestoreDisplayMode(&ddraw->IDirectDraw7_iface);
1218 /*****************************************************************************
1219 * IDirectDraw7::GetCaps
1221 * Returns the drives capabilities
1223 * Used for version 1, 2, 4 and 7
1226 * DriverCaps: Structure to write the Hardware accelerated caps to
1227 * HelCaps: Structure to write the emulation caps to
1230 * This implementation returns DD_OK only
1232 *****************************************************************************/
1233 static HRESULT WINAPI ddraw7_GetCaps(IDirectDraw7 *iface, DDCAPS *DriverCaps, DDCAPS *HELCaps)
1235 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1237 WINED3DCAPS winecaps;
1239 DDSCAPS2 ddscaps = {0, 0, 0, 0};
1241 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, DriverCaps, HELCaps);
1243 /* One structure must be != NULL */
1244 if (!DriverCaps && !HELCaps)
1246 WARN("Invalid parameters.\n");
1247 return DDERR_INVALIDPARAMS;
1250 memset(&caps, 0, sizeof(caps));
1251 memset(&winecaps, 0, sizeof(winecaps));
1252 caps.dwSize = sizeof(caps);
1254 wined3d_mutex_lock();
1255 hr = wined3d_device_get_device_caps(ddraw->wined3d_device, &winecaps);
1258 WARN("IWineD3DDevice::GetDeviceCaps failed\n");
1259 wined3d_mutex_unlock();
1263 hr = IDirectDraw7_GetAvailableVidMem(iface, &ddscaps, &caps.dwVidMemTotal, &caps.dwVidMemFree);
1264 wined3d_mutex_unlock();
1266 WARN("IDirectDraw7::GetAvailableVidMem failed\n");
1270 caps.dwCaps = winecaps.ddraw_caps.caps;
1271 caps.dwCaps2 = winecaps.ddraw_caps.caps2;
1272 caps.dwCKeyCaps = winecaps.ddraw_caps.color_key_caps;
1273 caps.dwFXCaps = winecaps.ddraw_caps.fx_caps;
1274 caps.dwPalCaps = winecaps.ddraw_caps.pal_caps;
1275 caps.ddsCaps.dwCaps = winecaps.ddraw_caps.dds_caps;
1276 caps.dwSVBCaps = winecaps.ddraw_caps.svb_caps;
1277 caps.dwSVBCKeyCaps = winecaps.ddraw_caps.svb_color_key_caps;
1278 caps.dwSVBFXCaps = winecaps.ddraw_caps.svb_fx_caps;
1279 caps.dwVSBCaps = winecaps.ddraw_caps.vsb_caps;
1280 caps.dwVSBCKeyCaps = winecaps.ddraw_caps.vsb_color_key_caps;
1281 caps.dwVSBFXCaps = winecaps.ddraw_caps.vsb_fx_caps;
1282 caps.dwSSBCaps = winecaps.ddraw_caps.ssb_caps;
1283 caps.dwSSBCKeyCaps = winecaps.ddraw_caps.ssb_color_key_caps;
1284 caps.dwSSBFXCaps = winecaps.ddraw_caps.ssb_fx_caps;
1286 /* Even if WineD3D supports 3D rendering, remove the cap if ddraw is configured
1289 if (DefaultSurfaceType == WINED3D_SURFACE_TYPE_GDI)
1291 caps.dwCaps &= ~DDCAPS_3D;
1292 caps.ddsCaps.dwCaps &= ~(DDSCAPS_3DDEVICE | DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_ZBUFFER);
1294 if (winecaps.ddraw_caps.stride_align)
1296 caps.dwCaps |= DDCAPS_ALIGNSTRIDE;
1297 caps.dwAlignStrideAlign = winecaps.ddraw_caps.stride_align;
1302 DD_STRUCT_COPY_BYSIZE(DriverCaps, &caps);
1303 if (TRACE_ON(ddraw))
1305 TRACE("Driver Caps :\n");
1306 DDRAW_dump_DDCAPS(DriverCaps);
1312 DD_STRUCT_COPY_BYSIZE(HELCaps, &caps);
1313 if (TRACE_ON(ddraw))
1315 TRACE("HEL Caps :\n");
1316 DDRAW_dump_DDCAPS(HELCaps);
1323 static HRESULT WINAPI ddraw4_GetCaps(IDirectDraw4 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1325 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1327 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1329 return ddraw7_GetCaps(&ddraw->IDirectDraw7_iface, driver_caps, hel_caps);
1332 static HRESULT WINAPI ddraw2_GetCaps(IDirectDraw2 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1334 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1336 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1338 return ddraw7_GetCaps(&ddraw->IDirectDraw7_iface, driver_caps, hel_caps);
1341 static HRESULT WINAPI ddraw1_GetCaps(IDirectDraw *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1343 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1345 TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1347 return ddraw7_GetCaps(&ddraw->IDirectDraw7_iface, driver_caps, hel_caps);
1350 /*****************************************************************************
1351 * IDirectDraw7::Compact
1353 * No idea what it does, MSDN says it's not implemented.
1356 * DD_OK, but this is unchecked
1358 *****************************************************************************/
1359 static HRESULT WINAPI ddraw7_Compact(IDirectDraw7 *iface)
1361 TRACE("iface %p.\n", iface);
1366 static HRESULT WINAPI ddraw4_Compact(IDirectDraw4 *iface)
1368 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1370 TRACE("iface %p.\n", iface);
1372 return ddraw7_Compact(&ddraw->IDirectDraw7_iface);
1375 static HRESULT WINAPI ddraw2_Compact(IDirectDraw2 *iface)
1377 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1379 TRACE("iface %p.\n", iface);
1381 return ddraw7_Compact(&ddraw->IDirectDraw7_iface);
1384 static HRESULT WINAPI ddraw1_Compact(IDirectDraw *iface)
1386 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1388 TRACE("iface %p.\n", iface);
1390 return ddraw7_Compact(&ddraw->IDirectDraw7_iface);
1393 /*****************************************************************************
1394 * IDirectDraw7::GetDisplayMode
1396 * Returns information about the current display mode
1398 * Exists in Version 1, 2, 4 and 7
1401 * DDSD: Address of a surface description structure to write the info to
1406 *****************************************************************************/
1407 static HRESULT WINAPI ddraw7_GetDisplayMode(IDirectDraw7 *iface, DDSURFACEDESC2 *DDSD)
1409 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1410 struct wined3d_display_mode mode;
1414 TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
1416 wined3d_mutex_lock();
1417 /* This seems sane */
1420 wined3d_mutex_unlock();
1421 return DDERR_INVALIDPARAMS;
1424 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode)))
1426 ERR("Failed to get display mode, hr %#x.\n", hr);
1427 wined3d_mutex_unlock();
1431 Size = DDSD->dwSize;
1432 memset(DDSD, 0, Size);
1434 DDSD->dwSize = Size;
1435 DDSD->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
1436 DDSD->dwWidth = mode.width;
1437 DDSD->dwHeight = mode.height;
1438 DDSD->u2.dwRefreshRate = 60;
1439 DDSD->ddsCaps.dwCaps = 0;
1440 DDSD->u4.ddpfPixelFormat.dwSize = sizeof(DDSD->u4.ddpfPixelFormat);
1441 PixelFormat_WineD3DtoDD(&DDSD->u4.ddpfPixelFormat, mode.format_id);
1442 DDSD->u1.lPitch = mode.width * DDSD->u4.ddpfPixelFormat.u1.dwRGBBitCount / 8;
1446 TRACE("Returning surface desc :\n");
1447 DDRAW_dump_surface_desc(DDSD);
1450 wined3d_mutex_unlock();
1455 static HRESULT WINAPI ddraw4_GetDisplayMode(IDirectDraw4 *iface, DDSURFACEDESC2 *surface_desc)
1457 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1459 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1461 return ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, surface_desc);
1464 static HRESULT WINAPI ddraw2_GetDisplayMode(IDirectDraw2 *iface, DDSURFACEDESC *surface_desc)
1466 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1468 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1470 /* FIXME: Test sizes, properly convert surface_desc */
1471 return ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
1474 static HRESULT WINAPI ddraw1_GetDisplayMode(IDirectDraw *iface, DDSURFACEDESC *surface_desc)
1476 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1478 TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1480 /* FIXME: Test sizes, properly convert surface_desc */
1481 return ddraw7_GetDisplayMode(&ddraw->IDirectDraw7_iface, (DDSURFACEDESC2 *)surface_desc);
1484 /*****************************************************************************
1485 * IDirectDraw7::GetFourCCCodes
1487 * Returns an array of supported FourCC codes.
1489 * Exists in Version 1, 2, 4 and 7
1492 * NumCodes: Contains the number of Codes that Codes can carry. Returns the number
1493 * of enumerated codes
1494 * Codes: Pointer to an array of DWORDs where the supported codes are written
1498 * Always returns DD_OK, as it's a stub for now
1500 *****************************************************************************/
1501 static HRESULT WINAPI ddraw7_GetFourCCCodes(IDirectDraw7 *iface, DWORD *NumCodes, DWORD *Codes)
1503 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1504 static const enum wined3d_format_id formats[] =
1506 WINED3DFMT_YUY2, WINED3DFMT_UYVY, WINED3DFMT_YV12,
1507 WINED3DFMT_DXT1, WINED3DFMT_DXT2, WINED3DFMT_DXT3, WINED3DFMT_DXT4, WINED3DFMT_DXT5,
1508 WINED3DFMT_ATI2N, WINED3DFMT_NVHU, WINED3DFMT_NVHS
1510 struct wined3d_display_mode mode;
1511 DWORD count = 0, i, outsize;
1514 TRACE("iface %p, codes_count %p, codes %p.\n", iface, NumCodes, Codes);
1516 if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode)))
1518 ERR("Failed to get display mode, hr %#x.\n", hr);
1522 outsize = NumCodes && Codes ? *NumCodes : 0;
1524 for (i = 0; i < (sizeof(formats) / sizeof(formats[0])); ++i)
1526 hr = wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, WINED3D_DEVICE_TYPE_HAL,
1527 mode.format_id, 0, WINED3D_RTYPE_SURFACE, formats[i], DefaultSurfaceType);
1530 if (count < outsize)
1531 Codes[count] = formats[i];
1536 TRACE("Returning %u FourCC codes\n", count);
1543 static HRESULT WINAPI ddraw4_GetFourCCCodes(IDirectDraw4 *iface, DWORD *codes_count, DWORD *codes)
1545 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1547 TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1549 return ddraw7_GetFourCCCodes(&ddraw->IDirectDraw7_iface, codes_count, codes);
1552 static HRESULT WINAPI ddraw2_GetFourCCCodes(IDirectDraw2 *iface, DWORD *codes_count, DWORD *codes)
1554 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1556 TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1558 return ddraw7_GetFourCCCodes(&ddraw->IDirectDraw7_iface, codes_count, codes);
1561 static HRESULT WINAPI ddraw1_GetFourCCCodes(IDirectDraw *iface, DWORD *codes_count, DWORD *codes)
1563 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1565 TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1567 return ddraw7_GetFourCCCodes(&ddraw->IDirectDraw7_iface, codes_count, codes);
1570 /*****************************************************************************
1571 * IDirectDraw7::GetMonitorFrequency
1573 * Returns the monitor's frequency
1575 * Exists in Version 1, 2, 4 and 7
1578 * Freq: Pointer to a DWORD to write the frequency to
1581 * Always returns DD_OK
1583 *****************************************************************************/
1584 static HRESULT WINAPI ddraw7_GetMonitorFrequency(IDirectDraw7 *iface, DWORD *Freq)
1586 FIXME("iface %p, frequency %p stub!\n", iface, Freq);
1588 /* Ideally this should be in WineD3D, as it concerns the screen setup,
1589 * but for now this should make the games happy
1595 static HRESULT WINAPI ddraw4_GetMonitorFrequency(IDirectDraw4 *iface, DWORD *frequency)
1597 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1599 TRACE("iface %p, frequency %p.\n", iface, frequency);
1601 return ddraw7_GetMonitorFrequency(&ddraw->IDirectDraw7_iface, frequency);
1604 static HRESULT WINAPI ddraw2_GetMonitorFrequency(IDirectDraw2 *iface, DWORD *frequency)
1606 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1608 TRACE("iface %p, frequency %p.\n", iface, frequency);
1610 return ddraw7_GetMonitorFrequency(&ddraw->IDirectDraw7_iface, frequency);
1613 static HRESULT WINAPI ddraw1_GetMonitorFrequency(IDirectDraw *iface, DWORD *frequency)
1615 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1617 TRACE("iface %p, frequency %p.\n", iface, frequency);
1619 return ddraw7_GetMonitorFrequency(&ddraw->IDirectDraw7_iface, frequency);
1622 /*****************************************************************************
1623 * IDirectDraw7::GetVerticalBlankStatus
1625 * Returns the Vertical blank status of the monitor. This should be in WineD3D
1626 * too basically, but as it's a semi stub, I didn't create a function there
1629 * status: Pointer to a BOOL to be filled with the vertical blank status
1633 * DDERR_INVALIDPARAMS if status is NULL
1635 *****************************************************************************/
1636 static HRESULT WINAPI ddraw7_GetVerticalBlankStatus(IDirectDraw7 *iface, BOOL *status)
1638 static BOOL fake_vblank;
1640 TRACE("iface %p, status %p.\n", iface, status);
1643 return DDERR_INVALIDPARAMS;
1645 *status = fake_vblank;
1646 fake_vblank = !fake_vblank;
1651 static HRESULT WINAPI ddraw4_GetVerticalBlankStatus(IDirectDraw4 *iface, BOOL *status)
1653 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1655 TRACE("iface %p, status %p.\n", iface, status);
1657 return ddraw7_GetVerticalBlankStatus(&ddraw->IDirectDraw7_iface, status);
1660 static HRESULT WINAPI ddraw2_GetVerticalBlankStatus(IDirectDraw2 *iface, BOOL *status)
1662 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1664 TRACE("iface %p, status %p.\n", iface, status);
1666 return ddraw7_GetVerticalBlankStatus(&ddraw->IDirectDraw7_iface, status);
1669 static HRESULT WINAPI ddraw1_GetVerticalBlankStatus(IDirectDraw *iface, BOOL *status)
1671 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1673 TRACE("iface %p, status %p.\n", iface, status);
1675 return ddraw7_GetVerticalBlankStatus(&ddraw->IDirectDraw7_iface, status);
1678 /*****************************************************************************
1679 * IDirectDraw7::GetAvailableVidMem
1681 * Returns the total and free video memory
1684 * Caps: Specifies the memory type asked for
1685 * total: Pointer to a DWORD to be filled with the total memory
1686 * free: Pointer to a DWORD to be filled with the free memory
1690 * DDERR_INVALIDPARAMS of free and total are NULL
1692 *****************************************************************************/
1693 static HRESULT WINAPI ddraw7_GetAvailableVidMem(IDirectDraw7 *iface, DDSCAPS2 *Caps, DWORD *total,
1696 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1699 TRACE("iface %p, caps %p, total %p, free %p.\n", iface, Caps, total, free);
1701 if (TRACE_ON(ddraw))
1703 TRACE("Asked for memory with description: ");
1704 DDRAW_dump_DDSCAPS2(Caps);
1706 wined3d_mutex_lock();
1708 /* Todo: System memory vs local video memory vs non-local video memory
1709 * The MSDN also mentions differences between texture memory and other
1710 * resources, but that's not important
1713 if( (!total) && (!free) )
1715 wined3d_mutex_unlock();
1716 return DDERR_INVALIDPARAMS;
1720 *free = wined3d_device_get_available_texture_mem(ddraw->wined3d_device);
1723 struct wined3d_adapter_identifier desc = {0};
1725 hr = wined3d_get_adapter_identifier(ddraw->wined3d, WINED3DADAPTER_DEFAULT, 0, &desc);
1726 *total = desc.video_memory;
1729 wined3d_mutex_unlock();
1734 static HRESULT WINAPI ddraw4_GetAvailableVidMem(IDirectDraw4 *iface,
1735 DDSCAPS2 *caps, DWORD *total, DWORD *free)
1737 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1739 TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1741 return ddraw7_GetAvailableVidMem(&ddraw->IDirectDraw7_iface, caps, total, free);
1744 static HRESULT WINAPI ddraw2_GetAvailableVidMem(IDirectDraw2 *iface,
1745 DDSCAPS *caps, DWORD *total, DWORD *free)
1747 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1750 TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1752 DDRAW_Convert_DDSCAPS_1_To_2(caps, &caps2);
1753 return ddraw7_GetAvailableVidMem(&ddraw->IDirectDraw7_iface, &caps2, total, free);
1756 /*****************************************************************************
1757 * IDirectDraw7::Initialize
1759 * Initializes a DirectDraw interface.
1762 * GUID: Interface identifier. Well, don't know what this is really good
1766 * Returns DD_OK on the first call,
1767 * DDERR_ALREADYINITIALIZED on repeated calls
1769 *****************************************************************************/
1770 static HRESULT WINAPI ddraw7_Initialize(IDirectDraw7 *iface, GUID *guid)
1772 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1774 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1776 if (ddraw->initialized)
1777 return DDERR_ALREADYINITIALIZED;
1779 /* FIXME: To properly take the GUID into account we should call
1780 * ddraw_init() here instead of in DDRAW_Create(). */
1782 FIXME("Ignoring guid %s.\n", debugstr_guid(guid));
1784 ddraw->initialized = TRUE;
1788 static HRESULT WINAPI ddraw4_Initialize(IDirectDraw4 *iface, GUID *guid)
1790 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1792 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1794 return ddraw7_Initialize(&ddraw->IDirectDraw7_iface, guid);
1797 static HRESULT WINAPI ddraw2_Initialize(IDirectDraw2 *iface, GUID *guid)
1799 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1801 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1803 return ddraw7_Initialize(&ddraw->IDirectDraw7_iface, guid);
1806 static HRESULT WINAPI ddraw1_Initialize(IDirectDraw *iface, GUID *guid)
1808 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1810 TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1812 return ddraw7_Initialize(&ddraw->IDirectDraw7_iface, guid);
1815 static HRESULT WINAPI d3d1_Initialize(IDirect3D *iface, REFIID riid)
1817 TRACE("iface %p, riid %s.\n", iface, debugstr_guid(riid));
1819 return DDERR_ALREADYINITIALIZED;
1822 /*****************************************************************************
1823 * IDirectDraw7::FlipToGDISurface
1825 * "Makes the surface that the GDI writes to the primary surface"
1826 * Looks like some windows specific thing we don't have to care about.
1827 * According to MSDN it permits GDI dialog boxes in FULLSCREEN mode. Good to
1828 * show error boxes ;)
1829 * Well, just return DD_OK.
1832 * Always returns DD_OK
1834 *****************************************************************************/
1835 static HRESULT WINAPI ddraw7_FlipToGDISurface(IDirectDraw7 *iface)
1837 FIXME("iface %p stub!\n", iface);
1842 static HRESULT WINAPI ddraw4_FlipToGDISurface(IDirectDraw4 *iface)
1844 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1846 TRACE("iface %p.\n", iface);
1848 return ddraw7_FlipToGDISurface(&ddraw->IDirectDraw7_iface);
1851 static HRESULT WINAPI ddraw2_FlipToGDISurface(IDirectDraw2 *iface)
1853 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1855 TRACE("iface %p.\n", iface);
1857 return ddraw7_FlipToGDISurface(&ddraw->IDirectDraw7_iface);
1860 static HRESULT WINAPI ddraw1_FlipToGDISurface(IDirectDraw *iface)
1862 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1864 TRACE("iface %p.\n", iface);
1866 return ddraw7_FlipToGDISurface(&ddraw->IDirectDraw7_iface);
1869 /*****************************************************************************
1870 * IDirectDraw7::WaitForVerticalBlank
1872 * This method allows applications to get in sync with the vertical blank
1874 * The wormhole demo in the DirectX 7 sdk uses this call, and it doesn't
1875 * redraw the screen, most likely because of this stub
1878 * Flags: one of DDWAITVB_BLOCKBEGIN, DDWAITVB_BLOCKBEGINEVENT
1879 * or DDWAITVB_BLOCKEND
1880 * h: Not used, according to MSDN
1883 * Always returns DD_OK
1885 *****************************************************************************/
1886 static HRESULT WINAPI ddraw7_WaitForVerticalBlank(IDirectDraw7 *iface, DWORD Flags, HANDLE event)
1890 TRACE("iface %p, flags %#x, event %p.\n", iface, Flags, event);
1892 /* This function is called often, so print the fixme only once */
1895 FIXME("iface %p, flags %#x, event %p stub!\n", iface, Flags, event);
1899 /* MSDN says DDWAITVB_BLOCKBEGINEVENT is not supported */
1900 if(Flags & DDWAITVB_BLOCKBEGINEVENT)
1901 return DDERR_UNSUPPORTED; /* unchecked */
1906 static HRESULT WINAPI ddraw4_WaitForVerticalBlank(IDirectDraw4 *iface, DWORD flags, HANDLE event)
1908 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1910 TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
1912 return ddraw7_WaitForVerticalBlank(&ddraw->IDirectDraw7_iface, flags, event);
1915 static HRESULT WINAPI ddraw2_WaitForVerticalBlank(IDirectDraw2 *iface, DWORD flags, HANDLE event)
1917 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1919 TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
1921 return ddraw7_WaitForVerticalBlank(&ddraw->IDirectDraw7_iface, flags, event);
1924 static HRESULT WINAPI ddraw1_WaitForVerticalBlank(IDirectDraw *iface, DWORD flags, HANDLE event)
1926 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
1928 TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
1930 return ddraw7_WaitForVerticalBlank(&ddraw->IDirectDraw7_iface, flags, event);
1933 /*****************************************************************************
1934 * IDirectDraw7::GetScanLine
1936 * Returns the scan line that is being drawn on the monitor
1939 * Scanline: Address to write the scan line value to
1942 * Always returns DD_OK
1944 *****************************************************************************/
1945 static HRESULT WINAPI ddraw7_GetScanLine(IDirectDraw7 *iface, DWORD *Scanline)
1947 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
1948 struct wined3d_display_mode mode;
1949 static BOOL hide = FALSE;
1950 DWORD time, frame_progress, lines;
1952 TRACE("iface %p, line %p.\n", iface, Scanline);
1954 /* This function is called often, so print the fixme only once */
1957 FIXME("iface %p, line %p partial stub!\n", iface, Scanline);
1961 wined3d_mutex_lock();
1962 wined3d_device_get_display_mode(ddraw->wined3d_device, 0, &mode);
1963 wined3d_mutex_unlock();
1965 /* Fake the line sweeping of the monitor */
1966 /* FIXME: We should synchronize with a source to keep the refresh rate */
1968 /* Simulate a 60Hz display */
1969 time = GetTickCount();
1970 frame_progress = time & 15; /* time % (1000 / 60) */
1971 if (!frame_progress)
1974 return DDERR_VERTICALBLANKINPROGRESS;
1977 /* Convert frame_progress to estimated scan line. Return any line from
1978 * block determined by time. Some lines may be never returned */
1979 lines = mode.height / 15;
1980 *Scanline = (frame_progress - 1) * lines + time % lines;
1984 static HRESULT WINAPI ddraw4_GetScanLine(IDirectDraw4 *iface, DWORD *line)
1986 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
1988 TRACE("iface %p, line %p.\n", iface, line);
1990 return ddraw7_GetScanLine(&ddraw->IDirectDraw7_iface, line);
1993 static HRESULT WINAPI ddraw2_GetScanLine(IDirectDraw2 *iface, DWORD *line)
1995 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
1997 TRACE("iface %p, line %p.\n", iface, line);
1999 return ddraw7_GetScanLine(&ddraw->IDirectDraw7_iface, line);
2002 static HRESULT WINAPI ddraw1_GetScanLine(IDirectDraw *iface, DWORD *line)
2004 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2006 TRACE("iface %p, line %p.\n", iface, line);
2008 return ddraw7_GetScanLine(&ddraw->IDirectDraw7_iface, line);
2011 /*****************************************************************************
2012 * IDirectDraw7::TestCooperativeLevel
2014 * Informs the application about the state of the video adapter, depending
2015 * on the cooperative level
2018 * DD_OK if the device is in a sane state
2019 * DDERR_NOEXCLUSIVEMODE or DDERR_EXCLUSIVEMODEALREADYSET
2020 * if the state is not correct(See below)
2022 *****************************************************************************/
2023 static HRESULT WINAPI ddraw7_TestCooperativeLevel(IDirectDraw7 *iface)
2025 TRACE("iface %p.\n", iface);
2030 static HRESULT WINAPI ddraw4_TestCooperativeLevel(IDirectDraw4 *iface)
2032 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2034 TRACE("iface %p.\n", iface);
2036 return ddraw7_TestCooperativeLevel(&ddraw->IDirectDraw7_iface);
2039 /*****************************************************************************
2040 * IDirectDraw7::GetGDISurface
2042 * Returns the surface that GDI is treating as the primary surface.
2043 * For Wine this is the front buffer
2046 * GDISurface: Address to write the surface pointer to
2049 * DD_OK if the surface was found
2050 * DDERR_NOTFOUND if the GDI surface wasn't found
2052 *****************************************************************************/
2053 static HRESULT WINAPI ddraw7_GetGDISurface(IDirectDraw7 *iface, IDirectDrawSurface7 **GDISurface)
2055 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2057 TRACE("iface %p, surface %p.\n", iface, GDISurface);
2059 wined3d_mutex_lock();
2061 if (!(*GDISurface = &ddraw->primary->IDirectDrawSurface7_iface))
2063 WARN("Primary not created yet.\n");
2064 wined3d_mutex_unlock();
2065 return DDERR_NOTFOUND;
2067 IDirectDrawSurface7_AddRef(*GDISurface);
2069 wined3d_mutex_unlock();
2074 static HRESULT WINAPI ddraw4_GetGDISurface(IDirectDraw4 *iface, IDirectDrawSurface4 **surface)
2076 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2077 struct ddraw_surface *surface_impl;
2078 IDirectDrawSurface7 *surface7;
2081 TRACE("iface %p, surface %p.\n", iface, surface);
2083 hr = ddraw7_GetGDISurface(&ddraw->IDirectDraw7_iface, &surface7);
2089 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2090 *surface = &surface_impl->IDirectDrawSurface4_iface;
2091 IDirectDrawSurface4_AddRef(*surface);
2092 IDirectDrawSurface7_Release(surface7);
2097 static HRESULT WINAPI ddraw2_GetGDISurface(IDirectDraw2 *iface, IDirectDrawSurface **surface)
2099 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2100 struct ddraw_surface *surface_impl;
2101 IDirectDrawSurface7 *surface7;
2104 TRACE("iface %p, surface %p.\n", iface, surface);
2106 hr = ddraw7_GetGDISurface(&ddraw->IDirectDraw7_iface, &surface7);
2112 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2113 *surface = &surface_impl->IDirectDrawSurface_iface;
2114 IDirectDrawSurface_AddRef(*surface);
2115 IDirectDrawSurface7_Release(surface7);
2120 static HRESULT WINAPI ddraw1_GetGDISurface(IDirectDraw *iface, IDirectDrawSurface **surface)
2122 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2123 struct ddraw_surface *surface_impl;
2124 IDirectDrawSurface7 *surface7;
2127 TRACE("iface %p, surface %p.\n", iface, surface);
2129 hr = ddraw7_GetGDISurface(&ddraw->IDirectDraw7_iface, &surface7);
2135 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2136 *surface = &surface_impl->IDirectDrawSurface_iface;
2137 IDirectDrawSurface_AddRef(*surface);
2138 IDirectDrawSurface7_Release(surface7);
2143 struct displaymodescallback_context
2145 LPDDENUMMODESCALLBACK func;
2149 static HRESULT CALLBACK EnumDisplayModesCallbackThunk(DDSURFACEDESC2 *surface_desc, void *context)
2151 struct displaymodescallback_context *cbcontext = context;
2154 DDSD2_to_DDSD(surface_desc, &desc);
2155 return cbcontext->func(&desc, cbcontext->context);
2158 /*****************************************************************************
2159 * IDirectDraw7::EnumDisplayModes
2161 * Enumerates the supported Display modes. The modes can be filtered with
2162 * the DDSD parameter.
2165 * Flags: can be DDEDM_REFRESHRATES and DDEDM_STANDARDVGAMODES. For old ddraw
2166 * versions (3 and older?) this is reserved and must be 0.
2167 * DDSD: Surface description to filter the modes
2168 * Context: Pointer passed back to the callback function
2169 * cb: Application-provided callback function
2173 * DDERR_INVALIDPARAMS if the callback wasn't set
2175 *****************************************************************************/
2176 static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags,
2177 DDSURFACEDESC2 *DDSD, void *Context, LPDDENUMMODESCALLBACK2 cb)
2179 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2180 struct wined3d_display_mode *enum_modes = NULL;
2181 struct wined3d_display_mode mode;
2182 unsigned int modenum, fmt;
2183 DDSURFACEDESC2 callback_sd;
2184 unsigned enum_mode_count = 0, enum_mode_array_size = 0;
2185 DDPIXELFORMAT pixelformat;
2187 static const enum wined3d_format_id checkFormatList[] =
2189 WINED3DFMT_B8G8R8X8_UNORM,
2190 WINED3DFMT_B5G6R5_UNORM,
2194 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2195 iface, Flags, DDSD, Context, cb);
2198 return DDERR_INVALIDPARAMS;
2200 wined3d_mutex_lock();
2201 if(!(Flags & DDEDM_REFRESHRATES))
2203 enum_mode_array_size = 16;
2204 enum_modes = HeapAlloc(GetProcessHeap(), 0, sizeof(*enum_modes) * enum_mode_array_size);
2207 ERR("Out of memory\n");
2208 wined3d_mutex_unlock();
2209 return DDERR_OUTOFMEMORY;
2213 pixelformat.dwSize = sizeof(pixelformat);
2214 for(fmt = 0; fmt < (sizeof(checkFormatList) / sizeof(checkFormatList[0])); fmt++)
2217 while (wined3d_enum_adapter_modes(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
2218 checkFormatList[fmt], modenum++, &mode) == WINED3D_OK)
2220 PixelFormat_WineD3DtoDD(&pixelformat, mode.format_id);
2223 if (DDSD->dwFlags & DDSD_WIDTH && mode.width != DDSD->dwWidth)
2225 if (DDSD->dwFlags & DDSD_HEIGHT && mode.height != DDSD->dwHeight)
2227 if (DDSD->dwFlags & DDSD_REFRESHRATE && mode.refresh_rate != DDSD->u2.dwRefreshRate)
2229 if (DDSD->dwFlags & DDSD_PIXELFORMAT
2230 && pixelformat.u1.dwRGBBitCount != DDSD->u4.ddpfPixelFormat.u1.dwRGBBitCount)
2234 if(!(Flags & DDEDM_REFRESHRATES))
2236 /* DX docs state EnumDisplayMode should return only unique modes. If DDEDM_REFRESHRATES is not set, refresh
2237 * rate doesn't matter when determining if the mode is unique. So modes only differing in refresh rate have
2238 * to be reduced to a single unique result in such case.
2243 for (i = 0; i < enum_mode_count; i++)
2245 if (enum_modes[i].width == mode.width && enum_modes[i].height == mode.height
2246 && enum_modes[i].format_id == mode.format_id)
2256 memset(&callback_sd, 0, sizeof(callback_sd));
2257 callback_sd.dwSize = sizeof(callback_sd);
2258 callback_sd.u4.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
2260 callback_sd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|DDSD_PITCH|DDSD_REFRESHRATE;
2261 if (Flags & DDEDM_REFRESHRATES)
2262 callback_sd.u2.dwRefreshRate = mode.refresh_rate;
2264 callback_sd.dwWidth = mode.width;
2265 callback_sd.dwHeight = mode.height;
2267 callback_sd.u4.ddpfPixelFormat=pixelformat;
2269 /* Calc pitch and DWORD align like MSDN says */
2270 callback_sd.u1.lPitch = (callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount / 8) * mode.width;
2271 callback_sd.u1.lPitch = (callback_sd.u1.lPitch + 3) & ~3;
2273 TRACE("Enumerating %dx%dx%d @%d\n", callback_sd.dwWidth, callback_sd.dwHeight, callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount,
2274 callback_sd.u2.dwRefreshRate);
2276 if(cb(&callback_sd, Context) == DDENUMRET_CANCEL)
2278 TRACE("Application asked to terminate the enumeration\n");
2279 HeapFree(GetProcessHeap(), 0, enum_modes);
2280 wined3d_mutex_unlock();
2284 if(!(Flags & DDEDM_REFRESHRATES))
2286 if (enum_mode_count == enum_mode_array_size)
2288 struct wined3d_display_mode *new_enum_modes;
2290 enum_mode_array_size *= 2;
2291 new_enum_modes = HeapReAlloc(GetProcessHeap(), 0, enum_modes,
2292 sizeof(*new_enum_modes) * enum_mode_array_size);
2293 if (!new_enum_modes)
2295 ERR("Out of memory\n");
2296 HeapFree(GetProcessHeap(), 0, enum_modes);
2297 wined3d_mutex_unlock();
2298 return DDERR_OUTOFMEMORY;
2301 enum_modes = new_enum_modes;
2304 enum_modes[enum_mode_count++] = mode;
2309 TRACE("End of enumeration\n");
2310 HeapFree(GetProcessHeap(), 0, enum_modes);
2311 wined3d_mutex_unlock();
2316 static HRESULT WINAPI ddraw4_EnumDisplayModes(IDirectDraw4 *iface, DWORD flags,
2317 DDSURFACEDESC2 *surface_desc, void *context, LPDDENUMMODESCALLBACK2 callback)
2319 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2321 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2322 iface, flags, surface_desc, context, callback);
2324 return ddraw7_EnumDisplayModes(&ddraw->IDirectDraw7_iface, flags, surface_desc, context, callback);
2327 static HRESULT WINAPI ddraw2_EnumDisplayModes(IDirectDraw2 *iface, DWORD flags,
2328 DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2330 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
2331 struct displaymodescallback_context cbcontext;
2332 DDSURFACEDESC2 surface_desc2;
2334 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2335 iface, flags, surface_desc, context, callback);
2337 cbcontext.func = callback;
2338 cbcontext.context = context;
2340 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
2341 return ddraw7_EnumDisplayModes(&ddraw->IDirectDraw7_iface, flags,
2342 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumDisplayModesCallbackThunk);
2345 static HRESULT WINAPI ddraw1_EnumDisplayModes(IDirectDraw *iface, DWORD flags,
2346 DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2348 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
2349 struct displaymodescallback_context cbcontext;
2350 DDSURFACEDESC2 surface_desc2;
2352 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2353 iface, flags, surface_desc, context, callback);
2355 cbcontext.func = callback;
2356 cbcontext.context = context;
2358 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
2359 return ddraw7_EnumDisplayModes(&ddraw->IDirectDraw7_iface, flags,
2360 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumDisplayModesCallbackThunk);
2363 /*****************************************************************************
2364 * IDirectDraw7::EvaluateMode
2366 * Used with IDirectDraw7::StartModeTest to test video modes.
2367 * EvaluateMode is used to pass or fail a mode, and continue with the next
2371 * Flags: DDEM_MODEPASSED or DDEM_MODEFAILED
2372 * Timeout: Returns the amount of seconds left before the mode would have
2373 * been failed automatically
2376 * This implementation always DD_OK, because it's a stub
2378 *****************************************************************************/
2379 static HRESULT WINAPI ddraw7_EvaluateMode(IDirectDraw7 *iface, DWORD Flags, DWORD *Timeout)
2381 FIXME("iface %p, flags %#x, timeout %p stub!\n", iface, Flags, Timeout);
2383 /* When implementing this, implement it in WineD3D */
2388 /*****************************************************************************
2389 * IDirectDraw7::GetDeviceIdentifier
2391 * Returns the device identifier, which gives information about the driver
2392 * Our device identifier is defined at the beginning of this file.
2395 * DDDI: Address for the returned structure
2396 * Flags: Can be DDGDI_GETHOSTIDENTIFIER
2399 * On success it returns DD_OK
2400 * DDERR_INVALIDPARAMS if DDDI is NULL
2402 *****************************************************************************/
2403 static HRESULT WINAPI ddraw7_GetDeviceIdentifier(IDirectDraw7 *iface,
2404 DDDEVICEIDENTIFIER2 *DDDI, DWORD Flags)
2406 TRACE("iface %p, device_identifier %p, flags %#x.\n", iface, DDDI, Flags);
2409 return DDERR_INVALIDPARAMS;
2411 /* The DDGDI_GETHOSTIDENTIFIER returns the information about the 2D
2412 * host adapter, if there's a secondary 3D adapter. This doesn't apply
2413 * to any modern hardware, nor is it interesting for Wine, so ignore it.
2414 * Size of DDDEVICEIDENTIFIER2 may be aligned to 8 bytes and thus 4
2415 * bytes too long. So only copy the relevant part of the structure
2418 memcpy(DDDI, &deviceidentifier, FIELD_OFFSET(DDDEVICEIDENTIFIER2, dwWHQLLevel) + sizeof(DWORD));
2422 static HRESULT WINAPI ddraw4_GetDeviceIdentifier(IDirectDraw4 *iface,
2423 DDDEVICEIDENTIFIER *identifier, DWORD flags)
2425 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2426 DDDEVICEIDENTIFIER2 identifier2;
2429 TRACE("iface %p, identifier %p, flags %#x.\n", iface, identifier, flags);
2431 hr = ddraw7_GetDeviceIdentifier(&ddraw->IDirectDraw7_iface, &identifier2, flags);
2432 DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1(&identifier2, identifier);
2437 /*****************************************************************************
2438 * IDirectDraw7::GetSurfaceFromDC
2440 * Returns the Surface for a GDI device context handle.
2441 * Is this related to IDirectDrawSurface::GetDC ???
2444 * hdc: hdc to return the surface for
2445 * Surface: Address to write the surface pointer to
2448 * Always returns DD_OK because it's a stub
2450 *****************************************************************************/
2451 static HRESULT WINAPI ddraw7_GetSurfaceFromDC(IDirectDraw7 *iface, HDC hdc,
2452 IDirectDrawSurface7 **Surface)
2454 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
2455 struct wined3d_surface *wined3d_surface;
2456 struct ddraw_surface *surface_impl;
2459 TRACE("iface %p, dc %p, surface %p.\n", iface, hdc, Surface);
2461 if (!Surface) return E_INVALIDARG;
2463 hr = wined3d_device_get_surface_from_dc(ddraw->wined3d_device, hdc, &wined3d_surface);
2466 TRACE("No surface found for dc %p.\n", hdc);
2468 return DDERR_NOTFOUND;
2471 surface_impl = wined3d_surface_get_parent(wined3d_surface);
2472 *Surface = &surface_impl->IDirectDrawSurface7_iface;
2473 IDirectDrawSurface7_AddRef(*Surface);
2474 TRACE("Returning surface %p.\n", Surface);
2478 static HRESULT WINAPI ddraw4_GetSurfaceFromDC(IDirectDraw4 *iface, HDC dc,
2479 IDirectDrawSurface4 **surface)
2481 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2482 struct ddraw_surface *surface_impl;
2483 IDirectDrawSurface7 *surface7;
2486 TRACE("iface %p, dc %p, surface %p.\n", iface, dc, surface);
2488 if (!surface) return E_INVALIDARG;
2490 hr = ddraw7_GetSurfaceFromDC(&ddraw->IDirectDraw7_iface, dc, &surface7);
2496 surface_impl = impl_from_IDirectDrawSurface7(surface7);
2497 /* Tests say this is true */
2498 *surface = (IDirectDrawSurface4 *)&surface_impl->IDirectDrawSurface_iface;
2499 IDirectDrawSurface_AddRef(&surface_impl->IDirectDrawSurface_iface);
2500 IDirectDrawSurface7_Release(surface7);
2505 /*****************************************************************************
2506 * IDirectDraw7::RestoreAllSurfaces
2508 * Calls the restore method of all surfaces
2513 * Always returns DD_OK because it's a stub
2515 *****************************************************************************/
2516 static HRESULT WINAPI ddraw7_RestoreAllSurfaces(IDirectDraw7 *iface)
2518 FIXME("iface %p stub!\n", iface);
2520 /* This isn't hard to implement: Enumerate all WineD3D surfaces,
2521 * get their parent and call their restore method. Do not implement
2522 * it in WineD3D, as restoring a surface means re-creating the
2528 static HRESULT WINAPI ddraw4_RestoreAllSurfaces(IDirectDraw4 *iface)
2530 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
2532 TRACE("iface %p.\n", iface);
2534 return ddraw7_RestoreAllSurfaces(&ddraw->IDirectDraw7_iface);
2537 /*****************************************************************************
2538 * IDirectDraw7::StartModeTest
2540 * Tests the specified video modes to update the system registry with
2541 * refresh rate information. StartModeTest starts the mode test,
2542 * EvaluateMode is used to fail or pass a mode. If EvaluateMode
2543 * isn't called within 15 seconds, the mode is failed automatically
2545 * As refresh rates are handled by the X server, I don't think this
2546 * Method is important
2549 * Modes: An array of mode specifications
2550 * NumModes: The number of modes in Modes
2551 * Flags: Some flags...
2554 * Returns DDERR_TESTFINISHED if flags contains DDSMT_ISTESTREQUIRED,
2555 * if no modes are passed, DDERR_INVALIDPARAMS is returned,
2558 *****************************************************************************/
2559 static HRESULT WINAPI ddraw7_StartModeTest(IDirectDraw7 *iface, SIZE *Modes, DWORD NumModes, DWORD Flags)
2561 FIXME("iface %p, modes %p, mode_count %u, flags %#x partial stub!\n",
2562 iface, Modes, NumModes, Flags);
2564 /* This looks sane */
2565 if( (!Modes) || (NumModes == 0) ) return DDERR_INVALIDPARAMS;
2567 /* DDSMT_ISTESTREQUIRED asks if a mode test is necessary.
2568 * As it is not, DDERR_TESTFINISHED is returned
2569 * (hopefully that's correct
2571 if(Flags & DDSMT_ISTESTREQUIRED) return DDERR_TESTFINISHED;
2572 * well, that value doesn't (yet) exist in the wine headers, so ignore it
2578 /*****************************************************************************
2579 * ddraw_create_surface
2581 * A helper function for IDirectDraw7::CreateSurface. It creates a new surface
2582 * with the passed parameters.
2585 * DDSD: Description of the surface to create
2586 * Surf: Address to store the interface pointer at
2591 *****************************************************************************/
2592 static HRESULT ddraw_create_surface(struct ddraw *ddraw, DDSURFACEDESC2 *pDDSD,
2593 struct ddraw_surface **surface, UINT level, UINT version)
2597 TRACE("ddraw %p, surface_desc %p, surface %p, level %u.\n",
2598 ddraw, pDDSD, surface, level);
2600 if (TRACE_ON(ddraw))
2602 TRACE("Requesting surface desc:\n");
2603 DDRAW_dump_surface_desc(pDDSD);
2606 if ((pDDSD->ddsCaps.dwCaps & DDSCAPS_3DDEVICE) && DefaultSurfaceType != WINED3D_SURFACE_TYPE_OPENGL)
2608 WARN("The application requests a 3D capable surface, but a non-OpenGL surface type was set in the registry.\n");
2609 /* Do not fail surface creation, only fail 3D device creation. */
2612 /* Create the Surface object */
2613 *surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**surface));
2616 ERR("Failed to allocate surface memory.\n");
2617 return DDERR_OUTOFVIDEOMEMORY;
2620 hr = ddraw_surface_init(*surface, ddraw, pDDSD, level, version);
2623 WARN("Failed to initialize surface, hr %#x.\n", hr);
2624 HeapFree(GetProcessHeap(), 0, *surface);
2628 /* Increase the surface counter, and attach the surface */
2629 list_add_head(&ddraw->surface_list, &(*surface)->surface_list_entry);
2631 TRACE("Created surface %p.\n", *surface);
2635 /*****************************************************************************
2636 * CreateAdditionalSurfaces
2638 * Creates a new mipmap chain.
2641 * root: Root surface to attach the newly created chain to
2642 * count: number of surfaces to create
2643 * DDSD: Description of the surface. Intentionally not a pointer to avoid side
2644 * effects on the caller
2645 * CubeFaceRoot: Whether the new surface is a root of a cube map face. This
2646 * creates an additional surface without the mipmapping flags
2648 *****************************************************************************/
2649 static HRESULT CreateAdditionalSurfaces(struct ddraw *ddraw, struct ddraw_surface *root,
2650 UINT count, DDSURFACEDESC2 DDSD, BOOL CubeFaceRoot, UINT version)
2652 struct ddraw_surface *last = root;
2653 UINT i, j, level = 0;
2656 for (i = 0; i < count; ++i)
2658 struct ddraw_surface *object2 = NULL;
2660 /* increase the mipmap level, but only if a mipmap is created
2661 * In this case, also halve the size
2663 if(DDSD.ddsCaps.dwCaps & DDSCAPS_MIPMAP && !CubeFaceRoot)
2666 if(DDSD.dwWidth > 1) DDSD.dwWidth /= 2;
2667 if(DDSD.dwHeight > 1) DDSD.dwHeight /= 2;
2668 /* Set the mipmap sublevel flag according to msdn */
2669 DDSD.ddsCaps.dwCaps2 |= DDSCAPS2_MIPMAPSUBLEVEL;
2673 DDSD.ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
2675 CubeFaceRoot = FALSE;
2677 hr = ddraw_create_surface(ddraw, &DDSD, &object2, level, version);
2683 /* Add the new surface to the complex attachment array */
2684 for(j = 0; j < MAX_COMPLEX_ATTACHED; j++)
2686 if(last->complex_array[j]) continue;
2687 last->complex_array[j] = object2;
2692 /* Remove the (possible) back buffer cap from the new surface description,
2693 * because only one surface in the flipping chain is a back buffer, one
2694 * is a front buffer, the others are just primary surfaces.
2696 DDSD.ddsCaps.dwCaps &= ~DDSCAPS_BACKBUFFER;
2701 static HRESULT CDECL ddraw_reset_enum_callback(struct wined3d_resource *resource)
2706 /*****************************************************************************
2707 * IDirectDraw7::CreateSurface
2709 * Creates a new IDirectDrawSurface object and returns its interface.
2711 * The surface connections with wined3d are a bit tricky. Basically it works
2714 * |------------------------| |-----------------|
2715 * | DDraw surface | | WineD3DSurface |
2717 * | WineD3DSurface |-------------->| |
2718 * | Child |<------------->| Parent |
2719 * |------------------------| |-----------------|
2721 * The DDraw surface is the parent of the wined3d surface, and it releases
2722 * the WineD3DSurface when the ddraw surface is destroyed.
2724 * However, for all surfaces which can be in a container in WineD3D,
2725 * we have to do this. These surfaces are usually complex surfaces,
2726 * so this concerns primary surfaces with a front and a back buffer,
2729 * |------------------------| |-----------------|
2730 * | DDraw surface | | Container |
2732 * | Child |<------------->| Parent |
2733 * | Texture |<------------->| |
2734 * | WineD3DSurface |<----| | Levels |<--|
2735 * | Complex connection | | | | |
2736 * |------------------------| | |-----------------| |
2740 * | |------------------| | |-----------------| |
2741 * | | IParent | |-------->| WineD3DSurface | |
2743 * | | Child |<------------->| Parent | |
2744 * | | | | Container |<--|
2745 * | |------------------| |-----------------| |
2747 * | |----------------------| |
2748 * | | DDraw surface 2 | |
2750 * |<->| Complex root Child | |
2752 * | | WineD3DSurface |<----| |
2753 * | |----------------------| | |
2755 * | |---------------------| | |-----------------| |
2756 * | | IParent | |----->| WineD3DSurface | |
2758 * | | Child |<---------->| Parent | |
2759 * | |---------------------| | Container |<--|
2760 * | |-----------------| |
2762 * | ---More surfaces can follow--- |
2764 * The reason is that the IWineD3DSwapchain(render target container)
2765 * and the IWineD3DTexure(Texture container) release the parents
2766 * of their surface's children, but by releasing the complex root
2767 * the surfaces which are complexly attached to it are destroyed
2768 * too. See IDirectDrawSurface::Release for a more detailed
2772 * DDSD: Description of the surface to create
2773 * Surf: Address to store the interface pointer at
2774 * UnkOuter: Basically for aggregation support, but ddraw doesn't support
2775 * aggregation, so it has to be NULL
2779 * CLASS_E_NOAGGREGATION if UnkOuter != NULL
2780 * DDERR_* if an error occurs
2782 *****************************************************************************/
2783 static HRESULT CreateSurface(struct ddraw *ddraw, DDSURFACEDESC2 *DDSD,
2784 struct ddraw_surface **surface, IUnknown *UnkOuter, UINT version)
2786 struct ddraw_surface *object = NULL;
2787 struct wined3d_display_mode mode;
2789 LONG extra_surfaces = 0;
2790 DDSURFACEDESC2 desc2;
2791 const DWORD sysvidmem = DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY;
2793 TRACE("ddraw %p, surface_desc %p, surface %p, outer_unknown %p.\n", ddraw, DDSD, surface, UnkOuter);
2795 /* Some checks before we start */
2796 if (TRACE_ON(ddraw))
2798 TRACE(" (%p) Requesting surface desc :\n", ddraw);
2799 DDRAW_dump_surface_desc(DDSD);
2802 if (UnkOuter != NULL)
2804 FIXME("(%p) : outer != NULL?\n", ddraw);
2805 return CLASS_E_NOAGGREGATION; /* unchecked */
2810 FIXME("(%p) You want to get back a surface? Don't give NULL ptrs!\n", ddraw);
2811 return E_POINTER; /* unchecked */
2814 if (!(DDSD->dwFlags & DDSD_CAPS))
2816 /* DVIDEO.DLL does forget the DDSD_CAPS flag ... *sigh* */
2817 DDSD->dwFlags |= DDSD_CAPS;
2820 if (DDSD->ddsCaps.dwCaps & DDSCAPS_ALLOCONLOAD)
2822 /* If the surface is of the 'alloconload' type, ignore the LPSURFACE field */
2823 DDSD->dwFlags &= ~DDSD_LPSURFACE;
2826 if ((DDSD->dwFlags & DDSD_LPSURFACE) && (DDSD->lpSurface == NULL))
2828 /* Frank Herbert's Dune specifies a null pointer for the surface, ignore the LPSURFACE field */
2829 WARN("(%p) Null surface pointer specified, ignore it!\n", ddraw);
2830 DDSD->dwFlags &= ~DDSD_LPSURFACE;
2833 if((DDSD->ddsCaps.dwCaps & (DDSCAPS_FLIP | DDSCAPS_PRIMARYSURFACE)) == (DDSCAPS_FLIP | DDSCAPS_PRIMARYSURFACE) &&
2834 !(ddraw->cooperative_level & DDSCL_EXCLUSIVE))
2836 TRACE("(%p): Attempt to create a flipable primary surface without DDSCL_EXCLUSIVE set\n",
2839 return DDERR_NOEXCLUSIVEMODE;
2842 if((DDSD->ddsCaps.dwCaps & (DDSCAPS_BACKBUFFER | DDSCAPS_PRIMARYSURFACE)) == (DDSCAPS_BACKBUFFER | DDSCAPS_PRIMARYSURFACE))
2844 WARN("Application wanted to create back buffer primary surface\n");
2845 return DDERR_INVALIDCAPS;
2848 if((DDSD->ddsCaps.dwCaps & sysvidmem) == sysvidmem)
2850 /* This is a special switch in ddrawex.dll, but not allowed in ddraw.dll */
2851 WARN("Application tries to put the surface in both system and video memory\n");
2853 return DDERR_INVALIDCAPS;
2856 /* Check cube maps but only if the size includes them */
2857 if (DDSD->dwSize >= sizeof(DDSURFACEDESC2))
2859 if(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES &&
2860 !(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP))
2862 WARN("Cube map faces requested without cube map flag\n");
2863 return DDERR_INVALIDCAPS;
2865 if(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP &&
2866 (DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) == 0)
2868 WARN("Cube map without faces requested\n");
2869 return DDERR_INVALIDPARAMS;
2872 /* Quick tests confirm those can be created, but we don't do that yet */
2873 if(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP &&
2874 (DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) != DDSCAPS2_CUBEMAP_ALLFACES)
2876 FIXME("Partial cube maps not supported yet\n");
2880 /* According to the msdn this flag is ignored by CreateSurface */
2881 if (DDSD->dwSize >= sizeof(DDSURFACEDESC2))
2882 DDSD->ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
2884 /* Modify some flags */
2885 copy_to_surfacedesc2(&desc2, DDSD);
2886 desc2.u4.ddpfPixelFormat.dwSize=sizeof(DDPIXELFORMAT); /* Just to be sure */
2888 /* Get the video mode from WineD3D - we will need it */
2889 hr = wined3d_device_get_display_mode(ddraw->wined3d_device, 0, &mode);
2892 ERR("Failed to read display mode from wined3d\n");
2893 switch(ddraw->orig_bpp)
2896 mode.format_id = WINED3DFMT_P8_UINT;
2900 mode.format_id = WINED3DFMT_B5G5R5X1_UNORM;
2904 mode.format_id = WINED3DFMT_B5G6R5_UNORM;
2908 mode.format_id = WINED3DFMT_B8G8R8_UNORM;
2912 mode.format_id = WINED3DFMT_B8G8R8X8_UNORM;
2915 mode.width = ddraw->orig_width;
2916 mode.height = ddraw->orig_height;
2919 /* No pixelformat given? Use the current screen format */
2920 if(!(desc2.dwFlags & DDSD_PIXELFORMAT))
2922 desc2.dwFlags |= DDSD_PIXELFORMAT;
2923 desc2.u4.ddpfPixelFormat.dwSize=sizeof(DDPIXELFORMAT);
2925 PixelFormat_WineD3DtoDD(&desc2.u4.ddpfPixelFormat, mode.format_id);
2928 /* No Width or no Height? Use the original screen size
2930 if(!(desc2.dwFlags & DDSD_WIDTH) ||
2931 !(desc2.dwFlags & DDSD_HEIGHT) )
2933 /* Invalid for non-render targets */
2934 if(!(desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
2936 WARN("Creating a non-Primary surface without Width or Height info, returning DDERR_INVALIDPARAMS\n");
2938 return DDERR_INVALIDPARAMS;
2941 desc2.dwFlags |= DDSD_WIDTH | DDSD_HEIGHT;
2942 desc2.dwWidth = mode.width;
2943 desc2.dwHeight = mode.height;
2946 if (!desc2.dwWidth || !desc2.dwHeight)
2947 return DDERR_INVALIDPARAMS;
2949 /* Mipmap count fixes */
2950 if(desc2.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
2952 if(desc2.ddsCaps.dwCaps & DDSCAPS_COMPLEX)
2954 if(desc2.dwFlags & DDSD_MIPMAPCOUNT)
2956 /* Mipmap count is given, should not be 0 */
2957 if( desc2.u2.dwMipMapCount == 0 )
2958 return DDERR_INVALIDPARAMS;
2962 /* Undocumented feature: Create sublevels until
2963 * either the width or the height is 1
2965 DWORD min = desc2.dwWidth < desc2.dwHeight ?
2966 desc2.dwWidth : desc2.dwHeight;
2967 desc2.u2.dwMipMapCount = 0;
2970 desc2.u2.dwMipMapCount += 1;
2977 /* Not-complex mipmap -> Mipmapcount = 1 */
2978 desc2.u2.dwMipMapCount = 1;
2980 extra_surfaces = desc2.u2.dwMipMapCount - 1;
2982 /* There's a mipmap count in the created surface in any case */
2983 desc2.dwFlags |= DDSD_MIPMAPCOUNT;
2985 /* If no mipmap is given, the texture has only one level */
2987 /* The first surface is a front buffer, the back buffer is created afterwards */
2988 if( (desc2.dwFlags & DDSD_CAPS) && (desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) )
2990 desc2.ddsCaps.dwCaps |= DDSCAPS_FRONTBUFFER;
2993 /* The root surface in a cube map is positive x */
2994 if(desc2.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
2996 desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
2997 desc2.ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEX;
3000 if ((desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) && (ddraw->cooperative_level & DDSCL_EXCLUSIVE))
3002 struct wined3d_swapchain_desc swapchain_desc;
3004 hr = wined3d_swapchain_get_desc(ddraw->wined3d_swapchain, &swapchain_desc);
3007 ERR("Failed to get present parameters.\n");
3011 swapchain_desc.backbuffer_width = mode.width;
3012 swapchain_desc.backbuffer_height = mode.height;
3013 swapchain_desc.backbuffer_format = mode.format_id;
3015 hr = wined3d_device_reset(ddraw->wined3d_device,
3016 &swapchain_desc, ddraw_reset_enum_callback);
3019 ERR("Failed to reset device.\n");
3024 /* Create the first surface */
3025 hr = ddraw_create_surface(ddraw, &desc2, &object, 0, version);
3028 WARN("ddraw_create_surface failed, hr %#x.\n", hr);
3031 object->is_complex_root = TRUE;
3035 /* Create Additional surfaces if necessary
3036 * This applies to Primary surfaces which have a back buffer count
3037 * set, but not to mipmap textures. In case of Mipmap textures,
3038 * wineD3D takes care of the creation of additional surfaces
3040 if(DDSD->dwFlags & DDSD_BACKBUFFERCOUNT)
3042 extra_surfaces = DDSD->dwBackBufferCount;
3043 desc2.ddsCaps.dwCaps &= ~DDSCAPS_FRONTBUFFER; /* It's not a front buffer */
3044 desc2.ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
3045 desc2.dwBackBufferCount = 0;
3049 if(desc2.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
3051 desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
3052 desc2.ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEZ;
3053 hr |= CreateAdditionalSurfaces(ddraw, object, extra_surfaces + 1, desc2, TRUE, version);
3054 desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_NEGATIVEZ;
3055 desc2.ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEZ;
3056 hr |= CreateAdditionalSurfaces(ddraw, object, extra_surfaces + 1, desc2, TRUE, version);
3057 desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_POSITIVEZ;
3058 desc2.ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEY;
3059 hr |= CreateAdditionalSurfaces(ddraw, object, extra_surfaces + 1, desc2, TRUE, version);
3060 desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_NEGATIVEY;
3061 desc2.ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEY;
3062 hr |= CreateAdditionalSurfaces(ddraw, object, extra_surfaces + 1, desc2, TRUE, version);
3063 desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_POSITIVEY;
3064 desc2.ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEX;
3065 hr |= CreateAdditionalSurfaces(ddraw, object, extra_surfaces + 1, desc2, TRUE, version);
3066 desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_NEGATIVEX;
3067 desc2.ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEX;
3070 hr |= CreateAdditionalSurfaces(ddraw, object, extra_surfaces, desc2, FALSE, version);
3073 /* This destroys and possibly created surfaces too */
3075 IDirectDrawSurface7_Release(&object->IDirectDrawSurface7_iface);
3076 else if (version == 4)
3077 IDirectDrawSurface4_Release(&object->IDirectDrawSurface4_iface);
3079 IDirectDrawSurface_Release(&object->IDirectDrawSurface_iface);
3084 if (desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
3085 ddraw->primary = object;
3087 /* Create a WineD3DTexture if a texture was requested */
3088 if (desc2.ddsCaps.dwCaps & DDSCAPS_TEXTURE)
3090 ddraw->tex_root = object;
3091 ddraw_surface_create_texture(object);
3092 ddraw->tex_root = NULL;
3098 static HRESULT WINAPI ddraw7_CreateSurface(IDirectDraw7 *iface, DDSURFACEDESC2 *surface_desc,
3099 IDirectDrawSurface7 **surface, IUnknown *outer_unknown)
3101 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
3102 struct ddraw_surface *impl;
3105 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3106 iface, surface_desc, surface, outer_unknown);
3108 wined3d_mutex_lock();
3110 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
3112 WARN("Cooperative level not set.\n");
3113 wined3d_mutex_unlock();
3114 return DDERR_NOCOOPERATIVELEVELSET;
3117 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC2))
3119 WARN("Application supplied invalid surface descriptor\n");
3120 wined3d_mutex_unlock();
3121 return DDERR_INVALIDPARAMS;
3124 if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
3126 if (TRACE_ON(ddraw))
3128 TRACE(" (%p) Requesting surface desc :\n", iface);
3129 DDRAW_dump_surface_desc(surface_desc);
3132 WARN("Application tried to create an explicit front or back buffer\n");
3133 wined3d_mutex_unlock();
3134 return DDERR_INVALIDCAPS;
3137 hr = CreateSurface(ddraw, surface_desc, &impl, outer_unknown, 7);
3138 wined3d_mutex_unlock();
3145 *surface = &impl->IDirectDrawSurface7_iface;
3146 IDirectDraw7_AddRef(iface);
3147 impl->ifaceToRelease = (IUnknown *)iface;
3152 static HRESULT WINAPI ddraw4_CreateSurface(IDirectDraw4 *iface,
3153 DDSURFACEDESC2 *surface_desc, IDirectDrawSurface4 **surface, IUnknown *outer_unknown)
3155 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3156 struct ddraw_surface *impl;
3159 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3160 iface, surface_desc, surface, outer_unknown);
3162 wined3d_mutex_lock();
3164 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
3166 WARN("Cooperative level not set.\n");
3167 wined3d_mutex_unlock();
3168 return DDERR_NOCOOPERATIVELEVELSET;
3171 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC2))
3173 WARN("Application supplied invalid surface descriptor\n");
3174 wined3d_mutex_unlock();
3175 return DDERR_INVALIDPARAMS;
3178 if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
3180 if (TRACE_ON(ddraw))
3182 TRACE(" (%p) Requesting surface desc :\n", iface);
3183 DDRAW_dump_surface_desc(surface_desc);
3186 WARN("Application tried to create an explicit front or back buffer\n");
3187 wined3d_mutex_unlock();
3188 return DDERR_INVALIDCAPS;
3191 hr = CreateSurface(ddraw, surface_desc, &impl, outer_unknown, 4);
3192 wined3d_mutex_unlock();
3199 *surface = &impl->IDirectDrawSurface4_iface;
3200 IDirectDraw4_AddRef(iface);
3201 impl->ifaceToRelease = (IUnknown *)iface;
3206 static HRESULT WINAPI ddraw2_CreateSurface(IDirectDraw2 *iface,
3207 DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
3209 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3210 struct ddraw_surface *impl;
3212 DDSURFACEDESC2 surface_desc2;
3214 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3215 iface, surface_desc, surface, outer_unknown);
3217 wined3d_mutex_lock();
3219 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
3221 WARN("Cooperative level not set.\n");
3222 wined3d_mutex_unlock();
3223 return DDERR_NOCOOPERATIVELEVELSET;
3226 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
3228 WARN("Application supplied invalid surface descriptor\n");
3229 wined3d_mutex_unlock();
3230 return DDERR_INVALIDPARAMS;
3233 DDSD_to_DDSD2(surface_desc, &surface_desc2);
3234 if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
3236 if (TRACE_ON(ddraw))
3238 TRACE(" (%p) Requesting surface desc :\n", iface);
3239 DDRAW_dump_surface_desc((LPDDSURFACEDESC2)surface_desc);
3242 WARN("Application tried to create an explicit front or back buffer\n");
3243 wined3d_mutex_unlock();
3244 return DDERR_INVALIDCAPS;
3247 hr = CreateSurface(ddraw, &surface_desc2, &impl, outer_unknown, 2);
3248 wined3d_mutex_unlock();
3255 *surface = &impl->IDirectDrawSurface_iface;
3256 impl->ifaceToRelease = NULL;
3261 static HRESULT WINAPI ddraw1_CreateSurface(IDirectDraw *iface,
3262 DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
3264 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3265 struct ddraw_surface *impl;
3267 DDSURFACEDESC2 surface_desc2;
3269 TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3270 iface, surface_desc, surface, outer_unknown);
3272 wined3d_mutex_lock();
3274 if (!(ddraw->cooperative_level & (DDSCL_NORMAL | DDSCL_EXCLUSIVE)))
3276 WARN("Cooperative level not set.\n");
3277 wined3d_mutex_unlock();
3278 return DDERR_NOCOOPERATIVELEVELSET;
3281 if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
3283 WARN("Application supplied invalid surface descriptor\n");
3284 wined3d_mutex_unlock();
3285 return DDERR_INVALIDPARAMS;
3288 /* Remove front buffer flag, this causes failure in v7, and its added to normal
3289 * primaries anyway. */
3290 surface_desc->ddsCaps.dwCaps &= ~DDSCAPS_FRONTBUFFER;
3291 DDSD_to_DDSD2(surface_desc, &surface_desc2);
3292 hr = CreateSurface(ddraw, &surface_desc2, &impl, outer_unknown, 1);
3293 wined3d_mutex_unlock();
3300 *surface = &impl->IDirectDrawSurface_iface;
3301 impl->ifaceToRelease = NULL;
3306 #define DDENUMSURFACES_SEARCHTYPE (DDENUMSURFACES_CANBECREATED|DDENUMSURFACES_DOESEXIST)
3307 #define DDENUMSURFACES_MATCHTYPE (DDENUMSURFACES_ALL|DDENUMSURFACES_MATCH|DDENUMSURFACES_NOMATCH)
3310 Main_DirectDraw_DDPIXELFORMAT_Match(const DDPIXELFORMAT *requested,
3311 const DDPIXELFORMAT *provided)
3313 /* Some flags must be present in both or neither for a match. */
3314 static const DWORD must_match = DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2
3315 | DDPF_PALETTEINDEXED4 | DDPF_PALETTEINDEXED8 | DDPF_FOURCC
3316 | DDPF_ZBUFFER | DDPF_STENCILBUFFER;
3318 if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
3321 if ((requested->dwFlags & must_match) != (provided->dwFlags & must_match))
3324 if (requested->dwFlags & DDPF_FOURCC)
3325 if (requested->dwFourCC != provided->dwFourCC)
3328 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_ALPHA
3329 |DDPF_LUMINANCE|DDPF_BUMPDUDV))
3330 if (requested->u1.dwRGBBitCount != provided->u1.dwRGBBitCount)
3333 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
3334 |DDPF_LUMINANCE|DDPF_BUMPDUDV))
3335 if (requested->u2.dwRBitMask != provided->u2.dwRBitMask)
3338 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_BUMPDUDV))
3339 if (requested->u3.dwGBitMask != provided->u3.dwGBitMask)
3342 /* I could be wrong about the bumpmapping. MSDN docs are vague. */
3343 if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
3345 if (requested->u4.dwBBitMask != provided->u4.dwBBitMask)
3348 if (requested->dwFlags & (DDPF_ALPHAPIXELS|DDPF_ZPIXELS))
3349 if (requested->u5.dwRGBAlphaBitMask != provided->u5.dwRGBAlphaBitMask)
3355 static BOOL ddraw_match_surface_desc(const DDSURFACEDESC2 *requested, const DDSURFACEDESC2 *provided)
3364 #define CMP(FLAG, FIELD) \
3365 { DDSD_##FLAG, offsetof(DDSURFACEDESC2, FIELD), \
3366 sizeof(((DDSURFACEDESC2 *)(NULL))->FIELD) }
3368 static const struct compare_info compare[] =
3370 CMP(ALPHABITDEPTH, dwAlphaBitDepth),
3371 CMP(BACKBUFFERCOUNT, dwBackBufferCount),
3373 CMP(CKDESTBLT, ddckCKDestBlt),
3374 CMP(CKDESTOVERLAY, u3 /* ddckCKDestOverlay */),
3375 CMP(CKSRCBLT, ddckCKSrcBlt),
3376 CMP(CKSRCOVERLAY, ddckCKSrcOverlay),
3377 CMP(HEIGHT, dwHeight),
3378 CMP(LINEARSIZE, u1 /* dwLinearSize */),
3379 CMP(LPSURFACE, lpSurface),
3380 CMP(MIPMAPCOUNT, u2 /* dwMipMapCount */),
3381 CMP(PITCH, u1 /* lPitch */),
3382 /* PIXELFORMAT: manual */
3383 CMP(REFRESHRATE, u2 /* dwRefreshRate */),
3384 CMP(TEXTURESTAGE, dwTextureStage),
3385 CMP(WIDTH, dwWidth),
3386 /* ZBUFFERBITDEPTH: "obsolete" */
3393 if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
3396 for (i=0; i < sizeof(compare)/sizeof(compare[0]); i++)
3398 if (requested->dwFlags & compare[i].flag
3399 && memcmp((const char *)provided + compare[i].offset,
3400 (const char *)requested + compare[i].offset,
3401 compare[i].size) != 0)
3405 if (requested->dwFlags & DDSD_PIXELFORMAT)
3407 if (!Main_DirectDraw_DDPIXELFORMAT_Match(&requested->u4.ddpfPixelFormat,
3408 &provided->u4.ddpfPixelFormat))
3415 #undef DDENUMSURFACES_SEARCHTYPE
3416 #undef DDENUMSURFACES_MATCHTYPE
3418 struct surfacescallback2_context
3420 LPDDENUMSURFACESCALLBACK2 func;
3424 struct surfacescallback_context
3426 LPDDENUMSURFACESCALLBACK func;
3430 static HRESULT CALLBACK EnumSurfacesCallback2Thunk(IDirectDrawSurface7 *surface,
3431 DDSURFACEDESC2 *surface_desc, void *context)
3433 struct ddraw_surface *surface_impl = impl_from_IDirectDrawSurface7(surface);
3434 struct surfacescallback2_context *cbcontext = context;
3436 IDirectDrawSurface4_AddRef(&surface_impl->IDirectDrawSurface4_iface);
3437 IDirectDrawSurface7_Release(surface);
3439 return cbcontext->func(&surface_impl->IDirectDrawSurface4_iface,
3440 surface_desc, cbcontext->context);
3443 static HRESULT CALLBACK EnumSurfacesCallbackThunk(IDirectDrawSurface7 *surface,
3444 DDSURFACEDESC2 *surface_desc, void *context)
3446 struct ddraw_surface *surface_impl = impl_from_IDirectDrawSurface7(surface);
3447 struct surfacescallback_context *cbcontext = context;
3449 IDirectDrawSurface_AddRef(&surface_impl->IDirectDrawSurface_iface);
3450 IDirectDrawSurface7_Release(surface);
3452 return cbcontext->func(&surface_impl->IDirectDrawSurface_iface,
3453 (DDSURFACEDESC *)surface_desc, cbcontext->context);
3456 /*****************************************************************************
3457 * IDirectDraw7::EnumSurfaces
3459 * Loops through all surfaces attached to this device and calls the
3460 * application callback. This can't be relayed to WineD3DDevice,
3461 * because some WineD3DSurfaces' parents are IParent objects
3464 * Flags: Some filtering flags. See IDirectDrawImpl_EnumSurfacesCallback
3465 * DDSD: Description to filter for
3466 * Context: Application-provided pointer, it's passed unmodified to the
3468 * Callback: Address to call for each surface
3471 * DDERR_INVALIDPARAMS if the callback is NULL
3474 *****************************************************************************/
3475 static HRESULT WINAPI ddraw7_EnumSurfaces(IDirectDraw7 *iface, DWORD Flags,
3476 DDSURFACEDESC2 *DDSD, void *Context, LPDDENUMSURFACESCALLBACK7 Callback)
3478 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
3479 struct ddraw_surface *surf;
3481 DDSURFACEDESC2 desc;
3482 struct list *entry, *entry2;
3484 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3485 iface, Flags, DDSD, Context, Callback);
3487 all = Flags & DDENUMSURFACES_ALL;
3488 nomatch = Flags & DDENUMSURFACES_NOMATCH;
3491 return DDERR_INVALIDPARAMS;
3493 wined3d_mutex_lock();
3495 /* Use the _SAFE enumeration, the app may destroy enumerated surfaces */
3496 LIST_FOR_EACH_SAFE(entry, entry2, &ddraw->surface_list)
3498 surf = LIST_ENTRY(entry, struct ddraw_surface, surface_list_entry);
3500 if (!surf->iface_count)
3502 WARN("Not enumerating surface %p because it doesn't have any references.\n", surf);
3506 if (all || (nomatch != ddraw_match_surface_desc(DDSD, &surf->surface_desc)))
3508 TRACE("Enumerating surface %p.\n", surf);
3509 desc = surf->surface_desc;
3510 IDirectDrawSurface7_AddRef(&surf->IDirectDrawSurface7_iface);
3511 if (Callback(&surf->IDirectDrawSurface7_iface, &desc, Context) != DDENUMRET_OK)
3513 wined3d_mutex_unlock();
3519 wined3d_mutex_unlock();
3524 static HRESULT WINAPI ddraw4_EnumSurfaces(IDirectDraw4 *iface, DWORD flags,
3525 DDSURFACEDESC2 *surface_desc, void *context, LPDDENUMSURFACESCALLBACK2 callback)
3527 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3528 struct surfacescallback2_context cbcontext;
3530 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3531 iface, flags, surface_desc, context, callback);
3533 cbcontext.func = callback;
3534 cbcontext.context = context;
3536 return ddraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, flags, surface_desc,
3537 &cbcontext, EnumSurfacesCallback2Thunk);
3540 static HRESULT WINAPI ddraw2_EnumSurfaces(IDirectDraw2 *iface, DWORD flags,
3541 DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3543 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3544 struct surfacescallback_context cbcontext;
3545 DDSURFACEDESC2 surface_desc2;
3547 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3548 iface, flags, surface_desc, context, callback);
3550 cbcontext.func = callback;
3551 cbcontext.context = context;
3553 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3554 return ddraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, flags,
3555 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumSurfacesCallbackThunk);
3558 static HRESULT WINAPI ddraw1_EnumSurfaces(IDirectDraw *iface, DWORD flags,
3559 DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3561 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3562 struct surfacescallback_context cbcontext;
3563 DDSURFACEDESC2 surface_desc2;
3565 TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3566 iface, flags, surface_desc, context, callback);
3568 cbcontext.func = callback;
3569 cbcontext.context = context;
3571 if (surface_desc) DDSD_to_DDSD2(surface_desc, &surface_desc2);
3572 return ddraw7_EnumSurfaces(&ddraw->IDirectDraw7_iface, flags,
3573 surface_desc ? &surface_desc2 : NULL, &cbcontext, EnumSurfacesCallbackThunk);
3576 /*****************************************************************************
3577 * DirectDrawCreateClipper (DDRAW.@)
3579 * Creates a new IDirectDrawClipper object.
3582 * Clipper: Address to write the interface pointer to
3583 * UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3587 * CLASS_E_NOAGGREGATION if UnkOuter != NULL
3588 * E_OUTOFMEMORY if allocating the object failed
3590 *****************************************************************************/
3591 HRESULT WINAPI DirectDrawCreateClipper(DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3593 struct ddraw_clipper *object;
3596 TRACE("flags %#x, clipper %p, outer_unknown %p.\n",
3597 flags, clipper, outer_unknown);
3600 return CLASS_E_NOAGGREGATION;
3602 wined3d_mutex_lock();
3604 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3607 wined3d_mutex_unlock();
3608 return E_OUTOFMEMORY;
3611 hr = ddraw_clipper_init(object);
3614 WARN("Failed to initialize clipper, hr %#x.\n", hr);
3615 HeapFree(GetProcessHeap(), 0, object);
3616 wined3d_mutex_unlock();
3620 TRACE("Created clipper %p.\n", object);
3621 *clipper = &object->IDirectDrawClipper_iface;
3622 wined3d_mutex_unlock();
3627 /*****************************************************************************
3628 * IDirectDraw7::CreateClipper
3630 * Creates a DDraw clipper. See DirectDrawCreateClipper for details
3632 *****************************************************************************/
3633 static HRESULT WINAPI ddraw7_CreateClipper(IDirectDraw7 *iface, DWORD Flags,
3634 IDirectDrawClipper **Clipper, IUnknown *UnkOuter)
3636 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3637 iface, Flags, Clipper, UnkOuter);
3639 return DirectDrawCreateClipper(Flags, Clipper, UnkOuter);
3642 static HRESULT WINAPI ddraw4_CreateClipper(IDirectDraw4 *iface, DWORD flags,
3643 IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3645 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3647 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3648 iface, flags, clipper, outer_unknown);
3650 return ddraw7_CreateClipper(&ddraw->IDirectDraw7_iface, flags, clipper, outer_unknown);
3653 static HRESULT WINAPI ddraw2_CreateClipper(IDirectDraw2 *iface,
3654 DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3656 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3658 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3659 iface, flags, clipper, outer_unknown);
3661 return ddraw7_CreateClipper(&ddraw->IDirectDraw7_iface, flags, clipper, outer_unknown);
3664 static HRESULT WINAPI ddraw1_CreateClipper(IDirectDraw *iface,
3665 DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3667 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3669 TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3670 iface, flags, clipper, outer_unknown);
3672 return ddraw7_CreateClipper(&ddraw->IDirectDraw7_iface, flags, clipper, outer_unknown);
3675 /*****************************************************************************
3676 * IDirectDraw7::CreatePalette
3678 * Creates a new IDirectDrawPalette object
3681 * Flags: The flags for the new clipper
3682 * ColorTable: Color table to assign to the new clipper
3683 * Palette: Address to write the interface pointer to
3684 * UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3688 * CLASS_E_NOAGGREGATION if UnkOuter != NULL
3689 * E_OUTOFMEMORY if allocating the object failed
3691 *****************************************************************************/
3692 static HRESULT WINAPI ddraw7_CreatePalette(IDirectDraw7 *iface, DWORD Flags,
3693 PALETTEENTRY *ColorTable, IDirectDrawPalette **Palette, IUnknown *pUnkOuter)
3695 struct ddraw *ddraw = impl_from_IDirectDraw7(iface);
3696 struct ddraw_palette *object;
3699 TRACE("iface %p, flags %#x, color_table %p, palette %p, outer_unknown %p.\n",
3700 iface, Flags, ColorTable, Palette, pUnkOuter);
3703 return CLASS_E_NOAGGREGATION;
3705 wined3d_mutex_lock();
3707 /* The refcount test shows that a cooplevel is required for this */
3708 if (!ddraw->cooperative_level)
3710 WARN("No cooperative level set, returning DDERR_NOCOOPERATIVELEVELSET\n");
3711 wined3d_mutex_unlock();
3712 return DDERR_NOCOOPERATIVELEVELSET;
3715 object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object));
3718 ERR("Out of memory when allocating memory for a palette implementation\n");
3719 wined3d_mutex_unlock();
3720 return E_OUTOFMEMORY;
3723 hr = ddraw_palette_init(object, ddraw, Flags, ColorTable);
3726 WARN("Failed to initialize palette, hr %#x.\n", hr);
3727 HeapFree(GetProcessHeap(), 0, object);
3728 wined3d_mutex_unlock();
3732 TRACE("Created palette %p.\n", object);
3733 *Palette = &object->IDirectDrawPalette_iface;
3734 wined3d_mutex_unlock();
3739 static HRESULT WINAPI ddraw4_CreatePalette(IDirectDraw4 *iface, DWORD flags, PALETTEENTRY *entries,
3740 IDirectDrawPalette **palette, IUnknown *outer_unknown)
3742 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3745 TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3746 iface, flags, entries, palette, outer_unknown);
3748 hr = ddraw7_CreatePalette(&ddraw->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3749 if (SUCCEEDED(hr) && *palette)
3751 struct ddraw_palette *impl = impl_from_IDirectDrawPalette(*palette);
3752 IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
3753 IDirectDraw4_AddRef(iface);
3754 impl->ifaceToRelease = (IUnknown *)iface;
3759 static HRESULT WINAPI ddraw2_CreatePalette(IDirectDraw2 *iface, DWORD flags,
3760 PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3762 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3765 TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3766 iface, flags, entries, palette, outer_unknown);
3768 hr = ddraw7_CreatePalette(&ddraw->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3769 if (SUCCEEDED(hr) && *palette)
3771 struct ddraw_palette *impl = impl_from_IDirectDrawPalette(*palette);
3772 IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
3773 impl->ifaceToRelease = NULL;
3779 static HRESULT WINAPI ddraw1_CreatePalette(IDirectDraw *iface, DWORD flags,
3780 PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3782 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3785 TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3786 iface, flags, entries, palette, outer_unknown);
3788 hr = ddraw7_CreatePalette(&ddraw->IDirectDraw7_iface, flags, entries, palette, outer_unknown);
3789 if (SUCCEEDED(hr) && *palette)
3791 struct ddraw_palette *impl = impl_from_IDirectDrawPalette(*palette);
3792 IDirectDraw7_Release(&ddraw->IDirectDraw7_iface);
3793 impl->ifaceToRelease = NULL;
3799 /*****************************************************************************
3800 * IDirectDraw7::DuplicateSurface
3802 * Duplicates a surface. The surface memory points to the same memory as
3803 * the original surface, and it's released when the last surface referencing
3804 * it is released. I guess that's beyond Wine's surface management right now
3805 * (Idea: create a new DDraw surface with the same WineD3DSurface. I need a
3806 * test application to implement this)
3809 * Src: Address of the source surface
3810 * Dest: Address to write the new surface pointer to
3813 * See IDirectDraw7::CreateSurface
3815 *****************************************************************************/
3816 static HRESULT WINAPI ddraw7_DuplicateSurface(IDirectDraw7 *iface,
3817 IDirectDrawSurface7 *Src, IDirectDrawSurface7 **Dest)
3819 struct ddraw_surface *src_surface = unsafe_impl_from_IDirectDrawSurface7(Src);
3821 FIXME("iface %p, src %p, dst %p partial stub!\n", iface, Src, Dest);
3823 /* For now, simply create a new, independent surface */
3824 return IDirectDraw7_CreateSurface(iface, &src_surface->surface_desc, Dest, NULL);
3827 static HRESULT WINAPI ddraw4_DuplicateSurface(IDirectDraw4 *iface, IDirectDrawSurface4 *src,
3828 IDirectDrawSurface4 **dst)
3830 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface4(src);
3831 struct ddraw *ddraw = impl_from_IDirectDraw4(iface);
3832 struct ddraw_surface *dst_impl;
3833 IDirectDrawSurface7 *dst7;
3836 TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3838 hr = ddraw7_DuplicateSurface(&ddraw->IDirectDraw7_iface,
3839 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3845 dst_impl = impl_from_IDirectDrawSurface7(dst7);
3846 *dst = &dst_impl->IDirectDrawSurface4_iface;
3847 IDirectDrawSurface4_AddRef(*dst);
3848 IDirectDrawSurface7_Release(dst7);
3853 static HRESULT WINAPI ddraw2_DuplicateSurface(IDirectDraw2 *iface,
3854 IDirectDrawSurface *src, IDirectDrawSurface **dst)
3856 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface(src);
3857 struct ddraw *ddraw = impl_from_IDirectDraw2(iface);
3858 struct ddraw_surface *dst_impl;
3859 IDirectDrawSurface7 *dst7;
3862 TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3864 hr = ddraw7_DuplicateSurface(&ddraw->IDirectDraw7_iface,
3865 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3868 dst_impl = impl_from_IDirectDrawSurface7(dst7);
3869 *dst = &dst_impl->IDirectDrawSurface_iface;
3870 IDirectDrawSurface_AddRef(*dst);
3871 IDirectDrawSurface7_Release(dst7);
3876 static HRESULT WINAPI ddraw1_DuplicateSurface(IDirectDraw *iface, IDirectDrawSurface *src,
3877 IDirectDrawSurface **dst)
3879 struct ddraw_surface *src_impl = unsafe_impl_from_IDirectDrawSurface(src);
3880 struct ddraw *ddraw = impl_from_IDirectDraw(iface);
3881 struct ddraw_surface *dst_impl;
3882 IDirectDrawSurface7 *dst7;
3885 TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
3887 hr = ddraw7_DuplicateSurface(&ddraw->IDirectDraw7_iface,
3888 src_impl ? &src_impl->IDirectDrawSurface7_iface : NULL, &dst7);
3891 dst_impl = impl_from_IDirectDrawSurface7(dst7);
3892 *dst = &dst_impl->IDirectDrawSurface_iface;
3893 IDirectDrawSurface_AddRef(*dst);
3894 IDirectDrawSurface7_Release(dst7);
3899 /*****************************************************************************
3900 * IDirect3D7::EnumDevices
3902 * The EnumDevices method for IDirect3D7. It enumerates all supported
3903 * D3D7 devices. Currently the T&L, HAL and RGB devices are enumerated.
3906 * callback: Function to call for each enumerated device
3907 * context: Pointer to pass back to the app
3910 * D3D_OK, or the return value of the GetCaps call
3912 *****************************************************************************/
3913 static HRESULT WINAPI d3d7_EnumDevices(IDirect3D7 *iface, LPD3DENUMDEVICESCALLBACK7 callback, void *context)
3915 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
3916 D3DDEVICEDESC7 device_desc7;
3917 D3DDEVICEDESC device_desc1;
3921 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3924 return DDERR_INVALIDPARAMS;
3926 wined3d_mutex_lock();
3928 hr = IDirect3DImpl_GetCaps(ddraw->wined3d, &device_desc1, &device_desc7);
3931 wined3d_mutex_unlock();
3935 for (i = 0; i < sizeof(device_list7)/sizeof(device_list7[0]); i++)
3939 device_desc7.deviceGUID = *device_list7[i].device_guid;
3940 ret = callback(device_list7[i].interface_name, device_list7[i].device_name, &device_desc7, context);
3941 if (ret != DDENUMRET_OK)
3943 TRACE("Application cancelled the enumeration.\n");
3944 wined3d_mutex_unlock();
3949 TRACE("End of enumeration.\n");
3951 wined3d_mutex_unlock();
3956 /*****************************************************************************
3957 * IDirect3D3::EnumDevices
3959 * Enumerates all supported Direct3DDevice interfaces. This is the
3960 * implementation for Direct3D 1 to Direc3D 3, Version 7 has its own.
3962 * Version 1, 2 and 3
3965 * callback: Application-provided routine to call for each enumerated device
3966 * Context: Pointer to pass to the callback
3969 * D3D_OK on success,
3970 * The result of IDirect3DImpl_GetCaps if it failed
3972 *****************************************************************************/
3973 static HRESULT WINAPI d3d3_EnumDevices(IDirect3D3 *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
3975 static CHAR wined3d_description[] = "Wine D3DDevice using WineD3D and OpenGL";
3977 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
3978 D3DDEVICEDESC device_desc1, hal_desc, hel_desc;
3979 D3DDEVICEDESC7 device_desc7;
3982 /* Some games (Motoracer 2 demo) have the bad idea to modify the device
3983 * name string. Let's put the string in a sufficiently sized array in
3984 * writable memory. */
3985 char device_name[50];
3986 strcpy(device_name,"Direct3D HEL");
3988 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
3991 return DDERR_INVALIDPARAMS;
3993 wined3d_mutex_lock();
3995 hr = IDirect3DImpl_GetCaps(ddraw->wined3d, &device_desc1, &device_desc7);
3998 wined3d_mutex_unlock();
4002 /* Do I have to enumerate the reference id? Note from old d3d7:
4003 * "It seems that enumerating the reference IID on Direct3D 1 games
4004 * (AvP / Motoracer2) breaks them". So do not enumerate this iid in V1
4006 * There's a registry key HKLM\Software\Microsoft\Direct3D\Drivers,
4007 * EnumReference which enables / disables enumerating the reference
4008 * rasterizer. It's a DWORD, 0 means disabled, 2 means enabled. The
4009 * enablerefrast.reg and disablerefrast.reg files in the DirectX 7.0 sdk
4010 * demo directory suggest this.
4012 * Some games(GTA 2) seem to use the second enumerated device, so I have
4013 * to enumerate at least 2 devices. So enumerate the reference device to
4016 * Other games (Rollcage) tell emulation and hal device apart by certain
4017 * flags. Rollcage expects D3DPTEXTURECAPS_POW2 to be set (yeah, it is a
4018 * limitation flag), and it refuses all devices that have the perspective
4019 * flag set. This way it refuses the emulation device, and HAL devices
4020 * never have POW2 unset in d3d7 on windows. */
4021 if (ddraw->d3dversion != 1)
4023 static CHAR reference_description[] = "RGB Direct3D emulation";
4025 TRACE("Enumerating WineD3D D3DDevice interface.\n");
4026 hal_desc = device_desc1;
4027 hel_desc = device_desc1;
4028 /* The rgb device has the pow2 flag set in the hel caps, but not in the hal caps. */
4029 hal_desc.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
4030 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
4031 hal_desc.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
4032 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
4033 /* RGB, RAMP and MMX devices have a HAL dcmColorModel of 0 */
4034 hal_desc.dcmColorModel = 0;
4036 hr = callback((GUID *)&IID_IDirect3DRGBDevice, reference_description,
4037 device_name, &hal_desc, &hel_desc, context);
4038 if (hr != D3DENUMRET_OK)
4040 TRACE("Application cancelled the enumeration.\n");
4041 wined3d_mutex_unlock();
4046 strcpy(device_name,"Direct3D HAL");
4048 TRACE("Enumerating HAL Direct3D device.\n");
4049 hal_desc = device_desc1;
4050 hel_desc = device_desc1;
4052 /* The hal device does not have the pow2 flag set in hel, but in hal. */
4053 hel_desc.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
4054 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
4055 hel_desc.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
4056 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
4057 /* HAL devices have a HEL dcmColorModel of 0 */
4058 hel_desc.dcmColorModel = 0;
4060 hr = callback((GUID *)&IID_IDirect3DHALDevice, wined3d_description,
4061 device_name, &hal_desc, &hel_desc, context);
4062 if (hr != D3DENUMRET_OK)
4064 TRACE("Application cancelled the enumeration.\n");
4065 wined3d_mutex_unlock();
4069 TRACE("End of enumeration.\n");
4071 wined3d_mutex_unlock();
4076 static HRESULT WINAPI d3d2_EnumDevices(IDirect3D2 *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
4078 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4080 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
4082 return d3d3_EnumDevices(&ddraw->IDirect3D3_iface, callback, context);
4085 static HRESULT WINAPI d3d1_EnumDevices(IDirect3D *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
4087 struct ddraw *ddraw = impl_from_IDirect3D(iface);
4089 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
4091 return d3d3_EnumDevices(&ddraw->IDirect3D3_iface, callback, context);
4094 /*****************************************************************************
4095 * IDirect3D3::CreateLight
4097 * Creates an IDirect3DLight interface. This interface is used in
4098 * Direct3D3 or earlier for lighting. In Direct3D7 it has been replaced
4099 * by the DIRECT3DLIGHT7 structure. Wine's Direct3DLight implementation
4100 * uses the IDirect3DDevice7 interface with D3D7 lights.
4102 * Version 1, 2 and 3
4105 * light: Address to store the new interface pointer
4106 * outer_unknown: Basically for aggregation, but ddraw doesn't support it.
4111 * DDERR_OUTOFMEMORY if memory allocation failed
4112 * CLASS_E_NOAGGREGATION if outer_unknown != NULL
4114 *****************************************************************************/
4115 static HRESULT WINAPI d3d3_CreateLight(IDirect3D3 *iface, IDirect3DLight **light,
4116 IUnknown *outer_unknown)
4118 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4119 struct d3d_light *object;
4121 TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
4123 if (outer_unknown) return CLASS_E_NOAGGREGATION;
4125 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4128 ERR("Failed to allocate light memory.\n");
4129 return DDERR_OUTOFMEMORY;
4132 d3d_light_init(object, ddraw);
4134 TRACE("Created light %p.\n", object);
4135 *light = &object->IDirect3DLight_iface;
4140 static HRESULT WINAPI d3d2_CreateLight(IDirect3D2 *iface, IDirect3DLight **light, IUnknown *outer_unknown)
4142 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4144 TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
4146 return d3d3_CreateLight(&ddraw->IDirect3D3_iface, light, outer_unknown);
4149 static HRESULT WINAPI d3d1_CreateLight(IDirect3D *iface, IDirect3DLight **light, IUnknown *outer_unknown)
4151 struct ddraw *ddraw = impl_from_IDirect3D(iface);
4153 TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
4155 return d3d3_CreateLight(&ddraw->IDirect3D3_iface, light, outer_unknown);
4158 /*****************************************************************************
4159 * IDirect3D3::CreateMaterial
4161 * Creates an IDirect3DMaterial interface. This interface is used by Direct3D3
4162 * and older versions. The IDirect3DMaterial implementation wraps its
4163 * functionality to IDirect3DDevice7::SetMaterial and friends.
4165 * Version 1, 2 and 3
4168 * material: Address to store the new interface's pointer to
4169 * outer_unknown: Basically for aggregation, but ddraw doesn't support it.
4174 * DDERR_OUTOFMEMORY if memory allocation failed
4175 * CLASS_E_NOAGGREGATION if outer_unknown != NULL
4177 *****************************************************************************/
4178 static HRESULT WINAPI d3d3_CreateMaterial(IDirect3D3 *iface, IDirect3DMaterial3 **material,
4179 IUnknown *outer_unknown)
4181 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4182 struct d3d_material *object;
4184 TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
4186 if (outer_unknown) return CLASS_E_NOAGGREGATION;
4188 object = d3d_material_create(ddraw);
4191 ERR("Failed to allocate material memory.\n");
4192 return DDERR_OUTOFMEMORY;
4195 TRACE("Created material %p.\n", object);
4196 *material = &object->IDirect3DMaterial3_iface;
4201 static HRESULT WINAPI d3d2_CreateMaterial(IDirect3D2 *iface, IDirect3DMaterial2 **material,
4202 IUnknown *outer_unknown)
4204 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4205 struct d3d_material *object;
4207 TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
4209 object = d3d_material_create(ddraw);
4212 ERR("Failed to allocate material memory.\n");
4213 return DDERR_OUTOFMEMORY;
4216 TRACE("Created material %p.\n", object);
4217 *material = &object->IDirect3DMaterial2_iface;
4222 static HRESULT WINAPI d3d1_CreateMaterial(IDirect3D *iface, IDirect3DMaterial **material,
4223 IUnknown *outer_unknown)
4225 struct ddraw *ddraw = impl_from_IDirect3D(iface);
4226 struct d3d_material *object;
4228 TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
4230 object = d3d_material_create(ddraw);
4233 ERR("Failed to allocate material memory.\n");
4234 return DDERR_OUTOFMEMORY;
4237 TRACE("Created material %p.\n", object);
4238 *material = &object->IDirect3DMaterial_iface;
4243 /*****************************************************************************
4244 * IDirect3D3::CreateViewport
4246 * Creates an IDirect3DViewport interface. This interface is used
4247 * by Direct3D and earlier versions for Viewport management. In Direct3D7
4248 * it has been replaced by a viewport structure and
4249 * IDirect3DDevice7::*Viewport. Wine's IDirect3DViewport implementation
4250 * uses the IDirect3DDevice7 methods for its functionality
4253 * Viewport: Address to store the new interface pointer
4254 * outer_unknown: Basically for aggregation, but ddraw doesn't support it.
4259 * DDERR_OUTOFMEMORY if memory allocation failed
4260 * CLASS_E_NOAGGREGATION if outer_unknown != NULL
4262 *****************************************************************************/
4263 static HRESULT WINAPI d3d3_CreateViewport(IDirect3D3 *iface, IDirect3DViewport3 **viewport,
4264 IUnknown *outer_unknown)
4266 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4267 struct d3d_viewport *object;
4269 TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4271 if (outer_unknown) return CLASS_E_NOAGGREGATION;
4273 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4276 ERR("Failed to allocate viewport memory.\n");
4277 return DDERR_OUTOFMEMORY;
4280 d3d_viewport_init(object, ddraw);
4282 TRACE("Created viewport %p.\n", object);
4283 *viewport = &object->IDirect3DViewport3_iface;
4288 static HRESULT WINAPI d3d2_CreateViewport(IDirect3D2 *iface, IDirect3DViewport2 **viewport, IUnknown *outer_unknown)
4290 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4292 TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4294 return d3d3_CreateViewport(&ddraw->IDirect3D3_iface, (IDirect3DViewport3 **)viewport,
4298 static HRESULT WINAPI d3d1_CreateViewport(IDirect3D *iface, IDirect3DViewport **viewport, IUnknown *outer_unknown)
4300 struct ddraw *ddraw = impl_from_IDirect3D(iface);
4302 TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4304 return d3d3_CreateViewport(&ddraw->IDirect3D3_iface, (IDirect3DViewport3 **)viewport,
4308 /*****************************************************************************
4309 * IDirect3D3::FindDevice
4311 * This method finds a device with the requested properties and returns a
4312 * device description
4316 * fds: Describes the requested device characteristics
4317 * fdr: Returns the device description
4321 * DDERR_INVALIDPARAMS if no device was found
4323 *****************************************************************************/
4324 static HRESULT WINAPI d3d3_FindDevice(IDirect3D3 *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4326 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4327 D3DDEVICEDESC7 desc7;
4328 D3DDEVICEDESC desc1;
4331 TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4333 if (!fds || !fdr) return DDERR_INVALIDPARAMS;
4335 if (fds->dwSize != sizeof(D3DFINDDEVICESEARCH)
4336 || fdr->dwSize != sizeof(D3DFINDDEVICERESULT))
4337 return DDERR_INVALIDPARAMS;
4339 if ((fds->dwFlags & D3DFDS_COLORMODEL)
4340 && fds->dcmColorModel != D3DCOLOR_RGB)
4342 WARN("Trying to request a non-RGB D3D color model. Not supported.\n");
4343 return DDERR_INVALIDPARAMS; /* No real idea what to return here :-) */
4346 if (fds->dwFlags & D3DFDS_GUID)
4348 TRACE("Trying to match guid %s.\n", debugstr_guid(&(fds->guid)));
4349 if (!IsEqualGUID(&IID_D3DDEVICE_WineD3D, &fds->guid)
4350 && !IsEqualGUID(&IID_IDirect3DHALDevice, &fds->guid)
4351 && !IsEqualGUID(&IID_IDirect3DRGBDevice, &fds->guid))
4353 WARN("No match for this GUID.\n");
4354 return DDERR_NOTFOUND;
4359 hr = IDirect3DImpl_GetCaps(ddraw->wined3d, &desc1, &desc7);
4360 if (hr != D3D_OK) return hr;
4362 /* Now return our own GUID */
4363 fdr->guid = IID_D3DDEVICE_WineD3D;
4364 fdr->ddHwDesc = desc1;
4365 fdr->ddSwDesc = desc1;
4367 TRACE("Returning Wine's wined3d device with (undumped) capabilities.\n");
4372 static HRESULT WINAPI d3d2_FindDevice(IDirect3D2 *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4374 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4376 TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4378 return d3d3_FindDevice(&ddraw->IDirect3D3_iface, fds, fdr);
4381 static HRESULT WINAPI d3d1_FindDevice(IDirect3D *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4383 struct ddraw *ddraw = impl_from_IDirect3D(iface);
4385 TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4387 return d3d3_FindDevice(&ddraw->IDirect3D3_iface, fds, fdr);
4390 /*****************************************************************************
4391 * IDirect3D7::CreateDevice
4393 * Creates an IDirect3DDevice7 interface.
4395 * Version 2, 3 and 7. IDirect3DDevice 1 interfaces are interfaces to
4396 * DirectDraw surfaces and are created with
4397 * IDirectDrawSurface::QueryInterface. This method uses CreateDevice to
4398 * create the device object and QueryInterfaces for IDirect3DDevice
4401 * refiid: IID of the device to create
4402 * Surface: Initial rendertarget
4403 * Device: Address to return the interface pointer
4407 * DDERR_OUTOFMEMORY if memory allocation failed
4408 * DDERR_INVALIDPARAMS if a device exists already
4410 *****************************************************************************/
4411 static HRESULT WINAPI d3d7_CreateDevice(IDirect3D7 *iface, REFCLSID riid,
4412 IDirectDrawSurface7 *surface, IDirect3DDevice7 **device)
4414 struct ddraw_surface *target = unsafe_impl_from_IDirectDrawSurface7(surface);
4415 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4416 struct d3d_device *object;
4419 TRACE("iface %p, riid %s, surface %p, device %p.\n", iface, debugstr_guid(riid), surface, device);
4421 wined3d_mutex_lock();
4422 hr = d3d_device_create(ddraw, target, 7, &object, NULL);
4424 *device = &object->IDirect3DDevice7_iface;
4427 WARN("Failed to create device, hr %#x.\n", hr);
4430 wined3d_mutex_unlock();
4435 static HRESULT WINAPI d3d3_CreateDevice(IDirect3D3 *iface, REFCLSID riid,
4436 IDirectDrawSurface4 *surface, IDirect3DDevice3 **device, IUnknown *outer_unknown)
4438 struct ddraw_surface *surface_impl = unsafe_impl_from_IDirectDrawSurface4(surface);
4439 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4440 struct d3d_device *device_impl;
4443 TRACE("iface %p, riid %s, surface %p, device %p, outer_unknown %p.\n",
4444 iface, debugstr_guid(riid), surface, device, outer_unknown);
4447 return CLASS_E_NOAGGREGATION;
4449 wined3d_mutex_lock();
4450 hr = d3d_device_create(ddraw, surface_impl, 3, &device_impl, NULL);
4452 *device = &device_impl->IDirect3DDevice3_iface;
4455 WARN("Failed to create device, hr %#x.\n", hr);
4458 wined3d_mutex_unlock();
4463 static HRESULT WINAPI d3d2_CreateDevice(IDirect3D2 *iface, REFCLSID riid,
4464 IDirectDrawSurface *surface, IDirect3DDevice2 **device)
4466 struct ddraw_surface *surface_impl = unsafe_impl_from_IDirectDrawSurface(surface);
4467 struct ddraw *ddraw = impl_from_IDirect3D2(iface);
4468 struct d3d_device *device_impl;
4471 TRACE("iface %p, riid %s, surface %p, device %p.\n",
4472 iface, debugstr_guid(riid), surface, device);
4474 wined3d_mutex_lock();
4475 hr = d3d_device_create(ddraw, surface_impl, 2, &device_impl, NULL);
4477 *device = &device_impl->IDirect3DDevice2_iface;
4480 WARN("Failed to create device, hr %#x.\n", hr);
4483 wined3d_mutex_unlock();
4488 /*****************************************************************************
4489 * IDirect3D7::CreateVertexBuffer
4491 * Creates a new vertex buffer object and returns a IDirect3DVertexBuffer7
4497 * desc: Requested Vertex buffer properties
4498 * vertex_buffer: Address to return the interface pointer at
4499 * flags: Some flags, should be 0
4503 * DDERR_OUTOFMEMORY if memory allocation failed
4504 * The return value of IWineD3DDevice::CreateVertexBuffer if this call fails
4505 * DDERR_INVALIDPARAMS if desc or vertex_buffer are NULL
4507 *****************************************************************************/
4508 static HRESULT WINAPI d3d7_CreateVertexBuffer(IDirect3D7 *iface, D3DVERTEXBUFFERDESC *desc,
4509 IDirect3DVertexBuffer7 **vertex_buffer, DWORD flags)
4511 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4512 struct d3d_vertex_buffer *object;
4515 TRACE("iface %p, desc %p, vertex_buffer %p, flags %#x.\n",
4516 iface, desc, vertex_buffer, flags);
4518 if (!vertex_buffer || !desc) return DDERR_INVALIDPARAMS;
4520 hr = d3d_vertex_buffer_create(&object, ddraw, desc);
4523 TRACE("Created vertex buffer %p.\n", object);
4524 *vertex_buffer = &object->IDirect3DVertexBuffer7_iface;
4527 WARN("Failed to create vertex buffer, hr %#x.\n", hr);
4532 static HRESULT WINAPI d3d3_CreateVertexBuffer(IDirect3D3 *iface, D3DVERTEXBUFFERDESC *desc,
4533 IDirect3DVertexBuffer **vertex_buffer, DWORD flags, IUnknown *outer_unknown)
4535 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4536 struct d3d_vertex_buffer *object;
4539 TRACE("iface %p, desc %p, vertex_buffer %p, flags %#x, outer_unknown %p.\n",
4540 iface, desc, vertex_buffer, flags, outer_unknown);
4543 return CLASS_E_NOAGGREGATION;
4544 if (!vertex_buffer || !desc)
4545 return DDERR_INVALIDPARAMS;
4547 hr = d3d_vertex_buffer_create(&object, ddraw, desc);
4550 TRACE("Created vertex buffer %p.\n", object);
4551 *vertex_buffer = &object->IDirect3DVertexBuffer_iface;
4554 WARN("Failed to create vertex buffer, hr %#x.\n", hr);
4559 /*****************************************************************************
4560 * IDirect3D7::EnumZBufferFormats
4562 * Enumerates all supported Z buffer pixel formats
4568 * callback: callback to call for each pixel format
4569 * context: Pointer to pass back to the callback
4573 * DDERR_INVALIDPARAMS if callback is NULL
4574 * For details, see IWineD3DDevice::EnumZBufferFormats
4576 *****************************************************************************/
4577 static HRESULT WINAPI d3d7_EnumZBufferFormats(IDirect3D7 *iface, REFCLSID device_iid,
4578 LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
4580 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4581 struct wined3d_display_mode mode;
4582 enum wined3d_device_type type;
4586 /* Order matters. Specifically, BattleZone II (full version) expects the
4587 * 16-bit depth formats to be listed before the 24 and 32 ones. */
4588 static const enum wined3d_format_id formats[] =
4590 WINED3DFMT_S1_UINT_D15_UNORM,
4591 WINED3DFMT_D16_UNORM,
4592 WINED3DFMT_X8D24_UNORM,
4593 WINED3DFMT_S4X4_UINT_D24_UNORM,
4594 WINED3DFMT_D24_UNORM_S8_UINT,
4595 WINED3DFMT_D32_UNORM,
4598 TRACE("iface %p, device_iid %s, callback %p, context %p.\n",
4599 iface, debugstr_guid(device_iid), callback, context);
4601 if (!callback) return DDERR_INVALIDPARAMS;
4603 if (IsEqualGUID(device_iid, &IID_IDirect3DHALDevice)
4604 || IsEqualGUID(device_iid, &IID_IDirect3DTnLHalDevice)
4605 || IsEqualGUID(device_iid, &IID_D3DDEVICE_WineD3D))
4607 TRACE("Asked for HAL device.\n");
4608 type = WINED3D_DEVICE_TYPE_HAL;
4610 else if (IsEqualGUID(device_iid, &IID_IDirect3DRGBDevice)
4611 || IsEqualGUID(device_iid, &IID_IDirect3DMMXDevice))
4613 TRACE("Asked for SW device.\n");
4614 type = WINED3D_DEVICE_TYPE_SW;
4616 else if (IsEqualGUID(device_iid, &IID_IDirect3DRefDevice))
4618 TRACE("Asked for REF device.\n");
4619 type = WINED3D_DEVICE_TYPE_REF;
4621 else if (IsEqualGUID(device_iid, &IID_IDirect3DNullDevice))
4623 TRACE("Asked for NULLREF device.\n");
4624 type = WINED3D_DEVICE_TYPE_NULLREF;
4628 FIXME("Unexpected device GUID %s.\n", debugstr_guid(device_iid));
4629 type = WINED3D_DEVICE_TYPE_HAL;
4632 wined3d_mutex_lock();
4633 /* We need an adapter format from somewhere to please wined3d and WGL.
4634 * Use the current display mode. So far all cards offer the same depth
4635 * stencil format for all modes, but if some do not and applications do
4636 * not like that we'll have to find some workaround, like iterating over
4637 * all imaginable formats and collecting all the depth stencil formats we
4639 hr = wined3d_device_get_display_mode(ddraw->wined3d_device, 0, &mode);
4641 for (i = 0; i < (sizeof(formats) / sizeof(*formats)); ++i)
4643 hr = wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, type, mode.format_id,
4644 WINED3DUSAGE_DEPTHSTENCIL, WINED3D_RTYPE_SURFACE, formats[i], WINED3D_SURFACE_TYPE_OPENGL);
4647 DDPIXELFORMAT pformat;
4649 memset(&pformat, 0, sizeof(pformat));
4650 pformat.dwSize = sizeof(pformat);
4651 PixelFormat_WineD3DtoDD(&pformat, formats[i]);
4653 TRACE("Enumerating wined3d format %#x.\n", formats[i]);
4654 hr = callback(&pformat, context);
4655 if (hr != DDENUMRET_OK)
4657 TRACE("Format enumeration cancelled by application.\n");
4658 wined3d_mutex_unlock();
4664 /* Historically some windows drivers used dwZBufferBitDepth=24 for WINED3DFMT_X8D24_UNORM,
4665 * while others used dwZBufferBitDepth=32. In either case the pitch matches a 32 bits per
4666 * pixel format, so we use dwZBufferBitDepth=32. Some games expect 24. Windows Vista and
4667 * newer enumerate both versions, so we do the same(bug 22434) */
4668 hr = wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT, type, mode.format_id,
4669 WINED3DUSAGE_DEPTHSTENCIL, WINED3D_RTYPE_SURFACE, WINED3DFMT_X8D24_UNORM, WINED3D_SURFACE_TYPE_OPENGL);
4672 DDPIXELFORMAT x8d24 =
4674 sizeof(x8d24), DDPF_ZBUFFER, 0,
4675 {24}, {0x00000000}, {0x00ffffff}, {0x00000000}
4677 TRACE("Enumerating WINED3DFMT_X8D24_UNORM, dwZBufferBitDepth=24 version\n");
4678 callback(&x8d24, context);
4681 TRACE("End of enumeration.\n");
4683 wined3d_mutex_unlock();
4688 static HRESULT WINAPI d3d3_EnumZBufferFormats(IDirect3D3 *iface, REFCLSID device_iid,
4689 LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
4691 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4693 TRACE("iface %p, device_iid %s, callback %p, context %p.\n",
4694 iface, debugstr_guid(device_iid), callback, context);
4696 return d3d7_EnumZBufferFormats(&ddraw->IDirect3D7_iface, device_iid, callback, context);
4699 /*****************************************************************************
4700 * IDirect3D7::EvictManagedTextures
4702 * Removes all managed textures (=surfaces with DDSCAPS2_TEXTUREMANAGE or
4703 * DDSCAPS2_D3DTEXTUREMANAGE caps) to be removed from video memory.
4708 * D3D_OK, because it's a stub
4710 *****************************************************************************/
4711 static HRESULT WINAPI d3d7_EvictManagedTextures(IDirect3D7 *iface)
4713 struct ddraw *ddraw = impl_from_IDirect3D7(iface);
4715 TRACE("iface %p!\n", iface);
4717 wined3d_mutex_lock();
4718 if (ddraw->d3d_initialized)
4719 wined3d_device_evict_managed_resources(ddraw->wined3d_device);
4720 wined3d_mutex_unlock();
4725 static HRESULT WINAPI d3d3_EvictManagedTextures(IDirect3D3 *iface)
4727 struct ddraw *ddraw = impl_from_IDirect3D3(iface);
4729 TRACE("iface %p.\n", iface);
4731 return d3d7_EvictManagedTextures(&ddraw->IDirect3D7_iface);
4734 /*****************************************************************************
4735 * IDirect3DImpl_GetCaps
4737 * This function retrieves the device caps from wined3d
4738 * and converts it into a D3D7 and D3D - D3D3 structure
4739 * This is a helper function called from various places in ddraw
4742 * wined3d: The interface to get the caps from
4743 * desc1: Old D3D <3 structure to fill (needed)
4744 * desc7: D3D7 device desc structure to fill (needed)
4747 * D3D_OK on success, or the return value of IWineD3D::GetCaps
4749 *****************************************************************************/
4750 HRESULT IDirect3DImpl_GetCaps(const struct wined3d *wined3d, D3DDEVICEDESC *desc1, D3DDEVICEDESC7 *desc7)
4752 WINED3DCAPS wined3d_caps;
4755 TRACE("wined3d %p, desc1 %p, desc7 %p.\n", wined3d, desc1, desc7);
4757 memset(&wined3d_caps, 0, sizeof(wined3d_caps));
4759 wined3d_mutex_lock();
4760 hr = wined3d_get_device_caps(wined3d, 0, WINED3D_DEVICE_TYPE_HAL, &wined3d_caps);
4761 wined3d_mutex_unlock();
4764 WARN("Failed to get device caps, hr %#x.\n", hr);
4768 /* Copy the results into the d3d7 and d3d3 structures */
4769 desc7->dwDevCaps = wined3d_caps.DevCaps;
4770 desc7->dpcLineCaps.dwMiscCaps = wined3d_caps.PrimitiveMiscCaps;
4771 desc7->dpcLineCaps.dwRasterCaps = wined3d_caps.RasterCaps;
4772 desc7->dpcLineCaps.dwZCmpCaps = wined3d_caps.ZCmpCaps;
4773 desc7->dpcLineCaps.dwSrcBlendCaps = wined3d_caps.SrcBlendCaps;
4774 desc7->dpcLineCaps.dwDestBlendCaps = wined3d_caps.DestBlendCaps;
4775 desc7->dpcLineCaps.dwAlphaCmpCaps = wined3d_caps.AlphaCmpCaps;
4776 desc7->dpcLineCaps.dwShadeCaps = wined3d_caps.ShadeCaps;
4777 desc7->dpcLineCaps.dwTextureCaps = wined3d_caps.TextureCaps;
4778 desc7->dpcLineCaps.dwTextureFilterCaps = wined3d_caps.TextureFilterCaps;
4779 desc7->dpcLineCaps.dwTextureAddressCaps = wined3d_caps.TextureAddressCaps;
4781 desc7->dwMaxTextureWidth = wined3d_caps.MaxTextureWidth;
4782 desc7->dwMaxTextureHeight = wined3d_caps.MaxTextureHeight;
4784 desc7->dwMaxTextureRepeat = wined3d_caps.MaxTextureRepeat;
4785 desc7->dwMaxTextureAspectRatio = wined3d_caps.MaxTextureAspectRatio;
4786 desc7->dwMaxAnisotropy = wined3d_caps.MaxAnisotropy;
4787 desc7->dvMaxVertexW = wined3d_caps.MaxVertexW;
4789 desc7->dvGuardBandLeft = wined3d_caps.GuardBandLeft;
4790 desc7->dvGuardBandTop = wined3d_caps.GuardBandTop;
4791 desc7->dvGuardBandRight = wined3d_caps.GuardBandRight;
4792 desc7->dvGuardBandBottom = wined3d_caps.GuardBandBottom;
4794 desc7->dvExtentsAdjust = wined3d_caps.ExtentsAdjust;
4795 desc7->dwStencilCaps = wined3d_caps.StencilCaps;
4797 desc7->dwFVFCaps = wined3d_caps.FVFCaps;
4798 desc7->dwTextureOpCaps = wined3d_caps.TextureOpCaps;
4800 desc7->dwVertexProcessingCaps = wined3d_caps.VertexProcessingCaps;
4801 desc7->dwMaxActiveLights = wined3d_caps.MaxActiveLights;
4803 /* Remove all non-d3d7 caps */
4804 desc7->dwDevCaps &= (
4805 D3DDEVCAPS_FLOATTLVERTEX | D3DDEVCAPS_SORTINCREASINGZ | D3DDEVCAPS_SORTDECREASINGZ |
4806 D3DDEVCAPS_SORTEXACT | D3DDEVCAPS_EXECUTESYSTEMMEMORY | D3DDEVCAPS_EXECUTEVIDEOMEMORY |
4807 D3DDEVCAPS_TLVERTEXSYSTEMMEMORY | D3DDEVCAPS_TLVERTEXVIDEOMEMORY | D3DDEVCAPS_TEXTURESYSTEMMEMORY |
4808 D3DDEVCAPS_TEXTUREVIDEOMEMORY | D3DDEVCAPS_DRAWPRIMTLVERTEX | D3DDEVCAPS_CANRENDERAFTERFLIP |
4809 D3DDEVCAPS_TEXTURENONLOCALVIDMEM | D3DDEVCAPS_DRAWPRIMITIVES2 | D3DDEVCAPS_SEPARATETEXTUREMEMORIES |
4810 D3DDEVCAPS_DRAWPRIMITIVES2EX | D3DDEVCAPS_HWTRANSFORMANDLIGHT | D3DDEVCAPS_CANBLTSYSTONONLOCAL |
4811 D3DDEVCAPS_HWRASTERIZATION);
4813 desc7->dwStencilCaps &= (
4814 D3DSTENCILCAPS_KEEP | D3DSTENCILCAPS_ZERO | D3DSTENCILCAPS_REPLACE |
4815 D3DSTENCILCAPS_INCRSAT | D3DSTENCILCAPS_DECRSAT | D3DSTENCILCAPS_INVERT |
4816 D3DSTENCILCAPS_INCR | D3DSTENCILCAPS_DECR);
4820 desc7->dwTextureOpCaps &= (
4821 D3DTEXOPCAPS_DISABLE | D3DTEXOPCAPS_SELECTARG1 | D3DTEXOPCAPS_SELECTARG2 |
4822 D3DTEXOPCAPS_MODULATE | D3DTEXOPCAPS_MODULATE2X | D3DTEXOPCAPS_MODULATE4X |
4823 D3DTEXOPCAPS_ADD | D3DTEXOPCAPS_ADDSIGNED | D3DTEXOPCAPS_ADDSIGNED2X |
4824 D3DTEXOPCAPS_SUBTRACT | D3DTEXOPCAPS_ADDSMOOTH | D3DTEXOPCAPS_BLENDTEXTUREALPHA |
4825 D3DTEXOPCAPS_BLENDFACTORALPHA | D3DTEXOPCAPS_BLENDTEXTUREALPHAPM | D3DTEXOPCAPS_BLENDCURRENTALPHA |
4826 D3DTEXOPCAPS_PREMODULATE | D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
4827 D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA | D3DTEXOPCAPS_BUMPENVMAP |
4828 D3DTEXOPCAPS_BUMPENVMAPLUMINANCE | D3DTEXOPCAPS_DOTPRODUCT3);
4830 desc7->dwVertexProcessingCaps &= (
4831 D3DVTXPCAPS_TEXGEN | D3DVTXPCAPS_MATERIALSOURCE7 | D3DVTXPCAPS_VERTEXFOG |
4832 D3DVTXPCAPS_DIRECTIONALLIGHTS | D3DVTXPCAPS_POSITIONALLIGHTS | D3DVTXPCAPS_LOCALVIEWER);
4834 desc7->dpcLineCaps.dwMiscCaps &= (
4835 D3DPMISCCAPS_MASKPLANES | D3DPMISCCAPS_MASKZ | D3DPMISCCAPS_LINEPATTERNREP |
4836 D3DPMISCCAPS_CONFORMANT | D3DPMISCCAPS_CULLNONE | D3DPMISCCAPS_CULLCW |
4837 D3DPMISCCAPS_CULLCCW);
4839 desc7->dpcLineCaps.dwRasterCaps &= (
4840 D3DPRASTERCAPS_DITHER | D3DPRASTERCAPS_ROP2 | D3DPRASTERCAPS_XOR |
4841 D3DPRASTERCAPS_PAT | D3DPRASTERCAPS_ZTEST | D3DPRASTERCAPS_SUBPIXEL |
4842 D3DPRASTERCAPS_SUBPIXELX | D3DPRASTERCAPS_FOGVERTEX | D3DPRASTERCAPS_FOGTABLE |
4843 D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT | D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT |
4844 D3DPRASTERCAPS_ANTIALIASEDGES | D3DPRASTERCAPS_MIPMAPLODBIAS | D3DPRASTERCAPS_ZBIAS |
4845 D3DPRASTERCAPS_ZBUFFERLESSHSR | D3DPRASTERCAPS_FOGRANGE | D3DPRASTERCAPS_ANISOTROPY |
4846 D3DPRASTERCAPS_WBUFFER | D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT | D3DPRASTERCAPS_WFOG |
4847 D3DPRASTERCAPS_ZFOG);
4849 desc7->dpcLineCaps.dwZCmpCaps &= (
4850 D3DPCMPCAPS_NEVER | D3DPCMPCAPS_LESS | D3DPCMPCAPS_EQUAL |
4851 D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_NOTEQUAL |
4852 D3DPCMPCAPS_GREATEREQUAL | D3DPCMPCAPS_ALWAYS);
4854 desc7->dpcLineCaps.dwSrcBlendCaps &= (
4855 D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR |
4856 D3DPBLENDCAPS_INVSRCCOLOR | D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA |
4857 D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_DESTCOLOR |
4858 D3DPBLENDCAPS_INVDESTCOLOR | D3DPBLENDCAPS_SRCALPHASAT | D3DPBLENDCAPS_BOTHSRCALPHA |
4859 D3DPBLENDCAPS_BOTHINVSRCALPHA);
4861 desc7->dpcLineCaps.dwDestBlendCaps &= (
4862 D3DPBLENDCAPS_ZERO | D3DPBLENDCAPS_ONE | D3DPBLENDCAPS_SRCCOLOR |
4863 D3DPBLENDCAPS_INVSRCCOLOR | D3DPBLENDCAPS_SRCALPHA | D3DPBLENDCAPS_INVSRCALPHA |
4864 D3DPBLENDCAPS_DESTALPHA | D3DPBLENDCAPS_INVDESTALPHA | D3DPBLENDCAPS_DESTCOLOR |
4865 D3DPBLENDCAPS_INVDESTCOLOR | D3DPBLENDCAPS_SRCALPHASAT | D3DPBLENDCAPS_BOTHSRCALPHA |
4866 D3DPBLENDCAPS_BOTHINVSRCALPHA);
4868 desc7->dpcLineCaps.dwAlphaCmpCaps &= (
4869 D3DPCMPCAPS_NEVER | D3DPCMPCAPS_LESS | D3DPCMPCAPS_EQUAL |
4870 D3DPCMPCAPS_LESSEQUAL | D3DPCMPCAPS_GREATER | D3DPCMPCAPS_NOTEQUAL |
4871 D3DPCMPCAPS_GREATEREQUAL | D3DPCMPCAPS_ALWAYS);
4873 desc7->dpcLineCaps.dwShadeCaps &= (
4874 D3DPSHADECAPS_COLORFLATMONO | D3DPSHADECAPS_COLORFLATRGB | D3DPSHADECAPS_COLORGOURAUDMONO |
4875 D3DPSHADECAPS_COLORGOURAUDRGB | D3DPSHADECAPS_COLORPHONGMONO | D3DPSHADECAPS_COLORPHONGRGB |
4876 D3DPSHADECAPS_SPECULARFLATMONO | D3DPSHADECAPS_SPECULARFLATRGB | D3DPSHADECAPS_SPECULARGOURAUDMONO |
4877 D3DPSHADECAPS_SPECULARGOURAUDRGB | D3DPSHADECAPS_SPECULARPHONGMONO | D3DPSHADECAPS_SPECULARPHONGRGB |
4878 D3DPSHADECAPS_ALPHAFLATBLEND | D3DPSHADECAPS_ALPHAFLATSTIPPLED | D3DPSHADECAPS_ALPHAGOURAUDBLEND |
4879 D3DPSHADECAPS_ALPHAGOURAUDSTIPPLED | D3DPSHADECAPS_ALPHAPHONGBLEND | D3DPSHADECAPS_ALPHAPHONGSTIPPLED |
4880 D3DPSHADECAPS_FOGFLAT | D3DPSHADECAPS_FOGGOURAUD | D3DPSHADECAPS_FOGPHONG);
4882 desc7->dpcLineCaps.dwTextureCaps &= (
4883 D3DPTEXTURECAPS_PERSPECTIVE | D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_ALPHA |
4884 D3DPTEXTURECAPS_TRANSPARENCY | D3DPTEXTURECAPS_BORDER | D3DPTEXTURECAPS_SQUAREONLY |
4885 D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE | D3DPTEXTURECAPS_ALPHAPALETTE| D3DPTEXTURECAPS_NONPOW2CONDITIONAL |
4886 D3DPTEXTURECAPS_PROJECTED | D3DPTEXTURECAPS_CUBEMAP | D3DPTEXTURECAPS_COLORKEYBLEND);
4888 desc7->dpcLineCaps.dwTextureFilterCaps &= (
4889 D3DPTFILTERCAPS_NEAREST | D3DPTFILTERCAPS_LINEAR | D3DPTFILTERCAPS_MIPNEAREST |
4890 D3DPTFILTERCAPS_MIPLINEAR | D3DPTFILTERCAPS_LINEARMIPNEAREST | D3DPTFILTERCAPS_LINEARMIPLINEAR |
4891 D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MINFLINEAR | D3DPTFILTERCAPS_MINFANISOTROPIC |
4892 D3DPTFILTERCAPS_MIPFPOINT | D3DPTFILTERCAPS_MIPFLINEAR | D3DPTFILTERCAPS_MAGFPOINT |
4893 D3DPTFILTERCAPS_MAGFLINEAR | D3DPTFILTERCAPS_MAGFANISOTROPIC | D3DPTFILTERCAPS_MAGFAFLATCUBIC |
4894 D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC);
4896 desc7->dpcLineCaps.dwTextureBlendCaps &= (
4897 D3DPTBLENDCAPS_DECAL | D3DPTBLENDCAPS_MODULATE | D3DPTBLENDCAPS_DECALALPHA |
4898 D3DPTBLENDCAPS_MODULATEALPHA | D3DPTBLENDCAPS_DECALMASK | D3DPTBLENDCAPS_MODULATEMASK |
4899 D3DPTBLENDCAPS_COPY | D3DPTBLENDCAPS_ADD);
4901 desc7->dpcLineCaps.dwTextureAddressCaps &= (
4902 D3DPTADDRESSCAPS_WRAP | D3DPTADDRESSCAPS_MIRROR | D3DPTADDRESSCAPS_CLAMP |
4903 D3DPTADDRESSCAPS_BORDER | D3DPTADDRESSCAPS_INDEPENDENTUV);
4905 if (!(desc7->dpcLineCaps.dwTextureCaps & D3DPTEXTURECAPS_POW2))
4907 /* DirectX7 always has the np2 flag set, no matter what the card
4908 * supports. Some old games (Rollcage) check the caps incorrectly.
4909 * If wined3d supports nonpow2 textures it also has np2 conditional
4911 desc7->dpcLineCaps.dwTextureCaps |= D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL;
4914 /* Fill the missing members, and do some fixup */
4915 desc7->dpcLineCaps.dwSize = sizeof(desc7->dpcLineCaps);
4916 desc7->dpcLineCaps.dwTextureBlendCaps = D3DPTBLENDCAPS_ADD | D3DPTBLENDCAPS_MODULATEMASK |
4917 D3DPTBLENDCAPS_COPY | D3DPTBLENDCAPS_DECAL |
4918 D3DPTBLENDCAPS_DECALALPHA | D3DPTBLENDCAPS_DECALMASK |
4919 D3DPTBLENDCAPS_MODULATE | D3DPTBLENDCAPS_MODULATEALPHA;
4920 desc7->dpcLineCaps.dwStippleWidth = 32;
4921 desc7->dpcLineCaps.dwStippleHeight = 32;
4922 /* Use the same for the TriCaps */
4923 desc7->dpcTriCaps = desc7->dpcLineCaps;
4925 desc7->dwDeviceRenderBitDepth = DDBD_16 | DDBD_24 | DDBD_32;
4926 desc7->dwDeviceZBufferBitDepth = DDBD_16 | DDBD_24;
4927 desc7->dwMinTextureWidth = 1;
4928 desc7->dwMinTextureHeight = 1;
4930 /* Convert DWORDs safely to WORDs */
4931 if (wined3d_caps.MaxTextureBlendStages > 0xffff) desc7->wMaxTextureBlendStages = 0xffff;
4932 else desc7->wMaxTextureBlendStages = (WORD)wined3d_caps.MaxTextureBlendStages;
4933 if (wined3d_caps.MaxSimultaneousTextures > 0xffff) desc7->wMaxSimultaneousTextures = 0xffff;
4934 else desc7->wMaxSimultaneousTextures = (WORD)wined3d_caps.MaxSimultaneousTextures;
4936 if (wined3d_caps.MaxUserClipPlanes > 0xffff) desc7->wMaxUserClipPlanes = 0xffff;
4937 else desc7->wMaxUserClipPlanes = (WORD)wined3d_caps.MaxUserClipPlanes;
4938 if (wined3d_caps.MaxVertexBlendMatrices > 0xffff) desc7->wMaxVertexBlendMatrices = 0xffff;
4939 else desc7->wMaxVertexBlendMatrices = (WORD)wined3d_caps.MaxVertexBlendMatrices;
4941 desc7->deviceGUID = IID_IDirect3DTnLHalDevice;
4943 desc7->dwReserved1 = 0;
4944 desc7->dwReserved2 = 0;
4945 desc7->dwReserved3 = 0;
4946 desc7->dwReserved4 = 0;
4948 /* Fill the old structure */
4949 memset(desc1, 0, sizeof(*desc1));
4950 desc1->dwSize = sizeof(D3DDEVICEDESC);
4951 desc1->dwFlags = D3DDD_COLORMODEL
4953 | D3DDD_TRANSFORMCAPS
4955 | D3DDD_LIGHTINGCAPS
4958 | D3DDD_DEVICERENDERBITDEPTH
4959 | D3DDD_DEVICEZBUFFERBITDEPTH
4960 | D3DDD_MAXBUFFERSIZE
4961 | D3DDD_MAXVERTEXCOUNT;
4963 desc1->dcmColorModel = D3DCOLOR_RGB;
4964 desc1->dwDevCaps = desc7->dwDevCaps;
4965 desc1->dtcTransformCaps.dwSize = sizeof(D3DTRANSFORMCAPS);
4966 desc1->dtcTransformCaps.dwCaps = D3DTRANSFORMCAPS_CLIP;
4967 desc1->bClipping = TRUE;
4968 desc1->dlcLightingCaps.dwSize = sizeof(D3DLIGHTINGCAPS);
4969 desc1->dlcLightingCaps.dwCaps = D3DLIGHTCAPS_DIRECTIONAL
4970 | D3DLIGHTCAPS_PARALLELPOINT
4971 | D3DLIGHTCAPS_POINT
4972 | D3DLIGHTCAPS_SPOT;
4974 desc1->dlcLightingCaps.dwLightingModel = D3DLIGHTINGMODEL_RGB;
4975 desc1->dlcLightingCaps.dwNumLights = desc7->dwMaxActiveLights;
4977 desc1->dpcLineCaps.dwSize = sizeof(D3DPRIMCAPS);
4978 desc1->dpcLineCaps.dwMiscCaps = desc7->dpcLineCaps.dwMiscCaps;
4979 desc1->dpcLineCaps.dwRasterCaps = desc7->dpcLineCaps.dwRasterCaps;
4980 desc1->dpcLineCaps.dwZCmpCaps = desc7->dpcLineCaps.dwZCmpCaps;
4981 desc1->dpcLineCaps.dwSrcBlendCaps = desc7->dpcLineCaps.dwSrcBlendCaps;
4982 desc1->dpcLineCaps.dwDestBlendCaps = desc7->dpcLineCaps.dwDestBlendCaps;
4983 desc1->dpcLineCaps.dwShadeCaps = desc7->dpcLineCaps.dwShadeCaps;
4984 desc1->dpcLineCaps.dwTextureCaps = desc7->dpcLineCaps.dwTextureCaps;
4985 desc1->dpcLineCaps.dwTextureFilterCaps = desc7->dpcLineCaps.dwTextureFilterCaps;
4986 desc1->dpcLineCaps.dwTextureBlendCaps = desc7->dpcLineCaps.dwTextureBlendCaps;
4987 desc1->dpcLineCaps.dwTextureAddressCaps = desc7->dpcLineCaps.dwTextureAddressCaps;
4988 desc1->dpcLineCaps.dwStippleWidth = desc7->dpcLineCaps.dwStippleWidth;
4989 desc1->dpcLineCaps.dwAlphaCmpCaps = desc7->dpcLineCaps.dwAlphaCmpCaps;
4991 desc1->dpcTriCaps.dwSize = sizeof(D3DPRIMCAPS);
4992 desc1->dpcTriCaps.dwMiscCaps = desc7->dpcTriCaps.dwMiscCaps;
4993 desc1->dpcTriCaps.dwRasterCaps = desc7->dpcTriCaps.dwRasterCaps;
4994 desc1->dpcTriCaps.dwZCmpCaps = desc7->dpcTriCaps.dwZCmpCaps;
4995 desc1->dpcTriCaps.dwSrcBlendCaps = desc7->dpcTriCaps.dwSrcBlendCaps;
4996 desc1->dpcTriCaps.dwDestBlendCaps = desc7->dpcTriCaps.dwDestBlendCaps;
4997 desc1->dpcTriCaps.dwShadeCaps = desc7->dpcTriCaps.dwShadeCaps;
4998 desc1->dpcTriCaps.dwTextureCaps = desc7->dpcTriCaps.dwTextureCaps;
4999 desc1->dpcTriCaps.dwTextureFilterCaps = desc7->dpcTriCaps.dwTextureFilterCaps;
5000 desc1->dpcTriCaps.dwTextureBlendCaps = desc7->dpcTriCaps.dwTextureBlendCaps;
5001 desc1->dpcTriCaps.dwTextureAddressCaps = desc7->dpcTriCaps.dwTextureAddressCaps;
5002 desc1->dpcTriCaps.dwStippleWidth = desc7->dpcTriCaps.dwStippleWidth;
5003 desc1->dpcTriCaps.dwAlphaCmpCaps = desc7->dpcTriCaps.dwAlphaCmpCaps;
5005 desc1->dwDeviceRenderBitDepth = desc7->dwDeviceRenderBitDepth;
5006 desc1->dwDeviceZBufferBitDepth = desc7->dwDeviceZBufferBitDepth;
5007 desc1->dwMaxBufferSize = 0;
5008 desc1->dwMaxVertexCount = 65536;
5009 desc1->dwMinTextureWidth = desc7->dwMinTextureWidth;
5010 desc1->dwMinTextureHeight = desc7->dwMinTextureHeight;
5011 desc1->dwMaxTextureWidth = desc7->dwMaxTextureWidth;
5012 desc1->dwMaxTextureHeight = desc7->dwMaxTextureHeight;
5013 desc1->dwMinStippleWidth = 1;
5014 desc1->dwMinStippleHeight = 1;
5015 desc1->dwMaxStippleWidth = 32;
5016 desc1->dwMaxStippleHeight = 32;
5017 desc1->dwMaxTextureRepeat = desc7->dwMaxTextureRepeat;
5018 desc1->dwMaxTextureAspectRatio = desc7->dwMaxTextureAspectRatio;
5019 desc1->dwMaxAnisotropy = desc7->dwMaxAnisotropy;
5020 desc1->dvGuardBandLeft = desc7->dvGuardBandLeft;
5021 desc1->dvGuardBandRight = desc7->dvGuardBandRight;
5022 desc1->dvGuardBandTop = desc7->dvGuardBandTop;
5023 desc1->dvGuardBandBottom = desc7->dvGuardBandBottom;
5024 desc1->dvExtentsAdjust = desc7->dvExtentsAdjust;
5025 desc1->dwStencilCaps = desc7->dwStencilCaps;
5026 desc1->dwFVFCaps = desc7->dwFVFCaps;
5027 desc1->dwTextureOpCaps = desc7->dwTextureOpCaps;
5028 desc1->wMaxTextureBlendStages = desc7->wMaxTextureBlendStages;
5029 desc1->wMaxSimultaneousTextures = desc7->wMaxSimultaneousTextures;
5034 /*****************************************************************************
5035 * IDirectDraw7 VTable
5036 *****************************************************************************/
5037 static const struct IDirectDraw7Vtbl ddraw7_vtbl =
5040 ddraw7_QueryInterface,
5045 ddraw7_CreateClipper,
5046 ddraw7_CreatePalette,
5047 ddraw7_CreateSurface,
5048 ddraw7_DuplicateSurface,
5049 ddraw7_EnumDisplayModes,
5050 ddraw7_EnumSurfaces,
5051 ddraw7_FlipToGDISurface,
5053 ddraw7_GetDisplayMode,
5054 ddraw7_GetFourCCCodes,
5055 ddraw7_GetGDISurface,
5056 ddraw7_GetMonitorFrequency,
5058 ddraw7_GetVerticalBlankStatus,
5060 ddraw7_RestoreDisplayMode,
5061 ddraw7_SetCooperativeLevel,
5062 ddraw7_SetDisplayMode,
5063 ddraw7_WaitForVerticalBlank,
5065 ddraw7_GetAvailableVidMem,
5067 ddraw7_GetSurfaceFromDC,
5069 ddraw7_RestoreAllSurfaces,
5070 ddraw7_TestCooperativeLevel,
5071 ddraw7_GetDeviceIdentifier,
5073 ddraw7_StartModeTest,
5077 static const struct IDirectDraw4Vtbl ddraw4_vtbl =
5080 ddraw4_QueryInterface,
5085 ddraw4_CreateClipper,
5086 ddraw4_CreatePalette,
5087 ddraw4_CreateSurface,
5088 ddraw4_DuplicateSurface,
5089 ddraw4_EnumDisplayModes,
5090 ddraw4_EnumSurfaces,
5091 ddraw4_FlipToGDISurface,
5093 ddraw4_GetDisplayMode,
5094 ddraw4_GetFourCCCodes,
5095 ddraw4_GetGDISurface,
5096 ddraw4_GetMonitorFrequency,
5098 ddraw4_GetVerticalBlankStatus,
5100 ddraw4_RestoreDisplayMode,
5101 ddraw4_SetCooperativeLevel,
5102 ddraw4_SetDisplayMode,
5103 ddraw4_WaitForVerticalBlank,
5105 ddraw4_GetAvailableVidMem,
5107 ddraw4_GetSurfaceFromDC,
5109 ddraw4_RestoreAllSurfaces,
5110 ddraw4_TestCooperativeLevel,
5111 ddraw4_GetDeviceIdentifier,
5114 static const struct IDirectDraw2Vtbl ddraw2_vtbl =
5117 ddraw2_QueryInterface,
5122 ddraw2_CreateClipper,
5123 ddraw2_CreatePalette,
5124 ddraw2_CreateSurface,
5125 ddraw2_DuplicateSurface,
5126 ddraw2_EnumDisplayModes,
5127 ddraw2_EnumSurfaces,
5128 ddraw2_FlipToGDISurface,
5130 ddraw2_GetDisplayMode,
5131 ddraw2_GetFourCCCodes,
5132 ddraw2_GetGDISurface,
5133 ddraw2_GetMonitorFrequency,
5135 ddraw2_GetVerticalBlankStatus,
5137 ddraw2_RestoreDisplayMode,
5138 ddraw2_SetCooperativeLevel,
5139 ddraw2_SetDisplayMode,
5140 ddraw2_WaitForVerticalBlank,
5142 ddraw2_GetAvailableVidMem,
5145 static const struct IDirectDrawVtbl ddraw1_vtbl =
5148 ddraw1_QueryInterface,
5153 ddraw1_CreateClipper,
5154 ddraw1_CreatePalette,
5155 ddraw1_CreateSurface,
5156 ddraw1_DuplicateSurface,
5157 ddraw1_EnumDisplayModes,
5158 ddraw1_EnumSurfaces,
5159 ddraw1_FlipToGDISurface,
5161 ddraw1_GetDisplayMode,
5162 ddraw1_GetFourCCCodes,
5163 ddraw1_GetGDISurface,
5164 ddraw1_GetMonitorFrequency,
5166 ddraw1_GetVerticalBlankStatus,
5168 ddraw1_RestoreDisplayMode,
5169 ddraw1_SetCooperativeLevel,
5170 ddraw1_SetDisplayMode,
5171 ddraw1_WaitForVerticalBlank,
5174 static const struct IDirect3D7Vtbl d3d7_vtbl =
5176 /* IUnknown methods */
5177 d3d7_QueryInterface,
5180 /* IDirect3D7 methods */
5183 d3d7_CreateVertexBuffer,
5184 d3d7_EnumZBufferFormats,
5185 d3d7_EvictManagedTextures
5188 static const struct IDirect3D3Vtbl d3d3_vtbl =
5190 /* IUnknown methods */
5191 d3d3_QueryInterface,
5194 /* IDirect3D3 methods */
5197 d3d3_CreateMaterial,
5198 d3d3_CreateViewport,
5201 d3d3_CreateVertexBuffer,
5202 d3d3_EnumZBufferFormats,
5203 d3d3_EvictManagedTextures
5206 static const struct IDirect3D2Vtbl d3d2_vtbl =
5208 /* IUnknown methods */
5209 d3d2_QueryInterface,
5212 /* IDirect3D2 methods */
5215 d3d2_CreateMaterial,
5216 d3d2_CreateViewport,
5221 static const struct IDirect3DVtbl d3d1_vtbl =
5223 /* IUnknown methods */
5224 d3d1_QueryInterface,
5227 /* IDirect3D methods */
5231 d3d1_CreateMaterial,
5232 d3d1_CreateViewport,
5236 /*****************************************************************************
5239 * Finds the WineD3D vertex declaration for a specific fvf, and creates one
5240 * if none was found.
5242 * This function is in ddraw.c and the DDraw object space because D3D7
5243 * vertex buffers are created using the IDirect3D interface to the ddraw
5244 * object, so they can be valid across D3D devices(theoretically. The ddraw
5245 * object also owns the wined3d device
5249 * fvf: Fvf to find the decl for
5252 * NULL in case of an error, the vertex declaration for the FVF otherwise.
5254 *****************************************************************************/
5255 struct wined3d_vertex_declaration *ddraw_find_decl(struct ddraw *This, DWORD fvf)
5257 struct wined3d_vertex_declaration *pDecl = NULL;
5259 int p, low, high; /* deliberately signed */
5260 struct FvfToDecl *convertedDecls = This->decls;
5262 TRACE("Searching for declaration for fvf %08x... ", fvf);
5265 high = This->numConvertedDecls - 1;
5266 while(low <= high) {
5267 p = (low + high) >> 1;
5269 if(convertedDecls[p].fvf == fvf) {
5270 TRACE("found %p\n", convertedDecls[p].decl);
5271 return convertedDecls[p].decl;
5272 } else if(convertedDecls[p].fvf < fvf) {
5278 TRACE("not found. Creating and inserting at position %d.\n", low);
5280 hr = wined3d_vertex_declaration_create_from_fvf(This->wined3d_device,
5281 fvf, This, &ddraw_null_wined3d_parent_ops, &pDecl);
5282 if (hr != S_OK) return NULL;
5284 if(This->declArraySize == This->numConvertedDecls) {
5285 int grow = max(This->declArraySize / 2, 8);
5286 convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls,
5287 sizeof(convertedDecls[0]) * (This->numConvertedDecls + grow));
5288 if (!convertedDecls)
5290 wined3d_vertex_declaration_decref(pDecl);
5293 This->decls = convertedDecls;
5294 This->declArraySize += grow;
5297 memmove(convertedDecls + low + 1, convertedDecls + low, sizeof(convertedDecls[0]) * (This->numConvertedDecls - low));
5298 convertedDecls[low].decl = pDecl;
5299 convertedDecls[low].fvf = fvf;
5300 This->numConvertedDecls++;
5302 TRACE("Returning %p. %d decls in array\n", pDecl, This->numConvertedDecls);
5306 static inline struct ddraw *ddraw_from_device_parent(struct wined3d_device_parent *device_parent)
5308 return CONTAINING_RECORD(device_parent, struct ddraw, device_parent);
5311 static void CDECL device_parent_wined3d_device_created(struct wined3d_device_parent *device_parent,
5312 struct wined3d_device *device)
5314 TRACE("device_parent %p, device %p.\n", device_parent, device);
5317 /* This is run from device_process_message() in wined3d, we can't take the
5319 static void CDECL device_parent_mode_changed(struct wined3d_device_parent *device_parent)
5321 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
5322 MONITORINFO monitor_info;
5327 TRACE("device_parent %p.\n", device_parent);
5329 if (!(ddraw->cooperative_level & DDSCL_EXCLUSIVE) || !ddraw->swapchain_window)
5331 TRACE("Nothing to resize.\n");
5335 monitor = MonitorFromWindow(ddraw->swapchain_window, MONITOR_DEFAULTTOPRIMARY);
5336 monitor_info.cbSize = sizeof(monitor_info);
5337 if (!(ret = GetMonitorInfoW(monitor, &monitor_info)))
5339 ERR("Failed to get monitor info.\n");
5343 r = &monitor_info.rcMonitor;
5344 TRACE("Resizing window %p to %s.\n", ddraw->swapchain_window, wine_dbgstr_rect(r));
5346 if (!(ret = SetWindowPos(ddraw->swapchain_window, HWND_TOP, r->left, r->top,
5347 r->right - r->left, r->bottom - r->top, SWP_SHOWWINDOW | SWP_NOACTIVATE)))
5348 ERR("Failed to resize window.\n");
5351 static HRESULT CDECL device_parent_create_surface(struct wined3d_device_parent *device_parent,
5352 void *container_parent, UINT width, UINT height, enum wined3d_format_id format, DWORD usage,
5353 enum wined3d_pool pool, UINT level, enum wined3d_cubemap_face face, struct wined3d_surface **surface)
5355 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
5356 struct ddraw_surface *surf = NULL;
5358 DDSCAPS2 searchcaps = ddraw->tex_root->surface_desc.ddsCaps;
5360 TRACE("device_parent %p, container_parent %p, width %u, height %u, format %#x, usage %#x,\n"
5361 "\tpool %#x, level %u, face %u, surface %p.\n",
5362 device_parent, container_parent, width, height, format, usage, pool, level, face, surface);
5364 searchcaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
5367 case WINED3D_CUBEMAP_FACE_POSITIVE_X:
5368 TRACE("Asked for positive x\n");
5369 if (searchcaps.dwCaps2 & DDSCAPS2_CUBEMAP)
5371 searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEX;
5373 surf = ddraw->tex_root; break;
5374 case WINED3D_CUBEMAP_FACE_NEGATIVE_X:
5375 TRACE("Asked for negative x\n");
5376 searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEX; break;
5377 case WINED3D_CUBEMAP_FACE_POSITIVE_Y:
5378 TRACE("Asked for positive y\n");
5379 searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEY; break;
5380 case WINED3D_CUBEMAP_FACE_NEGATIVE_Y:
5381 TRACE("Asked for negative y\n");
5382 searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEY; break;
5383 case WINED3D_CUBEMAP_FACE_POSITIVE_Z:
5384 TRACE("Asked for positive z\n");
5385 searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEZ; break;
5386 case WINED3D_CUBEMAP_FACE_NEGATIVE_Z:
5387 TRACE("Asked for negative z\n");
5388 searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEZ; break;
5390 ERR("Unexpected cube face.\n");
5395 IDirectDrawSurface7 *attached;
5396 IDirectDrawSurface7_GetAttachedSurface(&ddraw->tex_root->IDirectDrawSurface7_iface, &searchcaps, &attached);
5397 surf = unsafe_impl_from_IDirectDrawSurface7(attached);
5398 IDirectDrawSurface7_Release(attached);
5400 if (!surf) ERR("root search surface not found\n");
5402 /* Find the wanted mipmap. There are enough mipmaps in the chain */
5405 IDirectDrawSurface7 *attached;
5406 IDirectDrawSurface7_GetAttachedSurface(&surf->IDirectDrawSurface7_iface, &searchcaps, &attached);
5407 if(!attached) ERR("Surface not found\n");
5408 surf = impl_from_IDirectDrawSurface7(attached);
5409 IDirectDrawSurface7_Release(attached);
5413 /* Return the surface */
5414 *surface = surf->wined3d_surface;
5415 wined3d_surface_incref(*surface);
5417 TRACE("Returning wineD3DSurface %p, it belongs to surface %p\n", *surface, surf);
5422 static void STDMETHODCALLTYPE ddraw_frontbuffer_destroyed(void *parent)
5424 struct ddraw *ddraw = parent;
5425 ddraw->wined3d_frontbuffer = NULL;
5428 static const struct wined3d_parent_ops ddraw_frontbuffer_parent_ops =
5430 ddraw_frontbuffer_destroyed,
5433 static HRESULT CDECL device_parent_create_rendertarget(struct wined3d_device_parent *device_parent,
5434 void *container_parent, UINT width, UINT height, enum wined3d_format_id format,
5435 enum wined3d_multisample_type multisample_type, DWORD multisample_quality, BOOL lockable,
5436 struct wined3d_surface **surface)
5438 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
5442 TRACE("device_parent %p, container_parent %p, width %u, height %u, format %#x, multisample_type %#x,\n"
5443 "\tmultisample_quality %u, lockable %u, surface %p.\n",
5444 device_parent, container_parent, width, height, format, multisample_type,
5445 multisample_quality, lockable, surface);
5447 if (ddraw->wined3d_frontbuffer)
5449 ERR("Frontbuffer already created.\n");
5454 flags |= WINED3D_SURFACE_MAPPABLE;
5456 hr = wined3d_surface_create(ddraw->wined3d_device, width, height, format, 0,
5457 WINED3DUSAGE_RENDERTARGET, WINED3D_POOL_DEFAULT, multisample_type, multisample_quality,
5458 DefaultSurfaceType, flags, ddraw, &ddraw_frontbuffer_parent_ops, surface);
5460 ddraw->wined3d_frontbuffer = *surface;
5465 static HRESULT CDECL device_parent_create_depth_stencil(struct wined3d_device_parent *device_parent,
5466 UINT width, UINT height, enum wined3d_format_id format, enum wined3d_multisample_type multisample_type,
5467 DWORD multisample_quality, BOOL discard, struct wined3d_surface **surface)
5469 ERR("DirectDraw doesn't have and shouldn't try creating implicit depth buffers.\n");
5473 static HRESULT CDECL device_parent_create_volume(struct wined3d_device_parent *device_parent,
5474 void *container_parent, UINT width, UINT height, UINT depth, enum wined3d_format_id format,
5475 enum wined3d_pool pool, DWORD usage, struct wined3d_volume **volume)
5477 TRACE("device_parent %p, container_parent %p, width %u, height %u, depth %u, "
5478 "format %#x, pool %#x, usage %#x, volume %p.\n",
5479 device_parent, container_parent, width, height, depth,
5480 format, pool, usage, volume);
5482 ERR("Not implemented!\n");
5487 static HRESULT CDECL device_parent_create_swapchain(struct wined3d_device_parent *device_parent,
5488 struct wined3d_swapchain_desc *desc, struct wined3d_swapchain **swapchain)
5490 struct ddraw *ddraw = ddraw_from_device_parent(device_parent);
5493 TRACE("device_parent %p, desc %p, swapchain %p.\n", device_parent, desc, swapchain);
5495 if (ddraw->wined3d_swapchain)
5497 ERR("Swapchain already created.\n");
5501 hr = wined3d_swapchain_create(ddraw->wined3d_device, desc,
5502 DefaultSurfaceType, NULL, &ddraw_null_wined3d_parent_ops, swapchain);
5504 WARN("Failed to create swapchain, hr %#x.\n", hr);
5509 static const struct wined3d_device_parent_ops ddraw_wined3d_device_parent_ops =
5511 device_parent_wined3d_device_created,
5512 device_parent_mode_changed,
5513 device_parent_create_surface,
5514 device_parent_create_rendertarget,
5515 device_parent_create_depth_stencil,
5516 device_parent_create_volume,
5517 device_parent_create_swapchain,
5520 HRESULT ddraw_init(struct ddraw *ddraw, enum wined3d_device_type device_type)
5525 ddraw->IDirectDraw7_iface.lpVtbl = &ddraw7_vtbl;
5526 ddraw->IDirectDraw_iface.lpVtbl = &ddraw1_vtbl;
5527 ddraw->IDirectDraw2_iface.lpVtbl = &ddraw2_vtbl;
5528 ddraw->IDirectDraw4_iface.lpVtbl = &ddraw4_vtbl;
5529 ddraw->IDirect3D_iface.lpVtbl = &d3d1_vtbl;
5530 ddraw->IDirect3D2_iface.lpVtbl = &d3d2_vtbl;
5531 ddraw->IDirect3D3_iface.lpVtbl = &d3d3_vtbl;
5532 ddraw->IDirect3D7_iface.lpVtbl = &d3d7_vtbl;
5533 ddraw->device_parent.ops = &ddraw_wined3d_device_parent_ops;
5534 ddraw->numIfaces = 1;
5537 /* Get the current screen settings. */
5539 ddraw->orig_bpp = GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES);
5541 ddraw->orig_width = GetSystemMetrics(SM_CXSCREEN);
5542 ddraw->orig_height = GetSystemMetrics(SM_CYSCREEN);
5544 ddraw->wined3d = wined3d_create(7, WINED3D_LEGACY_DEPTH_BIAS);
5545 if (!ddraw->wined3d)
5547 WARN("Failed to create a wined3d object.\n");
5548 return E_OUTOFMEMORY;
5551 hr = wined3d_device_create(ddraw->wined3d, WINED3DADAPTER_DEFAULT, device_type,
5552 NULL, 0, 8, &ddraw->device_parent, &ddraw->wined3d_device);
5555 WARN("Failed to create a wined3d device, hr %#x.\n", hr);
5556 wined3d_decref(ddraw->wined3d);
5560 list_init(&ddraw->surface_list);