secur32: Remove some unused variables.
[wine] / dlls / d3d9 / directx.c
1 /*
2  * IDirect3D9 implementation
3  *
4  * Copyright 2002 Jason Edmeades
5  * Copyright 2005 Oliver Stieber
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23 #include "d3d9_private.h"
24
25 WINE_DEFAULT_DEBUG_CHANNEL(d3d9);
26
27 static inline IDirect3D9Impl *impl_from_IDirect3D9Ex(IDirect3D9Ex *iface)
28 {
29     return CONTAINING_RECORD(iface, IDirect3D9Impl, IDirect3D9Ex_iface);
30 }
31
32 static HRESULT WINAPI IDirect3D9Impl_QueryInterface(IDirect3D9Ex *iface, REFIID riid, void **object)
33 {
34     IDirect3D9Impl *d3d9 = impl_from_IDirect3D9Ex(iface);
35
36     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
37
38     if (IsEqualGUID(riid, &IID_IDirect3D9)
39             || IsEqualGUID(riid, &IID_IUnknown))
40     {
41         IDirect3D9Ex_AddRef(&d3d9->IDirect3D9Ex_iface);
42         *object = &d3d9->IDirect3D9Ex_iface;
43         return S_OK;
44     }
45
46     if (IsEqualGUID(riid, &IID_IDirect3D9Ex))
47     {
48         if (!d3d9->extended)
49         {
50             WARN("Application asks for IDirect3D9Ex, but this instance wasn't created with Direct3DCreate9Ex.\n");
51             *object = NULL;
52             return E_NOINTERFACE;
53         }
54
55         IDirect3D9Ex_AddRef(&d3d9->IDirect3D9Ex_iface);
56         *object = &d3d9->IDirect3D9Ex_iface;
57         return S_OK;
58     }
59
60     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
61
62     *object = NULL;
63     return E_NOINTERFACE;
64 }
65
66 static ULONG WINAPI IDirect3D9Impl_AddRef(IDirect3D9Ex *iface)
67 {
68     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
69     ULONG ref = InterlockedIncrement(&This->ref);
70
71     TRACE("%p increasing refcount to %u.\n", iface, ref);
72
73     return ref;
74 }
75
76 static ULONG WINAPI IDirect3D9Impl_Release(IDirect3D9Ex *iface)
77 {
78     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
79     ULONG ref = InterlockedDecrement(&This->ref);
80
81     TRACE("%p decreasing refcount to %u.\n", iface, ref);
82
83     if (ref == 0) {
84         wined3d_mutex_lock();
85         wined3d_decref(This->WineD3D);
86         wined3d_mutex_unlock();
87
88         HeapFree(GetProcessHeap(), 0, This);
89     }
90
91     return ref;
92 }
93
94 /* IDirect3D9 Interface follow: */
95 static HRESULT  WINAPI  IDirect3D9Impl_RegisterSoftwareDevice(IDirect3D9Ex *iface,
96         void *pInitializeFunction)
97 {
98     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
99     HRESULT hr;
100
101     TRACE("iface %p, init_function %p.\n", iface, pInitializeFunction);
102
103     wined3d_mutex_lock();
104     hr = wined3d_register_software_device(This->WineD3D, pInitializeFunction);
105     wined3d_mutex_unlock();
106
107     return hr;
108 }
109
110 static UINT WINAPI IDirect3D9Impl_GetAdapterCount(IDirect3D9Ex *iface)
111 {
112     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
113     UINT ret;
114
115     TRACE("iface %p.\n", iface);
116
117     wined3d_mutex_lock();
118     ret = wined3d_get_adapter_count(This->WineD3D);
119     wined3d_mutex_unlock();
120
121     return ret;
122 }
123
124 static HRESULT WINAPI IDirect3D9Impl_GetAdapterIdentifier(IDirect3D9Ex *iface, UINT Adapter,
125         DWORD Flags, D3DADAPTER_IDENTIFIER9 *pIdentifier)
126 {
127     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
128     struct wined3d_adapter_identifier adapter_id;
129     HRESULT hr;
130
131     TRACE("iface %p, adapter %u, flags %#x, identifier %p.\n",
132             iface, Adapter, Flags, pIdentifier);
133
134     adapter_id.driver = pIdentifier->Driver;
135     adapter_id.driver_size = sizeof(pIdentifier->Driver);
136     adapter_id.description = pIdentifier->Description;
137     adapter_id.description_size = sizeof(pIdentifier->Description);
138     adapter_id.device_name = pIdentifier->DeviceName;
139     adapter_id.device_name_size = sizeof(pIdentifier->DeviceName);
140
141     wined3d_mutex_lock();
142     hr = wined3d_get_adapter_identifier(This->WineD3D, Adapter, Flags, &adapter_id);
143     wined3d_mutex_unlock();
144
145     pIdentifier->DriverVersion = adapter_id.driver_version;
146     pIdentifier->VendorId = adapter_id.vendor_id;
147     pIdentifier->DeviceId = adapter_id.device_id;
148     pIdentifier->SubSysId = adapter_id.subsystem_id;
149     pIdentifier->Revision = adapter_id.revision;
150     memcpy(&pIdentifier->DeviceIdentifier, &adapter_id.device_identifier, sizeof(pIdentifier->DeviceIdentifier));
151     pIdentifier->WHQLLevel = adapter_id.whql_level;
152
153     return hr;
154 }
155
156 static UINT WINAPI IDirect3D9Impl_GetAdapterModeCount(IDirect3D9Ex *iface, UINT Adapter,
157         D3DFORMAT Format)
158 {
159     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
160     UINT ret;
161
162     TRACE("iface %p, adapter %u, format %#x.\n", iface, Adapter, Format);
163
164     /* Others than that not supported by d3d9, but reported by wined3d for ddraw. Filter them out */
165     if(Format != D3DFMT_X8R8G8B8 && Format != D3DFMT_R5G6B5) {
166         return 0;
167     }
168
169     wined3d_mutex_lock();
170     ret = wined3d_get_adapter_mode_count(This->WineD3D, Adapter, wined3dformat_from_d3dformat(Format));
171     wined3d_mutex_unlock();
172
173     return ret;
174 }
175
176 static HRESULT WINAPI IDirect3D9Impl_EnumAdapterModes(IDirect3D9Ex *iface, UINT Adapter,
177         D3DFORMAT Format, UINT Mode, D3DDISPLAYMODE *pMode)
178 {
179     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
180     HRESULT hr;
181
182     TRACE("iface %p, adapter %u, format %#x, mode_idx %u, mode %p.\n",
183             iface, Adapter, Format, Mode, pMode);
184
185     /* We can't pass this to WineD3D, otherwise it'll think it came from D3D8 or DDraw.
186        It's supposed to fail anyway, so no harm returning failure. */
187     if(Format != D3DFMT_X8R8G8B8 && Format != D3DFMT_R5G6B5)
188         return D3DERR_INVALIDCALL;
189
190     wined3d_mutex_lock();
191     hr = wined3d_enum_adapter_modes(This->WineD3D, Adapter, wined3dformat_from_d3dformat(Format),
192             Mode, (struct wined3d_display_mode *)pMode);
193     wined3d_mutex_unlock();
194
195     if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
196
197     return hr;
198 }
199
200 static HRESULT WINAPI IDirect3D9Impl_GetAdapterDisplayMode(IDirect3D9Ex *iface, UINT Adapter,
201         D3DDISPLAYMODE *pMode)
202 {
203     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
204     HRESULT hr;
205
206     TRACE("iface %p, adapter %u, mode %p.\n", iface, Adapter, pMode);
207
208     wined3d_mutex_lock();
209     hr = wined3d_get_adapter_display_mode(This->WineD3D, Adapter, (struct wined3d_display_mode *)pMode);
210     wined3d_mutex_unlock();
211
212     if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
213
214     return hr;
215 }
216
217 static HRESULT WINAPI IDirect3D9Impl_CheckDeviceType(IDirect3D9Ex *iface, UINT Adapter,
218         D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL Windowed)
219 {
220     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
221     HRESULT hr;
222
223     TRACE("iface %p, adapter %u, device_type %#x, display_format %#x, backbuffer_format %#x, windowed %#x.\n",
224             iface, Adapter, CheckType, DisplayFormat, BackBufferFormat, Windowed);
225
226     wined3d_mutex_lock();
227     hr = wined3d_check_device_type(This->WineD3D, Adapter, CheckType, wined3dformat_from_d3dformat(DisplayFormat),
228             wined3dformat_from_d3dformat(BackBufferFormat), Windowed);
229     wined3d_mutex_unlock();
230
231     return hr;
232 }
233
234 static HRESULT WINAPI IDirect3D9Impl_CheckDeviceFormat(IDirect3D9Ex *iface, UINT Adapter,
235         D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType,
236         D3DFORMAT CheckFormat)
237 {
238     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
239     enum wined3d_resource_type wined3d_rtype;
240     HRESULT hr;
241
242     TRACE("iface %p, adapter %u, device_type %#x, adapter_format %#x, usage %#x, resource_type %#x, format %#x.\n",
243             iface, Adapter, DeviceType, AdapterFormat, Usage, RType, CheckFormat);
244
245     switch(RType) {
246         case D3DRTYPE_VERTEXBUFFER:
247         case D3DRTYPE_INDEXBUFFER:
248             wined3d_rtype = WINED3D_RTYPE_BUFFER;
249             break;
250
251         default:
252             wined3d_rtype = RType;
253             break;
254     }
255
256     wined3d_mutex_lock();
257     hr = wined3d_check_device_format(This->WineD3D, Adapter, DeviceType, wined3dformat_from_d3dformat(AdapterFormat),
258             Usage, wined3d_rtype, wined3dformat_from_d3dformat(CheckFormat), WINED3D_SURFACE_TYPE_OPENGL);
259     wined3d_mutex_unlock();
260
261     return hr;
262 }
263
264 static HRESULT WINAPI IDirect3D9Impl_CheckDeviceMultiSampleType(IDirect3D9Ex *iface, UINT Adapter,
265         D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed,
266         D3DMULTISAMPLE_TYPE MultiSampleType, DWORD *pQualityLevels)
267 {
268     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
269     HRESULT hr;
270
271     TRACE("iface %p, adapter %u, device_type %#x, format %#x, windowed %#x, multisample_type %#x, levels %p.\n",
272             iface, Adapter, DeviceType, SurfaceFormat, Windowed, MultiSampleType, pQualityLevels);
273
274     wined3d_mutex_lock();
275     hr = wined3d_check_device_multisample_type(This->WineD3D, Adapter, DeviceType,
276             wined3dformat_from_d3dformat(SurfaceFormat), Windowed, MultiSampleType, pQualityLevels);
277     wined3d_mutex_unlock();
278
279     return hr;
280 }
281
282 static HRESULT WINAPI IDirect3D9Impl_CheckDepthStencilMatch(IDirect3D9Ex *iface, UINT Adapter,
283         D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, D3DFORMAT RenderTargetFormat,
284         D3DFORMAT DepthStencilFormat)
285 {
286     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
287     HRESULT hr;
288
289     TRACE("iface %p, adapter %u, device_type %#x, adapter_format %#x, rt_format %#x, ds_format %#x.\n",
290             iface, Adapter, DeviceType, AdapterFormat, RenderTargetFormat, DepthStencilFormat);
291
292     wined3d_mutex_lock();
293     hr = wined3d_check_depth_stencil_match(This->WineD3D, Adapter, DeviceType,
294             wined3dformat_from_d3dformat(AdapterFormat), wined3dformat_from_d3dformat(RenderTargetFormat),
295             wined3dformat_from_d3dformat(DepthStencilFormat));
296     wined3d_mutex_unlock();
297
298     return hr;
299 }
300
301 static HRESULT WINAPI IDirect3D9Impl_CheckDeviceFormatConversion(IDirect3D9Ex *iface, UINT Adapter,
302         D3DDEVTYPE DeviceType, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat)
303 {
304     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
305     HRESULT hr;
306
307     TRACE("iface %p, adapter %u, device_type %#x, src_format %#x, dst_format %#x.\n",
308             iface, Adapter, DeviceType, SourceFormat, TargetFormat);
309
310     wined3d_mutex_lock();
311     hr = wined3d_check_device_format_conversion(This->WineD3D, Adapter, DeviceType,
312             wined3dformat_from_d3dformat(SourceFormat), wined3dformat_from_d3dformat(TargetFormat));
313     wined3d_mutex_unlock();
314
315     return hr;
316 }
317
318 void filter_caps(D3DCAPS9* pCaps)
319 {
320     DWORD ps_minor_version[] = {0, 4, 0, 0};
321     DWORD vs_minor_version[] = {0, 1, 0, 0};
322     DWORD textureFilterCaps =
323         D3DPTFILTERCAPS_MINFPOINT      | D3DPTFILTERCAPS_MINFLINEAR    | D3DPTFILTERCAPS_MINFANISOTROPIC |
324         D3DPTFILTERCAPS_MINFPYRAMIDALQUAD                              | D3DPTFILTERCAPS_MINFGAUSSIANQUAD|
325         D3DPTFILTERCAPS_MIPFPOINT      | D3DPTFILTERCAPS_MIPFLINEAR    | D3DPTFILTERCAPS_MAGFPOINT       |
326         D3DPTFILTERCAPS_MAGFLINEAR     |D3DPTFILTERCAPS_MAGFANISOTROPIC|D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD|
327         D3DPTFILTERCAPS_MAGFGAUSSIANQUAD;
328     pCaps->TextureFilterCaps &= textureFilterCaps;
329     pCaps->CubeTextureFilterCaps &= textureFilterCaps;
330     pCaps->VolumeTextureFilterCaps &= textureFilterCaps;
331
332     pCaps->DevCaps &=
333         D3DDEVCAPS_EXECUTESYSTEMMEMORY | D3DDEVCAPS_EXECUTEVIDEOMEMORY | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY |
334         D3DDEVCAPS_TLVERTEXVIDEOMEMORY | D3DDEVCAPS_TEXTURESYSTEMMEMORY| D3DDEVCAPS_TEXTUREVIDEOMEMORY   |
335         D3DDEVCAPS_DRAWPRIMTLVERTEX    | D3DDEVCAPS_CANRENDERAFTERFLIP | D3DDEVCAPS_TEXTURENONLOCALVIDMEM|
336         D3DDEVCAPS_DRAWPRIMITIVES2     | D3DDEVCAPS_SEPARATETEXTUREMEMORIES                              |
337         D3DDEVCAPS_DRAWPRIMITIVES2EX   | D3DDEVCAPS_HWTRANSFORMANDLIGHT| D3DDEVCAPS_CANBLTSYSTONONLOCAL  |
338         D3DDEVCAPS_HWRASTERIZATION     | D3DDEVCAPS_PUREDEVICE         | D3DDEVCAPS_QUINTICRTPATCHES     |
339         D3DDEVCAPS_RTPATCHES           | D3DDEVCAPS_RTPATCHHANDLEZERO  | D3DDEVCAPS_NPATCHES;
340
341     pCaps->ShadeCaps &=
342         D3DPSHADECAPS_COLORGOURAUDRGB  | D3DPSHADECAPS_SPECULARGOURAUDRGB |
343         D3DPSHADECAPS_ALPHAGOURAUDBLEND | D3DPSHADECAPS_FOGGOURAUD;
344
345     pCaps->RasterCaps &=
346         D3DPRASTERCAPS_DITHER          | D3DPRASTERCAPS_ZTEST          | D3DPRASTERCAPS_FOGVERTEX        |
347         D3DPRASTERCAPS_FOGTABLE        | D3DPRASTERCAPS_MIPMAPLODBIAS  | D3DPRASTERCAPS_ZBUFFERLESSHSR   |
348         D3DPRASTERCAPS_FOGRANGE        | D3DPRASTERCAPS_ANISOTROPY     | D3DPRASTERCAPS_WBUFFER          |
349         D3DPRASTERCAPS_WFOG            | D3DPRASTERCAPS_ZFOG           | D3DPRASTERCAPS_COLORPERSPECTIVE |
350         D3DPRASTERCAPS_SCISSORTEST     | D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS                              |
351         D3DPRASTERCAPS_DEPTHBIAS       | D3DPRASTERCAPS_MULTISAMPLE_TOGGLE;
352
353     pCaps->DevCaps2 &=
354         D3DDEVCAPS2_STREAMOFFSET       | D3DDEVCAPS2_DMAPNPATCH        | D3DDEVCAPS2_ADAPTIVETESSRTPATCH |
355         D3DDEVCAPS2_ADAPTIVETESSNPATCH | D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES                       |
356         D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH| D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
357
358     pCaps->Caps2 &=
359         D3DCAPS2_FULLSCREENGAMMA       | D3DCAPS2_CANCALIBRATEGAMMA    | D3DCAPS2_RESERVED               |
360         D3DCAPS2_CANMANAGERESOURCE     | D3DCAPS2_DYNAMICTEXTURES      | D3DCAPS2_CANAUTOGENMIPMAP;
361
362     pCaps->VertexProcessingCaps &=
363         D3DVTXPCAPS_TEXGEN             | D3DVTXPCAPS_MATERIALSOURCE7   | D3DVTXPCAPS_DIRECTIONALLIGHTS   |
364         D3DVTXPCAPS_POSITIONALLIGHTS   | D3DVTXPCAPS_LOCALVIEWER       | D3DVTXPCAPS_TWEENING            |
365         D3DVTXPCAPS_TEXGEN_SPHEREMAP   | D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER;
366
367     pCaps->TextureCaps &=
368         D3DPTEXTURECAPS_PERSPECTIVE    | D3DPTEXTURECAPS_POW2          | D3DPTEXTURECAPS_ALPHA           |
369         D3DPTEXTURECAPS_SQUAREONLY     | D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE                        |
370         D3DPTEXTURECAPS_ALPHAPALETTE   | D3DPTEXTURECAPS_NONPOW2CONDITIONAL                              |
371         D3DPTEXTURECAPS_PROJECTED      | D3DPTEXTURECAPS_CUBEMAP       | D3DPTEXTURECAPS_VOLUMEMAP       |
372         D3DPTEXTURECAPS_MIPMAP         | D3DPTEXTURECAPS_MIPVOLUMEMAP  | D3DPTEXTURECAPS_MIPCUBEMAP      |
373         D3DPTEXTURECAPS_CUBEMAP_POW2   | D3DPTEXTURECAPS_VOLUMEMAP_POW2| D3DPTEXTURECAPS_NOPROJECTEDBUMPENV;
374
375     pCaps->MaxVertexShaderConst = min(D3D9_MAX_VERTEX_SHADER_CONSTANTF, pCaps->MaxVertexShaderConst);
376     pCaps->NumSimultaneousRTs = min(D3D9_MAX_SIMULTANEOUS_RENDERTARGETS, pCaps->NumSimultaneousRTs);
377
378     if (pCaps->PixelShaderVersion > 3)
379         pCaps->PixelShaderVersion = D3DPS_VERSION(3,0);
380     else
381     {
382         DWORD major = pCaps->PixelShaderVersion;
383         pCaps->PixelShaderVersion = D3DPS_VERSION(major,ps_minor_version[major]);
384     }
385
386     if (pCaps->VertexShaderVersion > 3)
387         pCaps->VertexShaderVersion = D3DVS_VERSION(3,0);
388     else
389     {
390         DWORD major = pCaps->VertexShaderVersion;
391         pCaps->VertexShaderVersion = D3DVS_VERSION(major,vs_minor_version[major]);
392     }
393 }
394
395 static HRESULT WINAPI IDirect3D9Impl_GetDeviceCaps(IDirect3D9Ex *iface, UINT Adapter,
396         D3DDEVTYPE DeviceType, D3DCAPS9 *pCaps)
397 {
398     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
399     HRESULT hrc = D3D_OK;
400     WINED3DCAPS *pWineCaps;
401
402     TRACE("iface %p, adapter %u, device_type %#x, caps %p.\n", iface, Adapter, DeviceType, pCaps);
403
404     if(NULL == pCaps){
405         return D3DERR_INVALIDCALL;
406     }
407     pWineCaps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINED3DCAPS));
408     if(pWineCaps == NULL){
409         return D3DERR_INVALIDCALL; /*well this is what MSDN says to return*/
410     }
411     memset(pCaps, 0, sizeof(*pCaps));
412
413     wined3d_mutex_lock();
414     hrc = wined3d_get_device_caps(This->WineD3D, Adapter, DeviceType, pWineCaps);
415     wined3d_mutex_unlock();
416
417     WINECAPSTOD3D9CAPS(pCaps, pWineCaps)
418     HeapFree(GetProcessHeap(), 0, pWineCaps);
419
420     /* Some functionality is implemented in d3d9.dll, not wined3d.dll. Add the needed caps */
421     pCaps->DevCaps2 |= D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES;
422
423     filter_caps(pCaps);
424
425     TRACE("(%p) returning %p\n", This, pCaps);
426     return hrc;
427 }
428
429 static HMONITOR WINAPI IDirect3D9Impl_GetAdapterMonitor(IDirect3D9Ex *iface, UINT Adapter)
430 {
431     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
432     HMONITOR ret;
433
434     TRACE("iface %p, adapter %u.\n", iface, Adapter);
435
436     wined3d_mutex_lock();
437     ret = wined3d_get_adapter_monitor(This->WineD3D, Adapter);
438     wined3d_mutex_unlock();
439
440     return ret;
441 }
442
443 static HRESULT WINAPI DECLSPEC_HOTPATCH IDirect3D9Impl_CreateDevice(IDirect3D9Ex *iface, UINT adapter,
444         D3DDEVTYPE device_type, HWND focus_window, DWORD flags, D3DPRESENT_PARAMETERS *parameters,
445         IDirect3DDevice9 **device)
446 {
447     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
448     IDirect3DDevice9Impl *object;
449     HRESULT hr;
450
451     TRACE("iface %p, adapter %u, device_type %#x, focus_window %p, flags %#x, parameters %p, device %p.\n",
452             iface, adapter, device_type, focus_window, flags, parameters, device);
453
454     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
455     if (!object)
456     {
457         ERR("Failed to allocate device memory.\n");
458         return E_OUTOFMEMORY;
459     }
460
461     hr = device_init(object, This, This->WineD3D, adapter, device_type, focus_window, flags, parameters, NULL);
462     if (FAILED(hr))
463     {
464         WARN("Failed to initialize device, hr %#x.\n", hr);
465         HeapFree(GetProcessHeap(), 0, object);
466         return hr;
467     }
468
469     TRACE("Created device %p.\n", object);
470     *device = (IDirect3DDevice9 *)object;
471
472     return D3D_OK;
473 }
474
475 static UINT WINAPI IDirect3D9ExImpl_GetAdapterModeCountEx(IDirect3D9Ex *iface,
476         UINT adapter, const D3DDISPLAYMODEFILTER *filter)
477 {
478     FIXME("iface %p, adapter %u, filter %p stub!\n", iface, adapter, filter);
479
480     return 0;
481 }
482
483 static HRESULT WINAPI IDirect3D9ExImpl_EnumAdapterModesEx(IDirect3D9Ex *iface,
484         UINT adapter, const D3DDISPLAYMODEFILTER *filter, UINT mode_idx, D3DDISPLAYMODEEX *mode)
485 {
486     FIXME("iface %p, adapter %u, filter %p, mode_idx %u, mode %p stub!\n",
487             iface, adapter, filter, mode_idx, mode);
488
489     return E_NOTIMPL;
490 }
491
492 static HRESULT WINAPI IDirect3D9ExImpl_GetAdapterDisplayModeEx(IDirect3D9Ex *iface,
493         UINT adapter, D3DDISPLAYMODEEX *mode, D3DDISPLAYROTATION *rotation)
494 {
495     FIXME("iface %p, adapter %u, mode %p, rotation %p stub!\n",
496             iface, adapter, mode, rotation);
497
498     return E_NOTIMPL;
499 }
500
501 static HRESULT WINAPI DECLSPEC_HOTPATCH IDirect3D9ExImpl_CreateDeviceEx(IDirect3D9Ex *iface,
502         UINT adapter, D3DDEVTYPE device_type, HWND focus_window, DWORD flags,
503         D3DPRESENT_PARAMETERS *parameters, D3DDISPLAYMODEEX *mode, IDirect3DDevice9Ex **device)
504 {
505     IDirect3D9Impl *d3d9 = impl_from_IDirect3D9Ex(iface);
506     IDirect3DDevice9Impl *object;
507     HRESULT hr;
508
509     TRACE("iface %p, adapter %u, device_type %#x, focus_window %p, flags %#x, parameters %p, mode %p, device %p.\n",
510             iface, adapter, device_type, focus_window, flags, parameters, mode, device);
511
512     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
513     if (!object)
514     {
515         ERR("Failed to allocate device memory.\n");
516         return E_OUTOFMEMORY;
517     }
518
519     hr = device_init(object, d3d9, d3d9->WineD3D, adapter, device_type, focus_window, flags, parameters, mode);
520     if (FAILED(hr))
521     {
522         WARN("Failed to initialize device, hr %#x.\n", hr);
523         HeapFree(GetProcessHeap(), 0, object);
524         return hr;
525     }
526
527     TRACE("Created device %p.\n", object);
528     *device = &object->IDirect3DDevice9Ex_iface;
529
530     return D3D_OK;
531 }
532
533 static HRESULT WINAPI IDirect3D9ExImpl_GetAdapterLUID(IDirect3D9Ex *iface, UINT adapter, LUID *luid)
534 {
535     IDirect3D9Impl *This = impl_from_IDirect3D9Ex(iface);
536     struct wined3d_adapter_identifier adapter_id;
537     HRESULT hr;
538
539     TRACE("iface %p, adapter %u, luid %p.\n", iface, adapter, luid);
540
541     adapter_id.driver_size = 0;
542     adapter_id.description_size = 0;
543     adapter_id.device_name_size = 0;
544
545     wined3d_mutex_lock();
546     hr = wined3d_get_adapter_identifier(This->WineD3D, adapter, 0, &adapter_id);
547     wined3d_mutex_unlock();
548
549     memcpy(luid, &adapter_id.adapter_luid, sizeof(*luid));
550
551     return hr;
552 }
553
554
555 const IDirect3D9ExVtbl Direct3D9_Vtbl =
556 {
557     /* IUnknown */
558     IDirect3D9Impl_QueryInterface,
559     IDirect3D9Impl_AddRef,
560     IDirect3D9Impl_Release,
561     /* IDirect3D9 */
562     IDirect3D9Impl_RegisterSoftwareDevice,
563     IDirect3D9Impl_GetAdapterCount,
564     IDirect3D9Impl_GetAdapterIdentifier,
565     IDirect3D9Impl_GetAdapterModeCount,
566     IDirect3D9Impl_EnumAdapterModes,
567     IDirect3D9Impl_GetAdapterDisplayMode,
568     IDirect3D9Impl_CheckDeviceType,
569     IDirect3D9Impl_CheckDeviceFormat,
570     IDirect3D9Impl_CheckDeviceMultiSampleType,
571     IDirect3D9Impl_CheckDepthStencilMatch,
572     IDirect3D9Impl_CheckDeviceFormatConversion,
573     IDirect3D9Impl_GetDeviceCaps,
574     IDirect3D9Impl_GetAdapterMonitor,
575     IDirect3D9Impl_CreateDevice,
576     /* IDirect3D9Ex */
577     IDirect3D9ExImpl_GetAdapterModeCountEx,
578     IDirect3D9ExImpl_EnumAdapterModesEx,
579     IDirect3D9ExImpl_GetAdapterDisplayModeEx,
580     IDirect3D9ExImpl_CreateDeviceEx,
581     IDirect3D9ExImpl_GetAdapterLUID
582
583 };