1 /* DirectDraw Base Functions
3 * Copyright 1997-1999 Marcus Meissner
4 * Copyright 1998 Lionel Ulmer
5 * Copyright 2000-2001 TransGaming Technologies Inc.
6 * Copyright 2006 Stefan Dösinger
7 * Copyright 2008 Denver Gingerich
9 * This file contains the (internal) driver registration functions,
10 * driver enumeration APIs and DirectDraw creation functions.
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 #include "wine/port.h"
29 #include "wine/debug.h"
42 #include "wine/exception.h"
48 #define DDRAW_INIT_GUID
49 #include "ddraw_private.h"
51 static typeof(WineDirect3DCreate
) *pWineDirect3DCreate
;
53 WINE_DEFAULT_DEBUG_CHANNEL(ddraw
);
55 /* The configured default surface */
56 WINED3DSURFTYPE DefaultSurfaceType
= SURFACE_UNKNOWN
;
58 /* DDraw list and critical section */
59 static struct list global_ddraw_list
= LIST_INIT(global_ddraw_list
);
61 static CRITICAL_SECTION_DEBUG ddraw_cs_debug
=
64 { &ddraw_cs_debug
.ProcessLocksList
,
65 &ddraw_cs_debug
.ProcessLocksList
},
66 0, 0, { (DWORD_PTR
)(__FILE__
": ddraw_cs") }
68 CRITICAL_SECTION ddraw_cs
= { &ddraw_cs_debug
, -1, 0, 0, 0, 0 };
70 /* value of ForceRefreshRate */
71 DWORD force_refresh_rate
= 0;
73 /* Handle table functions */
74 BOOL
ddraw_handle_table_init(struct ddraw_handle_table
*t
, UINT initial_size
)
76 t
->entries
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, initial_size
* sizeof(*t
->entries
));
79 ERR("Failed to allocate handle table memory.\n");
82 t
->free_entries
= NULL
;
83 t
->table_size
= initial_size
;
89 void ddraw_handle_table_destroy(struct ddraw_handle_table
*t
)
91 HeapFree(GetProcessHeap(), 0, t
->entries
);
92 memset(t
, 0, sizeof(*t
));
95 DWORD
ddraw_allocate_handle(struct ddraw_handle_table
*t
, void *object
, enum ddraw_handle_type type
)
97 struct ddraw_handle_entry
*entry
;
101 DWORD idx
= t
->free_entries
- t
->entries
;
102 /* Use a free handle */
103 entry
= t
->free_entries
;
104 if (entry
->type
!= DDRAW_HANDLE_FREE
)
106 ERR("Handle %#x (%p) is in the free list, but has type %#x.\n", idx
, entry
->object
, entry
->type
);
107 return DDRAW_INVALID_HANDLE
;
109 t
->free_entries
= entry
->object
;
110 entry
->object
= object
;
116 if (!(t
->entry_count
< t
->table_size
))
119 UINT new_size
= t
->table_size
+ (t
->table_size
>> 1);
120 struct ddraw_handle_entry
*new_entries
= HeapReAlloc(GetProcessHeap(),
121 0, t
->entries
, new_size
* sizeof(*t
->entries
));
124 ERR("Failed to grow the handle table.\n");
125 return DDRAW_INVALID_HANDLE
;
127 t
->entries
= new_entries
;
128 t
->table_size
= new_size
;
131 entry
= &t
->entries
[t
->entry_count
];
132 entry
->object
= object
;
135 return t
->entry_count
++;
138 void *ddraw_free_handle(struct ddraw_handle_table
*t
, DWORD handle
, enum ddraw_handle_type type
)
140 struct ddraw_handle_entry
*entry
;
143 if (handle
== DDRAW_INVALID_HANDLE
|| handle
>= t
->entry_count
)
145 WARN("Invalid handle %#x passed.\n", handle
);
149 entry
= &t
->entries
[handle
];
150 if (entry
->type
!= type
)
152 WARN("Handle %#x (%p) is not of type %#x.\n", handle
, entry
->object
, type
);
156 object
= entry
->object
;
157 entry
->object
= t
->free_entries
;
158 entry
->type
= DDRAW_HANDLE_FREE
;
159 t
->free_entries
= entry
;
164 void *ddraw_get_object(struct ddraw_handle_table
*t
, DWORD handle
, enum ddraw_handle_type type
)
166 struct ddraw_handle_entry
*entry
;
168 if (handle
== DDRAW_INVALID_HANDLE
|| handle
>= t
->entry_count
)
170 WARN("Invalid handle %#x passed.\n", handle
);
174 entry
= &t
->entries
[handle
];
175 if (entry
->type
!= type
)
177 WARN("Handle %#x (%p) is not of type %#x.\n", handle
, entry
->object
, type
);
181 return entry
->object
;
185 * Helper Function for DDRAW_Create and DirectDrawCreateClipper for
186 * lazy loading of the Wine D3D driver.
193 BOOL
LoadWineD3D(void)
195 static HMODULE hWineD3D
= (HMODULE
) -1;
196 if (hWineD3D
== (HMODULE
) -1)
198 hWineD3D
= LoadLibraryA("wined3d");
201 pWineDirect3DCreate
= (typeof(WineDirect3DCreate
) *)GetProcAddress(hWineD3D
, "WineDirect3DCreate");
202 pWineDirect3DCreateClipper
= (typeof(WineDirect3DCreateClipper
) *) GetProcAddress(hWineD3D
, "WineDirect3DCreateClipper");
206 return hWineD3D
!= NULL
;
209 /***********************************************************************
211 * Helper function for DirectDrawCreate and friends
212 * Creates a new DDraw interface with the given REFIID
214 * Interfaces that can be created:
215 * IDirectDraw, IDirectDraw2, IDirectDraw4, IDirectDraw7
216 * IDirect3D, IDirect3D2, IDirect3D3, IDirect3D7. (Does Windows return
217 * IDirect3D interfaces?)
220 * guid: ID of the requested driver, NULL for the default driver.
221 * The GUID can be queried with DirectDrawEnumerate(Ex)A/W
222 * DD: Used to return the pointer to the created object
223 * UnkOuter: For aggregation, which is unsupported. Must be NULL
224 * iid: requested version ID.
227 * DD_OK if the Interface was created successfully
228 * CLASS_E_NOAGGREGATION if UnkOuter is not NULL
229 * E_OUTOFMEMORY if some allocation failed
231 ***********************************************************************/
233 DDRAW_Create(const GUID
*guid
,
238 IDirectDrawImpl
*This
= NULL
;
240 IWineD3D
*wineD3D
= NULL
;
241 IWineD3DDevice
*wineD3DDevice
= NULL
;
243 WINED3DDEVTYPE devicetype
;
245 TRACE("(%s,%p,%p)\n", debugstr_guid(guid
), DD
, UnkOuter
);
249 /* We don't care about this guids. Well, there's no special guid anyway
252 if (guid
== (GUID
*) DDCREATE_EMULATIONONLY
)
254 /* Use the reference device id. This doesn't actually change anything,
255 * WineD3D always uses OpenGL for D3D rendering. One could make it request
258 devicetype
= WINED3DDEVTYPE_REF
;
260 else if(guid
== (GUID
*) DDCREATE_HARDWAREONLY
)
262 devicetype
= WINED3DDEVTYPE_HAL
;
269 /* DDraw doesn't support aggregation, according to msdn */
270 if (UnkOuter
!= NULL
)
271 return CLASS_E_NOAGGREGATION
;
273 /* DirectDraw creation comes here */
274 This
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(IDirectDrawImpl
));
277 ERR("Out of memory when creating DirectDraw\n");
278 return E_OUTOFMEMORY
;
282 * IDirectDraw and IDirect3D are the same object,
283 * QueryInterface is used to get other interfaces.
285 This
->lpVtbl
= &IDirectDraw7_Vtbl
;
286 This
->IDirectDraw_vtbl
= &IDirectDraw1_Vtbl
;
287 This
->IDirectDraw2_vtbl
= &IDirectDraw2_Vtbl
;
288 This
->IDirectDraw3_vtbl
= &IDirectDraw3_Vtbl
;
289 This
->IDirectDraw4_vtbl
= &IDirectDraw4_Vtbl
;
290 This
->IDirect3D_vtbl
= &IDirect3D1_Vtbl
;
291 This
->IDirect3D2_vtbl
= &IDirect3D2_Vtbl
;
292 This
->IDirect3D3_vtbl
= &IDirect3D3_Vtbl
;
293 This
->IDirect3D7_vtbl
= &IDirect3D7_Vtbl
;
294 This
->device_parent_vtbl
= &ddraw_wined3d_device_parent_vtbl
;
296 /* See comments in IDirectDrawImpl_CreateNewSurface for a description
298 * Read from a registry key, should add a winecfg option later
300 This
->ImplType
= DefaultSurfaceType
;
302 /* Get the current screen settings */
304 This
->orig_bpp
= GetDeviceCaps(hDC
, BITSPIXEL
) * GetDeviceCaps(hDC
, PLANES
);
306 This
->orig_width
= GetSystemMetrics(SM_CXSCREEN
);
307 This
->orig_height
= GetSystemMetrics(SM_CYSCREEN
);
311 ERR("Couldn't load WineD3D - OpenGL libs not present?\n");
312 hr
= DDERR_NODIRECTDRAWSUPPORT
;
316 /* Initialize WineD3D
318 * All Rendering (2D and 3D) is relayed to WineD3D,
319 * but DirectDraw specific management, like DDSURFACEDESC and DDPIXELFORMAT
320 * structure handling is handled in this lib.
322 wineD3D
= pWineDirect3DCreate(7 /* DXVersion */, (IUnknown
*) This
/* Parent */);
325 ERR("Failed to initialise WineD3D\n");
329 This
->wineD3D
= wineD3D
;
330 TRACE("WineD3D created at %p\n", wineD3D
);
332 /* Initialized member...
334 * It is set to false at creation time, and set to true in
335 * IDirectDraw7::Initialize. Its sole purpose is to return DD_OK on
336 * initialize only once
338 This
->initialized
= FALSE
;
340 /* Initialize WineD3DDevice
342 * It is used for screen setup, surface and palette creation
343 * When a Direct3DDevice7 is created, the D3D capabilities of WineD3D are
346 hr
= IWineD3D_CreateDevice(wineD3D
, 0 /* D3D_ADAPTER_DEFAULT */, devicetype
, NULL
/* FocusWindow, don't know yet */,
347 0 /* BehaviorFlags */, (IUnknown
*)This
, (IWineD3DDeviceParent
*)&This
->device_parent_vtbl
, &wineD3DDevice
);
350 ERR("Failed to create a wineD3DDevice, result = %x\n", hr
);
353 This
->wineD3DDevice
= wineD3DDevice
;
354 TRACE("wineD3DDevice created at %p\n", This
->wineD3DDevice
);
356 /* Get the amount of video memory */
357 This
->total_vidmem
= IWineD3DDevice_GetAvailableTextureMem(This
->wineD3DDevice
);
359 list_init(&This
->surface_list
);
360 list_add_head(&global_ddraw_list
, &This
->ddraw_list_entry
);
362 /* Call QueryInterface to get the pointer to the requested interface. This also initializes
363 * The required refcount
365 hr
= IDirectDraw7_QueryInterface((IDirectDraw7
*)This
, iid
, DD
);
366 if(SUCCEEDED(hr
)) return DD_OK
;
369 /* Let's hope we never need this ;) */
370 if(wineD3DDevice
) IWineD3DDevice_Release(wineD3DDevice
);
371 if(wineD3D
) IWineD3D_Release(wineD3D
);
372 HeapFree(GetProcessHeap(), 0, This
->decls
);
373 HeapFree(GetProcessHeap(), 0, This
);
377 /***********************************************************************
378 * DirectDrawCreate (DDRAW.@)
380 * Creates legacy DirectDraw Interfaces. Can't create IDirectDraw7
381 * interfaces in theory
383 * Arguments, return values: See DDRAW_Create
385 ***********************************************************************/
386 HRESULT WINAPI DECLSPEC_HOTPATCH
387 DirectDrawCreate(GUID
*GUID
,
392 TRACE("(%s,%p,%p)\n", debugstr_guid(GUID
), DD
, UnkOuter
);
394 EnterCriticalSection(&ddraw_cs
);
395 hr
= DDRAW_Create(GUID
, (void **) DD
, UnkOuter
, &IID_IDirectDraw
);
396 LeaveCriticalSection(&ddraw_cs
);
400 /***********************************************************************
401 * DirectDrawCreateEx (DDRAW.@)
403 * Only creates new IDirectDraw7 interfaces, supposed to fail if legacy
404 * interfaces are requested.
406 * Arguments, return values: See DDRAW_Create
408 ***********************************************************************/
409 HRESULT WINAPI DECLSPEC_HOTPATCH
410 DirectDrawCreateEx(GUID
*GUID
,
416 TRACE("(%s,%p,%s,%p)\n", debugstr_guid(GUID
), DD
, debugstr_guid(iid
), UnkOuter
);
418 if (!IsEqualGUID(iid
, &IID_IDirectDraw7
))
419 return DDERR_INVALIDPARAMS
;
421 EnterCriticalSection(&ddraw_cs
);
422 hr
= DDRAW_Create(GUID
, DD
, UnkOuter
, iid
);
423 LeaveCriticalSection(&ddraw_cs
);
427 /***********************************************************************
428 * DirectDrawEnumerateA (DDRAW.@)
430 * Enumerates legacy ddraw drivers, ascii version. We only have one
431 * driver, which relays to WineD3D. If we were sufficiently cool,
432 * we could offer various interfaces, which use a different default surface
433 * implementation, but I think it's better to offer this choice in
434 * winecfg, because some apps use the default driver, so we would need
435 * a winecfg option anyway, and there shouldn't be 2 ways to set one setting
438 * Callback: Callback function from the app
439 * Context: Argument to the call back.
443 * E_INVALIDARG if the Callback caused a page fault
446 ***********************************************************************/
448 DirectDrawEnumerateA(LPDDENUMCALLBACKA Callback
,
451 TRACE("(%p, %p)\n", Callback
, Context
);
453 TRACE(" Enumerating default DirectDraw HAL interface\n");
454 /* We only have one driver */
457 static CHAR driver_desc
[] = "DirectDraw HAL",
458 driver_name
[] = "display";
460 Callback(NULL
, driver_desc
, driver_name
, Context
);
464 return DDERR_INVALIDPARAMS
;
468 TRACE(" End of enumeration\n");
472 /***********************************************************************
473 * DirectDrawEnumerateExA (DDRAW.@)
475 * Enumerates DirectDraw7 drivers, ascii version. See
476 * the comments above DirectDrawEnumerateA for more details.
478 * The Flag member is not supported right now.
480 ***********************************************************************/
482 DirectDrawEnumerateExA(LPDDENUMCALLBACKEXA Callback
,
486 TRACE("(%p, %p, 0x%08x)\n", Callback
, Context
, Flags
);
488 if (Flags
& ~(DDENUM_ATTACHEDSECONDARYDEVICES
|
489 DDENUM_DETACHEDSECONDARYDEVICES
|
490 DDENUM_NONDISPLAYDEVICES
))
491 return DDERR_INVALIDPARAMS
;
494 FIXME("flags 0x%08x not handled\n", Flags
);
496 TRACE("Enumerating default DirectDraw HAL interface\n");
498 /* We only have one driver by now */
501 static CHAR driver_desc
[] = "DirectDraw HAL",
502 driver_name
[] = "display";
504 /* QuickTime expects the description "DirectDraw HAL" */
505 Callback(NULL
, driver_desc
, driver_name
, Context
, 0);
509 return DDERR_INVALIDPARAMS
;
513 TRACE("End of enumeration\n");
517 /***********************************************************************
518 * DirectDrawEnumerateW (DDRAW.@)
520 * Enumerates legacy drivers, unicode version.
521 * This function is not implemented on Windows.
523 ***********************************************************************/
525 DirectDrawEnumerateW(LPDDENUMCALLBACKW Callback
,
528 TRACE("(%p, %p)\n", Callback
, Context
);
531 return DDERR_INVALIDPARAMS
;
533 return DDERR_UNSUPPORTED
;
536 /***********************************************************************
537 * DirectDrawEnumerateExW (DDRAW.@)
539 * Enumerates DirectDraw7 drivers, unicode version.
540 * This function is not implemented on Windows.
542 ***********************************************************************/
544 DirectDrawEnumerateExW(LPDDENUMCALLBACKEXW Callback
,
548 TRACE("(%p, %p, 0x%x)\n", Callback
, Context
, Flags
);
550 return DDERR_UNSUPPORTED
;
553 /***********************************************************************
554 * Classfactory implementation.
555 ***********************************************************************/
557 /***********************************************************************
558 * CF_CreateDirectDraw
560 * DDraw creation function for the class factory
563 * UnkOuter: Set to NULL
564 * iid: ID of the wanted interface
565 * obj: Address to pass the interface pointer back
568 * DD_OK / DDERR*, see DDRAW_Create
570 ***********************************************************************/
572 CF_CreateDirectDraw(IUnknown
* UnkOuter
, REFIID iid
,
577 TRACE("(%p,%s,%p)\n", UnkOuter
, debugstr_guid(iid
), obj
);
579 EnterCriticalSection(&ddraw_cs
);
580 hr
= DDRAW_Create(NULL
, obj
, UnkOuter
, iid
);
581 LeaveCriticalSection(&ddraw_cs
);
585 /***********************************************************************
586 * CF_CreateDirectDraw
588 * Clipper creation function for the class factory
591 * UnkOuter: Set to NULL
592 * iid: ID of the wanted interface
593 * obj: Address to pass the interface pointer back
596 * DD_OK / DDERR*, see DDRAW_Create
598 ***********************************************************************/
600 CF_CreateDirectDrawClipper(IUnknown
* UnkOuter
, REFIID riid
,
604 IDirectDrawClipper
*Clip
;
606 EnterCriticalSection(&ddraw_cs
);
607 hr
= DirectDrawCreateClipper(0, &Clip
, UnkOuter
);
610 LeaveCriticalSection(&ddraw_cs
);
614 hr
= IDirectDrawClipper_QueryInterface(Clip
, riid
, obj
);
615 IDirectDrawClipper_Release(Clip
);
617 LeaveCriticalSection(&ddraw_cs
);
621 static const struct object_creation_info object_creation
[] =
623 { &CLSID_DirectDraw
, CF_CreateDirectDraw
},
624 { &CLSID_DirectDraw7
, CF_CreateDirectDraw
},
625 { &CLSID_DirectDrawClipper
, CF_CreateDirectDrawClipper
}
628 /*******************************************************************************
629 * IDirectDrawClassFactory::QueryInterface
631 * QueryInterface for the class factory
634 * riid Reference to identifier of queried interface
635 * ppv Address to return the interface pointer at
639 * Failure: E_NOINTERFACE
641 *******************************************************************************/
642 static HRESULT WINAPI
643 IDirectDrawClassFactoryImpl_QueryInterface(IClassFactory
*iface
,
647 IClassFactoryImpl
*This
= (IClassFactoryImpl
*)iface
;
649 TRACE("(%p)->(%s,%p)\n", This
, debugstr_guid(riid
), obj
);
651 if (IsEqualGUID(riid
, &IID_IUnknown
)
652 || IsEqualGUID(riid
, &IID_IClassFactory
))
654 IClassFactory_AddRef(iface
);
659 WARN("(%p)->(%s,%p),not found\n",This
,debugstr_guid(riid
),obj
);
660 return E_NOINTERFACE
;
663 /*******************************************************************************
664 * IDirectDrawClassFactory::AddRef
666 * AddRef for the class factory
671 *******************************************************************************/
673 IDirectDrawClassFactoryImpl_AddRef(IClassFactory
*iface
)
675 IClassFactoryImpl
*This
= (IClassFactoryImpl
*)iface
;
676 ULONG ref
= InterlockedIncrement(&This
->ref
);
678 TRACE("(%p)->() incrementing from %d.\n", This
, ref
- 1);
683 /*******************************************************************************
684 * IDirectDrawClassFactory::Release
686 * Release for the class factory. If the refcount falls to 0, the object
692 *******************************************************************************/
694 IDirectDrawClassFactoryImpl_Release(IClassFactory
*iface
)
696 IClassFactoryImpl
*This
= (IClassFactoryImpl
*)iface
;
697 ULONG ref
= InterlockedDecrement(&This
->ref
);
698 TRACE("(%p)->() decrementing from %d.\n", This
, ref
+1);
701 HeapFree(GetProcessHeap(), 0, This
);
707 /*******************************************************************************
708 * IDirectDrawClassFactory::CreateInstance
710 * What is this? Seems to create DirectDraw objects...
713 * The usual things???
718 *******************************************************************************/
719 static HRESULT WINAPI
720 IDirectDrawClassFactoryImpl_CreateInstance(IClassFactory
*iface
,
725 IClassFactoryImpl
*This
= (IClassFactoryImpl
*)iface
;
727 TRACE("(%p)->(%p,%s,%p)\n",This
,UnkOuter
,debugstr_guid(riid
),obj
);
729 return This
->pfnCreateInstance(UnkOuter
, riid
, obj
);
732 /*******************************************************************************
733 * IDirectDrawClassFactory::LockServer
741 * S_OK, because it's a stub
743 *******************************************************************************/
744 static HRESULT WINAPI
745 IDirectDrawClassFactoryImpl_LockServer(IClassFactory
*iface
,BOOL dolock
)
747 IClassFactoryImpl
*This
= (IClassFactoryImpl
*)iface
;
748 FIXME("(%p)->(%d),stub!\n",This
,dolock
);
752 /*******************************************************************************
753 * The class factory VTable
754 *******************************************************************************/
755 static const IClassFactoryVtbl IClassFactory_Vtbl
=
757 IDirectDrawClassFactoryImpl_QueryInterface
,
758 IDirectDrawClassFactoryImpl_AddRef
,
759 IDirectDrawClassFactoryImpl_Release
,
760 IDirectDrawClassFactoryImpl_CreateInstance
,
761 IDirectDrawClassFactoryImpl_LockServer
764 /*******************************************************************************
765 * DllGetClassObject [DDRAW.@]
766 * Retrieves class object from a DLL object
769 * Docs say returns STDAPI
772 * rclsid [I] CLSID for the class object
773 * riid [I] Reference to identifier of interface for class object
774 * ppv [O] Address of variable to receive interface pointer for riid
778 * Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
781 HRESULT WINAPI
DllGetClassObject(REFCLSID rclsid
, REFIID riid
, LPVOID
*ppv
)
784 IClassFactoryImpl
*factory
;
786 TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid
), debugstr_guid(riid
), ppv
);
788 if ( !IsEqualGUID( &IID_IClassFactory
, riid
)
789 && ! IsEqualGUID( &IID_IUnknown
, riid
) )
790 return E_NOINTERFACE
;
792 for (i
=0; i
< sizeof(object_creation
)/sizeof(object_creation
[0]); i
++)
794 if (IsEqualGUID(object_creation
[i
].clsid
, rclsid
))
798 if (i
== sizeof(object_creation
)/sizeof(object_creation
[0]))
800 FIXME("%s: no class found.\n", debugstr_guid(rclsid
));
801 return CLASS_E_CLASSNOTAVAILABLE
;
804 factory
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*factory
));
805 if (factory
== NULL
) return E_OUTOFMEMORY
;
807 factory
->lpVtbl
= &IClassFactory_Vtbl
;
810 factory
->pfnCreateInstance
= object_creation
[i
].pfnCreateInstance
;
817 /*******************************************************************************
818 * DllCanUnloadNow [DDRAW.@] Determines whether the DLL is in use.
824 HRESULT WINAPI
DllCanUnloadNow(void)
829 /*******************************************************************************
832 * Callback function for the EnumSurfaces call in DllMain.
833 * Dumps some surface info and releases the surface
836 * surf: The enumerated surface
837 * desc: it's description
838 * context: Pointer to the ddraw impl
842 *******************************************************************************/
843 static HRESULT WINAPI
844 DestroyCallback(IDirectDrawSurface7
*surf
,
845 DDSURFACEDESC2
*desc
,
848 IDirectDrawSurfaceImpl
*Impl
= (IDirectDrawSurfaceImpl
*)surf
;
851 ref
= IDirectDrawSurface7_Release(surf
); /* For the EnumSurfaces */
852 WARN("Surface %p has an reference count of %d\n", Impl
, ref
);
854 /* Skip surfaces which are attached somewhere or which are
855 * part of a complex compound. They will get released when destroying
858 if( (!Impl
->is_complex_root
) || (Impl
->first_attached
!= Impl
) )
861 /* Destroy the surface */
862 while(ref
) ref
= IDirectDrawSurface7_Release(surf
);
867 /***********************************************************************
870 * Reads a config key from the registry. Taken from WineD3D
872 ***********************************************************************/
873 static inline DWORD
get_config_key(HKEY defkey
, HKEY appkey
, const char* name
, char* buffer
, DWORD size
)
875 if (0 != appkey
&& !RegQueryValueExA( appkey
, name
, 0, NULL
, (LPBYTE
) buffer
, &size
)) return 0;
876 if (0 != defkey
&& !RegQueryValueExA( defkey
, name
, 0, NULL
, (LPBYTE
) buffer
, &size
)) return 0;
877 return ERROR_FILE_NOT_FOUND
;
880 /***********************************************************************
883 * Could be used to register DirectDraw drivers, if we have more than
884 * one. Also used to destroy any objects left at unload if the
885 * app didn't release them properly(Gothic 2, Diablo 2, Moto racer, ...)
887 ***********************************************************************/
889 DllMain(HINSTANCE hInstDLL
,
893 TRACE("(%p,%x,%p)\n", hInstDLL
, Reason
, lpv
);
894 if (Reason
== DLL_PROCESS_ATTACH
)
896 char buffer
[MAX_PATH
+10];
897 DWORD size
= sizeof(buffer
);
903 /* Register the window class. This is used to create a hidden window
904 * for D3D rendering, if the application didn't pass one. It can also
905 * be used for creating a device window from SetCooperativeLevel(). */
906 wc
.style
= CS_HREDRAW
| CS_VREDRAW
;
907 wc
.lpfnWndProc
= DefWindowProcA
;
910 wc
.hInstance
= hInstDLL
;
913 wc
.hbrBackground
= GetStockObject(BLACK_BRUSH
);
914 wc
.lpszMenuName
= NULL
;
915 wc
.lpszClassName
= DDRAW_WINDOW_CLASS_NAME
;
916 if (!RegisterClassA(&wc
))
918 ERR("Failed to register ddraw window class, last error %#x.\n", GetLastError());
922 /* @@ Wine registry key: HKCU\Software\Wine\Direct3D */
923 if ( RegOpenKeyA( HKEY_CURRENT_USER
, "Software\\Wine\\Direct3D", &hkey
) ) hkey
= 0;
925 len
= GetModuleFileNameA( 0, buffer
, MAX_PATH
);
926 if (len
&& len
< MAX_PATH
)
929 /* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe\Direct3D */
930 if (!RegOpenKeyA( HKEY_CURRENT_USER
, "Software\\Wine\\AppDefaults", &tmpkey
))
932 char *p
, *appname
= buffer
;
933 if ((p
= strrchr( appname
, '/' ))) appname
= p
+ 1;
934 if ((p
= strrchr( appname
, '\\' ))) appname
= p
+ 1;
935 strcat( appname
, "\\Direct3D" );
936 TRACE("appname = [%s]\n", appname
);
937 if (RegOpenKeyA( tmpkey
, appname
, &appkey
)) appkey
= 0;
938 RegCloseKey( tmpkey
);
942 if ( 0 != hkey
|| 0 != appkey
)
944 if ( !get_config_key( hkey
, appkey
, "DirectDrawRenderer", buffer
, size
) )
946 if (!strcmp(buffer
,"gdi"))
948 TRACE("Defaulting to GDI surfaces\n");
949 DefaultSurfaceType
= SURFACE_GDI
;
951 else if (!strcmp(buffer
,"opengl"))
953 TRACE("Defaulting to opengl surfaces\n");
954 DefaultSurfaceType
= SURFACE_OPENGL
;
958 ERR("Unknown default surface type. Supported are:\n gdi, opengl\n");
963 /* On Windows one can force the refresh rate that DirectDraw uses by
964 * setting an override value in dxdiag. This is documented in KB315614
965 * (main article), KB230002, and KB217348. By comparing registry dumps
966 * before and after setting the override, we see that the override value
967 * is stored in HKLM\Software\Microsoft\DirectDraw\ForceRefreshRate as a
968 * DWORD that represents the refresh rate to force. We use this
969 * registry entry to modify the behavior of SetDisplayMode so that Wine
970 * users can override the refresh rate in a Windows-compatible way.
972 * dxdiag will not accept a refresh rate lower than 40 or higher than
973 * 120 so this value should be within that range. It is, of course,
974 * possible for a user to set the registry entry value directly so that
975 * assumption might not hold.
977 * There is no current mechanism for setting this value through the Wine
978 * GUI. It would be most appropriate to set this value through a dxdiag
979 * clone, but it may be sufficient to use winecfg.
981 * TODO: Create a mechanism for setting this value through the Wine GUI.
983 if ( !RegOpenKeyA( HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\DirectDraw", &hkey
) )
987 if (!RegQueryValueExA( hkey
, "ForceRefreshRate", NULL
, &type
, (LPBYTE
)&data
, &size
) && type
== REG_DWORD
)
989 TRACE("ForceRefreshRate set; overriding refresh rate to %d Hz\n", data
);
990 force_refresh_rate
= data
;
995 DisableThreadLibraryCalls(hInstDLL
);
997 else if (Reason
== DLL_PROCESS_DETACH
)
999 if(!list_empty(&global_ddraw_list
))
1001 struct list
*entry
, *entry2
;
1002 WARN("There are still existing DirectDraw interfaces. Wine bug or buggy application?\n");
1004 /* We remove elements from this loop */
1005 LIST_FOR_EACH_SAFE(entry
, entry2
, &global_ddraw_list
)
1008 DDSURFACEDESC2 desc
;
1010 IDirectDrawImpl
*ddraw
= LIST_ENTRY(entry
, IDirectDrawImpl
, ddraw_list_entry
);
1012 WARN("DDraw %p has a refcount of %d\n", ddraw
, ddraw
->ref7
+ ddraw
->ref4
+ ddraw
->ref3
+ ddraw
->ref2
+ ddraw
->ref1
);
1014 /* Add references to each interface to avoid freeing them unexpectedly */
1015 IDirectDraw_AddRef((IDirectDraw
*)&ddraw
->IDirectDraw_vtbl
);
1016 IDirectDraw2_AddRef((IDirectDraw2
*)&ddraw
->IDirectDraw2_vtbl
);
1017 IDirectDraw3_AddRef((IDirectDraw3
*)&ddraw
->IDirectDraw3_vtbl
);
1018 IDirectDraw4_AddRef((IDirectDraw4
*)&ddraw
->IDirectDraw4_vtbl
);
1019 IDirectDraw7_AddRef((IDirectDraw7
*)ddraw
);
1021 /* Does a D3D device exist? Destroy it
1022 * TODO: Destroy all Vertex buffers, Lights, Materials
1023 * and execute buffers too
1025 if(ddraw
->d3ddevice
)
1027 WARN("DDraw %p has d3ddevice %p attached\n", ddraw
, ddraw
->d3ddevice
);
1028 while(IDirect3DDevice7_Release((IDirect3DDevice7
*)ddraw
->d3ddevice
));
1031 /* Try to release the objects
1032 * Do an EnumSurfaces to find any hanging surfaces
1034 memset(&desc
, 0, sizeof(desc
));
1035 desc
.dwSize
= sizeof(desc
);
1036 for(i
= 0; i
<= 1; i
++)
1038 hr
= IDirectDraw7_EnumSurfaces((IDirectDraw7
*)ddraw
,
1039 DDENUMSURFACES_ALL
, &desc
, ddraw
, DestroyCallback
);
1041 ERR("(%p) EnumSurfaces failed, prepare for trouble\n", ddraw
);
1044 /* Check the surface count */
1045 if(ddraw
->surfaces
> 0)
1046 ERR("DDraw %p still has %d surfaces attached\n", ddraw
, ddraw
->surfaces
);
1048 /* Release all hanging references to destroy the objects. This
1049 * restores the screen mode too
1051 while(IDirectDraw_Release((IDirectDraw
*)&ddraw
->IDirectDraw_vtbl
));
1052 while(IDirectDraw2_Release((IDirectDraw2
*)&ddraw
->IDirectDraw2_vtbl
));
1053 while(IDirectDraw3_Release((IDirectDraw3
*)&ddraw
->IDirectDraw3_vtbl
));
1054 while(IDirectDraw4_Release((IDirectDraw4
*)&ddraw
->IDirectDraw4_vtbl
));
1055 while(IDirectDraw7_Release((IDirectDraw7
*)ddraw
));
1059 /* Unregister the window class. */
1060 UnregisterClassA(DDRAW_WINDOW_CLASS_NAME
, hInstDLL
);