VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/device.c@ 43488

Last change on this file since 43488 was 43488, checked in by vboxsync, 13 years ago

wined3d: profiling; export flushToHost and Finish commands
  • Property svn:eol-style set to native
File size: 129.5 KB
Line 
1/*
2 * IDirect3DDevice9 implementation
3 *
4 * Copyright 2002-2005 Jason Edmeades
5 * Copyright 2002-2005 Raphael Junqueira
6 * Copyright 2005 Oliver Stieber
7 *
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.
12 *
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.
17 *
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
21 */
22
23/*
24 * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
25 * other than GPL or LGPL is available it will apply instead, Oracle elects to use only
26 * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
27 * a choice of LGPL license versions is made available with the language indicating
28 * that LGPLv2 or any later version may be used, or where a choice of which version
29 * of the LGPL is applied is otherwise unspecified.
30 */
31
32#include "config.h"
33#include "d3d9_private.h"
34
35#ifdef VBOX_WITH_WDDM
36#include <iprt/assert.h>
37# include "../../common/VBoxVideoTools.h"
38#endif
39
40WINE_DEFAULT_DEBUG_CHANNEL(d3d9);
41
42D3DFORMAT d3dformat_from_wined3dformat(WINED3DFORMAT format)
43{
44 BYTE *c = (BYTE *)&format;
45
46 /* Don't translate FOURCC formats */
47 if (isprint(c[0]) && isprint(c[1]) && isprint(c[2]) && isprint(c[3])) return format;
48
49 switch(format)
50 {
51 case WINED3DFMT_UNKNOWN: return D3DFMT_UNKNOWN;
52 case WINED3DFMT_B8G8R8_UNORM: return D3DFMT_R8G8B8;
53 case WINED3DFMT_B8G8R8A8_UNORM: return D3DFMT_A8R8G8B8;
54 case WINED3DFMT_B8G8R8X8_UNORM: return D3DFMT_X8R8G8B8;
55 case WINED3DFMT_B5G6R5_UNORM: return D3DFMT_R5G6B5;
56 case WINED3DFMT_B5G5R5X1_UNORM: return D3DFMT_X1R5G5B5;
57 case WINED3DFMT_B5G5R5A1_UNORM: return D3DFMT_A1R5G5B5;
58 case WINED3DFMT_B4G4R4A4_UNORM: return D3DFMT_A4R4G4B4;
59 case WINED3DFMT_B2G3R3_UNORM: return D3DFMT_R3G3B2;
60 case WINED3DFMT_A8_UNORM: return D3DFMT_A8;
61 case WINED3DFMT_B2G3R3A8_UNORM: return D3DFMT_A8R3G3B2;
62 case WINED3DFMT_B4G4R4X4_UNORM: return D3DFMT_X4R4G4B4;
63 case WINED3DFMT_R10G10B10A2_UNORM: return D3DFMT_A2B10G10R10;
64 case WINED3DFMT_R8G8B8A8_UNORM: return D3DFMT_A8B8G8R8;
65 case WINED3DFMT_R8G8B8X8_UNORM: return D3DFMT_X8B8G8R8;
66 case WINED3DFMT_R16G16_UNORM: return D3DFMT_G16R16;
67 case WINED3DFMT_B10G10R10A2_UNORM: return D3DFMT_A2R10G10B10;
68 case WINED3DFMT_R16G16B16A16_UNORM: return D3DFMT_A16B16G16R16;
69 case WINED3DFMT_P8_UINT_A8_UNORM: return D3DFMT_A8P8;
70 case WINED3DFMT_P8_UINT: return D3DFMT_P8;
71 case WINED3DFMT_L8_UNORM: return D3DFMT_L8;
72 case WINED3DFMT_L8A8_UNORM: return D3DFMT_A8L8;
73 case WINED3DFMT_L4A4_UNORM: return D3DFMT_A4L4;
74 case WINED3DFMT_R8G8_SNORM: return D3DFMT_V8U8;
75 case WINED3DFMT_R5G5_SNORM_L6_UNORM: return D3DFMT_L6V5U5;
76 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM: return D3DFMT_X8L8V8U8;
77 case WINED3DFMT_R8G8B8A8_SNORM: return D3DFMT_Q8W8V8U8;
78 case WINED3DFMT_R16G16_SNORM: return D3DFMT_V16U16;
79 case WINED3DFMT_R10G10B10_SNORM_A2_UNORM: return D3DFMT_A2W10V10U10;
80 case WINED3DFMT_D16_LOCKABLE: return D3DFMT_D16_LOCKABLE;
81 case WINED3DFMT_D32_UNORM: return D3DFMT_D32;
82 case WINED3DFMT_S1_UINT_D15_UNORM: return D3DFMT_D15S1;
83 case WINED3DFMT_D24_UNORM_S8_UINT: return D3DFMT_D24S8;
84 case WINED3DFMT_X8D24_UNORM: return D3DFMT_D24X8;
85 case WINED3DFMT_S4X4_UINT_D24_UNORM: return D3DFMT_D24X4S4;
86 case WINED3DFMT_D16_UNORM: return D3DFMT_D16;
87 case WINED3DFMT_L16_UNORM: return D3DFMT_L16;
88 case WINED3DFMT_D32_FLOAT: return D3DFMT_D32F_LOCKABLE;
89 case WINED3DFMT_S8_UINT_D24_FLOAT: return D3DFMT_D24FS8;
90 case WINED3DFMT_VERTEXDATA: return D3DFMT_VERTEXDATA;
91 case WINED3DFMT_R16_UINT: return D3DFMT_INDEX16;
92 case WINED3DFMT_R32_UINT: return D3DFMT_INDEX32;
93 case WINED3DFMT_R16G16B16A16_SNORM: return D3DFMT_Q16W16V16U16;
94 case WINED3DFMT_R16_FLOAT: return D3DFMT_R16F;
95 case WINED3DFMT_R16G16_FLOAT: return D3DFMT_G16R16F;
96 case WINED3DFMT_R16G16B16A16_FLOAT: return D3DFMT_A16B16G16R16F;
97 case WINED3DFMT_R32_FLOAT: return D3DFMT_R32F;
98 case WINED3DFMT_R32G32_FLOAT: return D3DFMT_G32R32F;
99 case WINED3DFMT_R32G32B32A32_FLOAT: return D3DFMT_A32B32G32R32F;
100 case WINED3DFMT_R8G8_SNORM_Cx: return D3DFMT_CxV8U8;
101 default:
102 FIXME("Unhandled WINED3DFORMAT %#x\n", format);
103 return D3DFMT_UNKNOWN;
104 }
105}
106
107WINED3DFORMAT wined3dformat_from_d3dformat(D3DFORMAT format)
108{
109 BYTE *c = (BYTE *)&format;
110
111 /* Don't translate FOURCC formats */
112 if (isprint(c[0]) && isprint(c[1]) && isprint(c[2]) && isprint(c[3])) return format;
113
114 switch(format)
115 {
116 case D3DFMT_UNKNOWN: return WINED3DFMT_UNKNOWN;
117 case D3DFMT_R8G8B8: return WINED3DFMT_B8G8R8_UNORM;
118 case D3DFMT_A8R8G8B8: return WINED3DFMT_B8G8R8A8_UNORM;
119 case D3DFMT_X8R8G8B8: return WINED3DFMT_B8G8R8X8_UNORM;
120 case D3DFMT_R5G6B5: return WINED3DFMT_B5G6R5_UNORM;
121 case D3DFMT_X1R5G5B5: return WINED3DFMT_B5G5R5X1_UNORM;
122 case D3DFMT_A1R5G5B5: return WINED3DFMT_B5G5R5A1_UNORM;
123 case D3DFMT_A4R4G4B4: return WINED3DFMT_B4G4R4A4_UNORM;
124 case D3DFMT_R3G3B2: return WINED3DFMT_B2G3R3_UNORM;
125 case D3DFMT_A8: return WINED3DFMT_A8_UNORM;
126 case D3DFMT_A8R3G3B2: return WINED3DFMT_B2G3R3A8_UNORM;
127 case D3DFMT_X4R4G4B4: return WINED3DFMT_B4G4R4X4_UNORM;
128 case D3DFMT_A2B10G10R10: return WINED3DFMT_R10G10B10A2_UNORM;
129 case D3DFMT_A8B8G8R8: return WINED3DFMT_R8G8B8A8_UNORM;
130 case D3DFMT_X8B8G8R8: return WINED3DFMT_R8G8B8X8_UNORM;
131 case D3DFMT_G16R16: return WINED3DFMT_R16G16_UNORM;
132 case D3DFMT_A2R10G10B10: return WINED3DFMT_B10G10R10A2_UNORM;
133 case D3DFMT_A16B16G16R16: return WINED3DFMT_R16G16B16A16_UNORM;
134 case D3DFMT_A8P8: return WINED3DFMT_P8_UINT_A8_UNORM;
135 case D3DFMT_P8: return WINED3DFMT_P8_UINT;
136 case D3DFMT_L8: return WINED3DFMT_L8_UNORM;
137 case D3DFMT_A8L8: return WINED3DFMT_L8A8_UNORM;
138 case D3DFMT_A4L4: return WINED3DFMT_L4A4_UNORM;
139 case D3DFMT_V8U8: return WINED3DFMT_R8G8_SNORM;
140 case D3DFMT_L6V5U5: return WINED3DFMT_R5G5_SNORM_L6_UNORM;
141 case D3DFMT_X8L8V8U8: return WINED3DFMT_R8G8_SNORM_L8X8_UNORM;
142 case D3DFMT_Q8W8V8U8: return WINED3DFMT_R8G8B8A8_SNORM;
143 case D3DFMT_V16U16: return WINED3DFMT_R16G16_SNORM;
144 case D3DFMT_A2W10V10U10: return WINED3DFMT_R10G10B10_SNORM_A2_UNORM;
145 case D3DFMT_D16_LOCKABLE: return WINED3DFMT_D16_LOCKABLE;
146 case D3DFMT_D32: return WINED3DFMT_D32_UNORM;
147 case D3DFMT_D15S1: return WINED3DFMT_S1_UINT_D15_UNORM;
148 case D3DFMT_D24S8: return WINED3DFMT_D24_UNORM_S8_UINT;
149 case D3DFMT_D24X8: return WINED3DFMT_X8D24_UNORM;
150 case D3DFMT_D24X4S4: return WINED3DFMT_S4X4_UINT_D24_UNORM;
151 case D3DFMT_D16: return WINED3DFMT_D16_UNORM;
152 case D3DFMT_L16: return WINED3DFMT_L16_UNORM;
153 case D3DFMT_D32F_LOCKABLE: return WINED3DFMT_D32_FLOAT;
154 case D3DFMT_D24FS8: return WINED3DFMT_S8_UINT_D24_FLOAT;
155 case D3DFMT_VERTEXDATA: return WINED3DFMT_VERTEXDATA;
156 case D3DFMT_INDEX16: return WINED3DFMT_R16_UINT;
157 case D3DFMT_INDEX32: return WINED3DFMT_R32_UINT;
158 case D3DFMT_Q16W16V16U16: return WINED3DFMT_R16G16B16A16_SNORM;
159 case D3DFMT_R16F: return WINED3DFMT_R16_FLOAT;
160 case D3DFMT_G16R16F: return WINED3DFMT_R16G16_FLOAT;
161 case D3DFMT_A16B16G16R16F: return WINED3DFMT_R16G16B16A16_FLOAT;
162 case D3DFMT_R32F: return WINED3DFMT_R32_FLOAT;
163 case D3DFMT_G32R32F: return WINED3DFMT_R32G32_FLOAT;
164 case D3DFMT_A32B32G32R32F: return WINED3DFMT_R32G32B32A32_FLOAT;
165 case D3DFMT_CxV8U8: return WINED3DFMT_R8G8_SNORM_Cx;
166 default:
167 FIXME("Unhandled D3DFORMAT %#x\n", format);
168 return WINED3DFMT_UNKNOWN;
169 }
170}
171
172static UINT vertex_count_from_primitive_count(D3DPRIMITIVETYPE primitive_type, UINT primitive_count)
173{
174 switch(primitive_type)
175 {
176 case D3DPT_POINTLIST:
177 return primitive_count;
178
179 case D3DPT_LINELIST:
180 return primitive_count * 2;
181
182 case D3DPT_LINESTRIP:
183 return primitive_count + 1;
184
185 case D3DPT_TRIANGLELIST:
186 return primitive_count * 3;
187
188 case D3DPT_TRIANGLESTRIP:
189 case D3DPT_TRIANGLEFAN:
190 return primitive_count + 2;
191
192 default:
193 FIXME("Unhandled primitive type %#x\n", primitive_type);
194 return 0;
195 }
196}
197
198static ULONG WINAPI D3D9CB_DestroySwapChain(IWineD3DSwapChain *swapchain)
199{
200 IDirect3DSwapChain9Impl *parent;
201
202 TRACE("swapchain %p.\n", swapchain);
203
204 IWineD3DSwapChain_GetParent(swapchain, (IUnknown **)&parent);
205 parent->isImplicit = FALSE;
206 return IDirect3DSwapChain9_Release((IDirect3DSwapChain9 *)parent);
207}
208
209/* IDirect3D IUnknown parts follow: */
210static HRESULT WINAPI IDirect3DDevice9Impl_QueryInterface(LPDIRECT3DDEVICE9EX iface, REFIID riid, LPVOID* ppobj) {
211 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
212 IDirect3D9 *d3d;
213 IDirect3D9Impl *d3dimpl;
214
215 TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), ppobj);
216
217 if (IsEqualGUID(riid, &IID_IUnknown)
218 || IsEqualGUID(riid, &IID_IDirect3DDevice9)) {
219 IDirect3DDevice9Ex_AddRef(iface);
220 *ppobj = This;
221 TRACE("Returning IDirect3DDevice9 interface at %p\n", *ppobj);
222 return S_OK;
223 } else if(IsEqualGUID(riid, &IID_IDirect3DDevice9Ex)) {
224 /* Find out if the creating d3d9 interface was created with Direct3DCreate9Ex.
225 * It doesn't matter with which function the device was created.
226 */
227 IDirect3DDevice9_GetDirect3D(iface, &d3d);
228 d3dimpl = (IDirect3D9Impl *) d3d;
229
230 if(d3dimpl->extended) {
231 *ppobj = iface;
232 IDirect3DDevice9Ex_AddRef((IDirect3DDevice9Ex *) *ppobj);
233 IDirect3D9_Release(d3d);
234 TRACE("Returning IDirect3DDevice9Ex interface at %p\n", *ppobj);
235 return S_OK;
236 } else {
237 WARN("IDirect3D9 instance wasn't created with CreateDirect3D9Ex, returning E_NOINTERFACE\n");
238 IDirect3D9_Release(d3d);
239 *ppobj = NULL;
240 ERR_D3D();
241 return E_NOINTERFACE;
242 }
243 }
244
245 if (IsEqualGUID(riid, &IID_IWineD3DDeviceParent))
246 {
247 IUnknown_AddRef((IUnknown *)&This->device_parent_vtbl);
248 *ppobj = &This->device_parent_vtbl;
249 return S_OK;
250 }
251
252 WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
253 *ppobj = NULL;
254 ERR_D3D();
255 return E_NOINTERFACE;
256}
257
258static ULONG WINAPI IDirect3DDevice9Impl_AddRef(LPDIRECT3DDEVICE9EX iface) {
259 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
260 ULONG ref = InterlockedIncrement(&This->ref);
261
262 TRACE("%p increasing refcount to %u.\n", iface, ref);
263
264 return ref;
265}
266
267static ULONG IDirect3DDevice9Impl_Term(IDirect3DDevice9Impl *This)
268{
269 ULONG wined3dDevRefs = 0;
270 unsigned i;
271 This->inDestruction = TRUE;
272
273 wined3d_mutex_lock();
274 for(i = 0; i < This->numConvertedDecls; i++) {
275 /* Unless Wine is buggy or the app has a bug the refcount will be 0, because decls hold a reference to the
276 * device
277 */
278 IDirect3DVertexDeclaration9Impl_Destroy(This->convertedDecls[i]);
279 }
280 HeapFree(GetProcessHeap(), 0, This->convertedDecls);
281
282 IWineD3DDevice_Uninit3D(This->WineD3DDevice, D3D9CB_DestroySwapChain);
283#ifndef VBOX_WITH_WDDM
284 IWineD3DDevice_ReleaseFocusWindow(This->WineD3DDevice);
285#endif
286 wined3dDevRefs = IWineD3DDevice_Release(This->WineD3DDevice);
287 wined3d_mutex_unlock();
288
289 HeapFree(GetProcessHeap(), 0, This);
290 return wined3dDevRefs;
291}
292
293static ULONG WINAPI DECLSPEC_HOTPATCH IDirect3DDevice9Impl_Release(LPDIRECT3DDEVICE9EX iface) {
294 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
295 ULONG ref;
296
297 if (This->inDestruction) return 0;
298 ref = InterlockedDecrement(&This->ref);
299
300 TRACE("%p decreasing refcount to %u.\n", iface, ref);
301
302 if (ref == 0) {
303 IDirect3DDevice9Impl_Term(This);
304 }
305 return ref;
306}
307
308/* IDirect3DDevice Interface follow: */
309static HRESULT WINAPI IDirect3DDevice9Impl_TestCooperativeLevel(IDirect3DDevice9Ex *iface)
310{
311 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
312
313 TRACE("iface %p.\n", iface);
314
315 if (This->notreset)
316 {
317 TRACE("D3D9 device is marked not reset.\n");
318 ERR_D3D();
319 return D3DERR_DEVICENOTRESET;
320 }
321
322 return D3D_OK;
323}
324
325static UINT WINAPI IDirect3DDevice9Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE9EX iface) {
326 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
327 HRESULT hr;
328
329 TRACE("iface %p.\n", iface);
330
331 wined3d_mutex_lock();
332 hr = IWineD3DDevice_GetAvailableTextureMem(This->WineD3DDevice);
333 wined3d_mutex_unlock();
334
335 ASSERT_D3D(hr > 0x400000);
336 return hr;
337}
338
339static HRESULT WINAPI IDirect3DDevice9Impl_EvictManagedResources(LPDIRECT3DDEVICE9EX iface) {
340 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
341 HRESULT hr;
342
343 TRACE("iface %p.\n", iface);
344
345 wined3d_mutex_lock();
346 hr = IWineD3DDevice_EvictManagedResources(This->WineD3DDevice);
347 wined3d_mutex_unlock();
348
349 ASSERT_D3D(hr == S_OK);
350 return hr;
351}
352
353static HRESULT WINAPI IDirect3DDevice9Impl_GetDirect3D(LPDIRECT3DDEVICE9EX iface, IDirect3D9** ppD3D9) {
354 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
355 HRESULT hr = D3D_OK;
356 IWineD3D* pWineD3D;
357
358 TRACE("iface %p, d3d9 %p.\n", iface, ppD3D9);
359
360 if (NULL == ppD3D9) {
361 ERR_D3D();
362 return D3DERR_INVALIDCALL;
363 }
364
365 wined3d_mutex_lock();
366 hr = IWineD3DDevice_GetDirect3D(This->WineD3DDevice, &pWineD3D);
367 if (hr == D3D_OK && pWineD3D != NULL)
368 {
369 IWineD3D_GetParent(pWineD3D,(IUnknown **)ppD3D9);
370 IWineD3D_Release(pWineD3D);
371 } else {
372 FIXME("Call to IWineD3DDevice_GetDirect3D failed\n");
373 *ppD3D9 = NULL;
374 }
375 TRACE("(%p) returning %p\n", This, *ppD3D9);
376 wined3d_mutex_unlock();
377
378 ASSERT_D3D(hr == S_OK);
379 return hr;
380}
381
382static HRESULT WINAPI IDirect3DDevice9Impl_GetDeviceCaps(LPDIRECT3DDEVICE9EX iface, D3DCAPS9* pCaps) {
383 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
384 HRESULT hrc = D3D_OK;
385 WINED3DCAPS *pWineCaps;
386
387 TRACE("iface %p, caps %p.\n", iface, pCaps);
388
389 if(NULL == pCaps){
390 ERR_D3D();
391 return D3DERR_INVALIDCALL;
392 }
393 pWineCaps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINED3DCAPS));
394 if(pWineCaps == NULL){
395 ERR_D3D();
396 return D3DERR_INVALIDCALL; /* well this is what MSDN says to return */
397 }
398
399 memset(pCaps, 0, sizeof(*pCaps));
400
401 wined3d_mutex_lock();
402 hrc = IWineD3DDevice_GetDeviceCaps(This->WineD3DDevice, pWineCaps);
403 wined3d_mutex_unlock();
404
405 WINECAPSTOD3D9CAPS(pCaps, pWineCaps)
406 HeapFree(GetProcessHeap(), 0, pWineCaps);
407
408 /* Some functionality is implemented in d3d9.dll, not wined3d.dll. Add the needed caps */
409 pCaps->DevCaps2 |= D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES;
410
411 filter_caps(pCaps);
412
413 TRACE("Returning %p %p\n", This, pCaps);
414 ASSERT_D3D(hrc == S_OK);
415 return hrc;
416}
417
418static HRESULT WINAPI IDirect3DDevice9Impl_GetDisplayMode(LPDIRECT3DDEVICE9EX iface, UINT iSwapChain, D3DDISPLAYMODE* pMode) {
419 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
420 HRESULT hr;
421
422 TRACE("iface %p, swapchain %u, mode %p.\n", iface, iSwapChain, pMode);
423
424 wined3d_mutex_lock();
425 hr = IWineD3DDevice_GetDisplayMode(This->WineD3DDevice, iSwapChain, (WINED3DDISPLAYMODE *) pMode);
426 wined3d_mutex_unlock();
427
428 if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
429
430 ASSERT_D3D(hr == S_OK);
431 return hr;
432}
433
434static HRESULT WINAPI IDirect3DDevice9Impl_GetCreationParameters(LPDIRECT3DDEVICE9EX iface, D3DDEVICE_CREATION_PARAMETERS *pParameters) {
435 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
436 HRESULT hr;
437
438 TRACE("iface %p, parameters %p.\n", iface, pParameters);
439
440 wined3d_mutex_lock();
441 hr = IWineD3DDevice_GetCreationParameters(This->WineD3DDevice, (WINED3DDEVICE_CREATION_PARAMETERS *) pParameters);
442 wined3d_mutex_unlock();
443
444 ASSERT_D3D(hr == S_OK);
445 return hr;
446}
447
448static HRESULT WINAPI IDirect3DDevice9Impl_SetCursorProperties(LPDIRECT3DDEVICE9EX iface, UINT XHotSpot, UINT YHotSpot, IDirect3DSurface9* pCursorBitmap) {
449 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
450 IDirect3DSurface9Impl *pSurface = (IDirect3DSurface9Impl*)pCursorBitmap;
451 HRESULT hr;
452
453 TRACE("iface %p, hotspot_x %u, hotspot_y %u, bitmap %p.\n",
454 iface, XHotSpot, YHotSpot, pCursorBitmap);
455
456 if(!pCursorBitmap) {
457 WARN("No cursor bitmap, returning WINED3DERR_INVALIDCALL\n");
458 ERR_D3D();
459 return WINED3DERR_INVALIDCALL;
460 }
461
462 wined3d_mutex_lock();
463 hr = IWineD3DDevice_SetCursorProperties(This->WineD3DDevice, XHotSpot, YHotSpot, pSurface->wineD3DSurface);
464 wined3d_mutex_unlock();
465
466 ASSERT_D3D(hr == S_OK);
467 return hr;
468}
469
470static void WINAPI IDirect3DDevice9Impl_SetCursorPosition(LPDIRECT3DDEVICE9EX iface, int XScreenSpace, int YScreenSpace, DWORD Flags) {
471 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
472
473 TRACE("iface %p, x %u, y %u, flags %#x.\n", iface, XScreenSpace, YScreenSpace, Flags);
474
475 wined3d_mutex_lock();
476 IWineD3DDevice_SetCursorPosition(This->WineD3DDevice, XScreenSpace, YScreenSpace, Flags);
477 wined3d_mutex_unlock();
478}
479
480static BOOL WINAPI IDirect3DDevice9Impl_ShowCursor(LPDIRECT3DDEVICE9EX iface, BOOL bShow) {
481 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
482 BOOL ret;
483
484 TRACE("iface %p, show %#x.\n", iface, bShow);
485
486 wined3d_mutex_lock();
487 ret = IWineD3DDevice_ShowCursor(This->WineD3DDevice, bShow);
488 wined3d_mutex_unlock();
489
490 return ret;
491}
492
493static HRESULT IDirect3DDevice9Impl_DoCreateAdditionalSwapChain(IDirect3DDevice9Ex *iface,
494 D3DPRESENT_PARAMETERS *present_parameters, IDirect3DSwapChain9 **swapchain)
495{
496 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
497 IDirect3DSwapChain9Impl *object;
498 HRESULT hr;
499
500 TRACE("iface %p, present_parameters %p, swapchain %p.\n",
501 iface, present_parameters, swapchain);
502
503 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
504 if (!object)
505 {
506 ERR("Failed to allocate swapchain memory.\n");
507 return E_OUTOFMEMORY;
508 }
509
510 hr = swapchain_init(object, This, present_parameters);
511 if (FAILED(hr))
512 {
513 WARN("Failed to initialize swapchain, hr %#x.\n", hr);
514 HeapFree(GetProcessHeap(), 0, object);
515 return hr;
516 }
517
518 TRACE("Created swapchain %p.\n", object);
519 *swapchain = (IDirect3DSwapChain9 *)object;
520
521 return D3D_OK;
522}
523
524static HRESULT WINAPI DECLSPEC_HOTPATCH IDirect3DDevice9Impl_CreateAdditionalSwapChain(IDirect3DDevice9Ex *iface,
525 D3DPRESENT_PARAMETERS *present_parameters, IDirect3DSwapChain9 **swapchain)
526{
527 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
528 IDirect3DSwapChain9Impl *newSwapchain;
529 HRESULT hr = IDirect3DDevice9Impl_DoCreateAdditionalSwapChain(iface, present_parameters, (IDirect3DSwapChain9**)&newSwapchain);
530 if (FAILED(hr))
531 {
532 ERR("Failed to create additional swapchain, hr %#x.\n", hr);
533 return hr;
534 }
535
536 /* add swapchain to the swapchain list */
537 wined3d_mutex_lock();
538 hr = IWineD3DDevice_AddSwapChain(This->WineD3DDevice, newSwapchain->wineD3DSwapChain);
539 wined3d_mutex_unlock();
540 if (FAILED(hr))
541 {
542 ERR("Failed to add additional swapchain, hr %#x.\n", hr);
543 IUnknown_Release((IDirect3DSwapChain9*)newSwapchain);
544 return hr;
545 }
546
547 *swapchain = (IDirect3DSwapChain9 *)newSwapchain;
548 return D3D_OK;
549}
550
551static HRESULT WINAPI reset_enum_callback(IWineD3DResource *resource, void *data) {
552 BOOL *resources_ok = data;
553 D3DRESOURCETYPE type;
554 HRESULT ret = S_OK;
555 WINED3DSURFACE_DESC surface_desc;
556 WINED3DVOLUME_DESC volume_desc;
557 D3DINDEXBUFFER_DESC index_desc;
558 D3DVERTEXBUFFER_DESC vertex_desc;
559 WINED3DPOOL pool;
560 IDirect3DResource9 *parent;
561
562 IWineD3DResource_GetParent(resource, (IUnknown **) &parent);
563 type = IDirect3DResource9_GetType(parent);
564 switch(type) {
565 case D3DRTYPE_SURFACE:
566 IWineD3DSurface_GetDesc((IWineD3DSurface *) resource, &surface_desc);
567 pool = surface_desc.pool;
568 break;
569
570 case D3DRTYPE_VOLUME:
571 IWineD3DVolume_GetDesc((IWineD3DVolume *) resource, &volume_desc);
572 pool = volume_desc.Pool;
573 break;
574
575 case D3DRTYPE_INDEXBUFFER:
576 IDirect3DIndexBuffer9_GetDesc((IDirect3DIndexBuffer9 *) parent, &index_desc);
577 pool = index_desc.Pool;
578 break;
579
580 case D3DRTYPE_VERTEXBUFFER:
581 IDirect3DVertexBuffer9_GetDesc((IDirect3DVertexBuffer9 *)parent, &vertex_desc);
582 pool = vertex_desc.Pool;
583 break;
584
585 /* No need to check for textures. If there is a D3DPOOL_DEFAULT texture, there
586 * is a D3DPOOL_DEFAULT surface or volume as well
587 */
588 default:
589 pool = WINED3DPOOL_SCRATCH; /* a harmless pool */
590 break;
591 }
592
593 if(pool == WINED3DPOOL_DEFAULT) {
594 if(IUnknown_Release(parent) == 0) {
595 TRACE("Parent %p is an implicit resource with ref 0\n", parent);
596 } else {
597 WARN("Resource %p(wineD3D %p) with pool D3DPOOL_DEFAULT blocks the Reset call\n", parent, resource);
598 ret = S_FALSE;
599 *resources_ok = FALSE;
600 }
601 } else {
602 IUnknown_Release(parent);
603 }
604 IWineD3DResource_Release(resource);
605
606 return ret;
607}
608
609static HRESULT WINAPI DECLSPEC_HOTPATCH IDirect3DDevice9Impl_Reset(LPDIRECT3DDEVICE9EX iface, D3DPRESENT_PARAMETERS* pPresentationParameters) {
610 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
611 WINED3DPRESENT_PARAMETERS localParameters;
612 HRESULT hr;
613 BOOL resources_ok = TRUE;
614 UINT i;
615
616 TRACE("iface %p, present_parameters %p.\n", iface, pPresentationParameters);
617
618 /* Reset states that hold a COM object. WineD3D holds an internal reference to set objects, because
619 * such objects can still be used for rendering after their external d3d9 object has been destroyed.
620 * These objects must not be enumerated. Unsetting them tells WineD3D that the application will not
621 * make use of the hidden reference and destroys the objects.
622 *
623 * Unsetting them is no problem, because the states are supposed to be reset anyway. If the validation
624 * below fails, the device is considered "lost", and _Reset and _Release are the only allowed calls
625 */
626 wined3d_mutex_lock();
627 IWineD3DDevice_SetIndexBuffer(This->WineD3DDevice, NULL, WINED3DFMT_UNKNOWN);
628 for(i = 0; i < 16; i++) {
629 IWineD3DDevice_SetStreamSource(This->WineD3DDevice, i, NULL, 0, 0);
630 }
631 for(i = 0; i < 16; i++) {
632 IWineD3DDevice_SetTexture(This->WineD3DDevice, i, NULL);
633 }
634
635 IWineD3DDevice_EnumResources(This->WineD3DDevice, reset_enum_callback, &resources_ok);
636 if(!resources_ok) {
637 WARN("The application is holding D3DPOOL_DEFAULT resources, rejecting reset\n");
638 This->notreset = TRUE;
639 wined3d_mutex_unlock();
640
641 ERR_D3D();
642 return WINED3DERR_INVALIDCALL;
643 }
644
645 localParameters.BackBufferWidth = pPresentationParameters->BackBufferWidth;
646 localParameters.BackBufferHeight = pPresentationParameters->BackBufferHeight;
647 localParameters.BackBufferFormat = wined3dformat_from_d3dformat(pPresentationParameters->BackBufferFormat);
648 localParameters.BackBufferCount = pPresentationParameters->BackBufferCount;
649 localParameters.MultiSampleType = pPresentationParameters->MultiSampleType;
650 localParameters.MultiSampleQuality = pPresentationParameters->MultiSampleQuality;
651 localParameters.SwapEffect = pPresentationParameters->SwapEffect;
652 localParameters.hDeviceWindow = pPresentationParameters->hDeviceWindow;
653 localParameters.Windowed = pPresentationParameters->Windowed;
654 localParameters.EnableAutoDepthStencil = pPresentationParameters->EnableAutoDepthStencil;
655 localParameters.AutoDepthStencilFormat = wined3dformat_from_d3dformat(pPresentationParameters->AutoDepthStencilFormat);
656 localParameters.Flags = pPresentationParameters->Flags;
657 localParameters.FullScreen_RefreshRateInHz = pPresentationParameters->FullScreen_RefreshRateInHz;
658 localParameters.PresentationInterval = pPresentationParameters->PresentationInterval;
659 localParameters.AutoRestoreDisplayMode = TRUE;
660
661 hr = IWineD3DDevice_Reset(This->WineD3DDevice, &localParameters);
662 if(FAILED(hr)) {
663 This->notreset = TRUE;
664
665 pPresentationParameters->BackBufferWidth = localParameters.BackBufferWidth;
666 pPresentationParameters->BackBufferHeight = localParameters.BackBufferHeight;
667 pPresentationParameters->BackBufferFormat = d3dformat_from_wined3dformat(localParameters.BackBufferFormat);
668 pPresentationParameters->BackBufferCount = localParameters.BackBufferCount;
669 pPresentationParameters->MultiSampleType = localParameters.MultiSampleType;
670 pPresentationParameters->MultiSampleQuality = localParameters.MultiSampleQuality;
671 pPresentationParameters->SwapEffect = localParameters.SwapEffect;
672 pPresentationParameters->hDeviceWindow = localParameters.hDeviceWindow;
673 pPresentationParameters->Windowed = localParameters.Windowed;
674 pPresentationParameters->EnableAutoDepthStencil = localParameters.EnableAutoDepthStencil;
675 pPresentationParameters->AutoDepthStencilFormat = d3dformat_from_wined3dformat(localParameters.AutoDepthStencilFormat);
676 pPresentationParameters->Flags = localParameters.Flags;
677 pPresentationParameters->FullScreen_RefreshRateInHz = localParameters.FullScreen_RefreshRateInHz;
678 pPresentationParameters->PresentationInterval = localParameters.PresentationInterval;
679 } else {
680 This->notreset = FALSE;
681 }
682
683 wined3d_mutex_unlock();
684
685 ASSERT_D3D(hr == S_OK);
686 return hr;
687}
688
689static HRESULT WINAPI DECLSPEC_HOTPATCH IDirect3DDevice9Impl_Present(LPDIRECT3DDEVICE9EX iface, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA*
690 pDirtyRegion) {
691 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
692 HRESULT hr;
693
694 TRACE("iface %p, src_rect %p, dst_rect %p, dst_window_override %p, dirty_region %p.\n",
695 iface, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
696
697 wined3d_mutex_lock();
698 hr = IWineD3DDevice_Present(This->WineD3DDevice, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
699 wined3d_mutex_unlock();
700
701 ASSERT_D3D(hr == S_OK);
702 return hr;
703 }
704
705static HRESULT WINAPI IDirect3DDevice9Impl_GetBackBuffer(LPDIRECT3DDEVICE9EX iface, UINT iSwapChain, UINT BackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface9 ** ppBackBuffer) {
706 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
707 IWineD3DSurface *retSurface = NULL;
708 HRESULT rc = D3D_OK;
709
710 TRACE("iface %p, swapchain %u, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n",
711 iface, iSwapChain, BackBuffer, Type, ppBackBuffer);
712
713 wined3d_mutex_lock();
714 rc = IWineD3DDevice_GetBackBuffer(This->WineD3DDevice, iSwapChain, BackBuffer, (WINED3DBACKBUFFER_TYPE) Type, &retSurface);
715 if (rc == D3D_OK && NULL != retSurface && NULL != ppBackBuffer) {
716 IWineD3DSurface_GetParent(retSurface, (IUnknown **)ppBackBuffer);
717 IWineD3DSurface_Release(retSurface);
718 }
719 wined3d_mutex_unlock();
720
721 ASSERT_D3D(rc == S_OK);
722 return rc;
723}
724static HRESULT WINAPI IDirect3DDevice9Impl_GetRasterStatus(LPDIRECT3DDEVICE9EX iface, UINT iSwapChain, D3DRASTER_STATUS* pRasterStatus) {
725 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
726 HRESULT hr;
727
728 TRACE("iface %p, swapchain %u, raster_status %p.\n", iface, iSwapChain, pRasterStatus);
729
730 wined3d_mutex_lock();
731 hr = IWineD3DDevice_GetRasterStatus(This->WineD3DDevice, iSwapChain, (WINED3DRASTER_STATUS *) pRasterStatus);
732 wined3d_mutex_unlock();
733
734 ASSERT_D3D(hr == S_OK);
735 return hr;
736}
737
738static HRESULT WINAPI IDirect3DDevice9Impl_SetDialogBoxMode(LPDIRECT3DDEVICE9EX iface, BOOL bEnableDialogs) {
739 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
740 HRESULT hr;
741
742 TRACE("iface %p, enable %#x.\n", iface, bEnableDialogs);
743
744 wined3d_mutex_lock();
745 hr = IWineD3DDevice_SetDialogBoxMode(This->WineD3DDevice, bEnableDialogs);
746 wined3d_mutex_unlock();
747
748 ASSERT_D3D(hr == S_OK);
749 return hr;
750}
751
752static void WINAPI IDirect3DDevice9Impl_SetGammaRamp(IDirect3DDevice9Ex *iface, UINT iSwapChain,
753 DWORD Flags, const D3DGAMMARAMP *pRamp)
754{
755 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
756
757 TRACE("iface %p, swapchain %u, flags %#x, ramp %p.\n", iface, iSwapChain, Flags, pRamp);
758
759 /* Note: D3DGAMMARAMP is compatible with WINED3DGAMMARAMP */
760 wined3d_mutex_lock();
761 IWineD3DDevice_SetGammaRamp(This->WineD3DDevice, iSwapChain, Flags, (CONST WINED3DGAMMARAMP *)pRamp);
762 wined3d_mutex_unlock();
763}
764
765static void WINAPI IDirect3DDevice9Impl_GetGammaRamp(LPDIRECT3DDEVICE9EX iface, UINT iSwapChain, D3DGAMMARAMP* pRamp) {
766 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
767
768 TRACE("iface %p, swapchain %u, ramp %p.\n", iface, iSwapChain, pRamp);
769
770 /* Note: D3DGAMMARAMP is compatible with WINED3DGAMMARAMP */
771 wined3d_mutex_lock();
772 IWineD3DDevice_GetGammaRamp(This->WineD3DDevice, iSwapChain, (WINED3DGAMMARAMP *) pRamp);
773 wined3d_mutex_unlock();
774}
775
776#ifdef VBOX_WITH_WDDM
777//#pragma comment(linker, "/export:VBoxWineExD3DDev9Flush=_VBoxWineExD3DDev9Flush@4")
778
779VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Flush(IDirect3DDevice9Ex *iface)
780{
781 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
782 HRESULT hr;
783
784 TRACE("iface %p, Flush\n", iface);
785
786 wined3d_mutex_lock();
787 hr = IWineD3DDevice_Flush(This->WineD3DDevice);
788 wined3d_mutex_unlock();
789
790 return hr;
791}
792
793VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9FlushToHost(IDirect3DDevice9Ex *iface)
794{
795 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
796 HRESULT hr;
797
798 TRACE("iface %p, FlushToHost\n", iface);
799
800 wined3d_mutex_lock();
801 hr = IWineD3DDevice_FlushToHost(This->WineD3DDevice);
802 wined3d_mutex_unlock();
803
804 return hr;
805}
806
807VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Finish(IDirect3DDevice9Ex *iface)
808{
809 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
810 HRESULT hr;
811
812 TRACE("iface %p, Finish\n", iface);
813
814 wined3d_mutex_lock();
815 hr = IWineD3DDevice_Finish(This->WineD3DDevice);
816 wined3d_mutex_unlock();
817
818 return hr;
819}
820
821//#pragma comment(linker, "/export:VBoxWineExD3DDev9CreateTexture=_VBoxWineExD3DDev9CreateTexture@40")
822
823VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9CreateTexture(IDirect3DDevice9Ex *iface,
824 UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format,
825 D3DPOOL pool, IDirect3DTexture9 **texture, HANDLE *shared_handle,
826 void **pavClientMem) /* <- extension arg to pass in the client memory buffer,
827 * applicable ONLY for SYSMEM textures */
828{
829 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
830 IDirect3DTexture9Impl *object;
831 HRESULT hr;
832
833 TRACE("iface %p, width %u, height %u, levels %u, usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n",
834 iface, width, height, levels, usage, format, pool, texture, shared_handle);
835
836 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
837 if (!object)
838 {
839 ERR("Failed to allocate texture memory.\n");
840 return D3DERR_OUTOFVIDEOMEMORY;
841 }
842
843 hr = texture_init(object, This, width, height, levels, usage, format, pool
844 , shared_handle
845 , pavClientMem
846 );
847 if (FAILED(hr))
848 {
849 WARN("Failed to initialize texture, hr %#x.\n", hr);
850 HeapFree(GetProcessHeap(), 0, object);
851 return hr;
852 }
853
854 TRACE("Created texture %p.\n", object);
855 *texture = (IDirect3DTexture9 *)object;
856
857 return D3D_OK;
858}
859
860VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9CreateVolumeTexture(IDirect3DDevice9Ex *iface,
861 UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format,
862 D3DPOOL pool, IDirect3DVolumeTexture9 **texture, HANDLE *shared_handle,
863 void **pavClientMem)
864{
865 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
866 IDirect3DVolumeTexture9Impl *object;
867 HRESULT hr;
868
869 TRACE("iface %p, width %u, height %u, depth %u, levels %u\n",
870 iface, width, height, depth, levels);
871 TRACE("usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n",
872 usage, format, pool, texture, shared_handle);
873
874 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
875 if (!object)
876 {
877 ERR("Failed to allocate volume texture memory.\n");
878 ERR_D3D();
879 return D3DERR_OUTOFVIDEOMEMORY;
880 }
881
882 hr = volumetexture_init(object, This, width, height, depth, levels, usage, format, pool, shared_handle, pavClientMem);
883 if (FAILED(hr))
884 {
885 ERR_D3D();
886 WARN("Failed to initialize volume texture, hr %#x.\n", hr);
887 HeapFree(GetProcessHeap(), 0, object);
888 return hr;
889 }
890
891 TRACE("Created volume texture %p.\n", object);
892 *texture = (IDirect3DVolumeTexture9 *)object;
893
894 return D3D_OK;
895}
896
897#ifdef VBOX_WITH_WDDM
898
899AssertCompile(sizeof (WINED3DBOX) == sizeof (VBOXBOX3D));
900AssertCompile(RT_SIZEOFMEMB(WINED3DBOX, Left) == RT_SIZEOFMEMB(VBOXBOX3D, Left));
901AssertCompile(RT_SIZEOFMEMB(WINED3DBOX, Top) == RT_SIZEOFMEMB(VBOXBOX3D, Top));
902AssertCompile(RT_SIZEOFMEMB(WINED3DBOX, Right) == RT_SIZEOFMEMB(VBOXBOX3D, Right));
903AssertCompile(RT_SIZEOFMEMB(WINED3DBOX, Bottom) == RT_SIZEOFMEMB(VBOXBOX3D, Bottom));
904AssertCompile(RT_SIZEOFMEMB(WINED3DBOX, Front) == RT_SIZEOFMEMB(VBOXBOX3D, Front));
905AssertCompile(RT_SIZEOFMEMB(WINED3DBOX, Back) == RT_SIZEOFMEMB(VBOXBOX3D, Back));
906
907AssertCompile(RT_OFFSETOF(WINED3DBOX, Left) == RT_OFFSETOF(VBOXBOX3D, Left));
908AssertCompile(RT_OFFSETOF(WINED3DBOX, Top) == RT_OFFSETOF(VBOXBOX3D, Top));
909AssertCompile(RT_OFFSETOF(WINED3DBOX, Right) == RT_OFFSETOF(VBOXBOX3D, Right));
910AssertCompile(RT_OFFSETOF(WINED3DBOX, Bottom) == RT_OFFSETOF(VBOXBOX3D, Bottom));
911AssertCompile(RT_OFFSETOF(WINED3DBOX, Front) == RT_OFFSETOF(VBOXBOX3D, Front));
912AssertCompile(RT_OFFSETOF(WINED3DBOX, Back) == RT_OFFSETOF(VBOXBOX3D, Back));
913
914VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9VolBlt(IDirect3DDevice9Ex *iface,
915 IDirect3DVolume9 *pSourceVolume, IDirect3DVolume9 *pDestinationVolume,
916 const VBOXBOX3D *pSrcBoxArg,
917 const VBOXPOINT3D *pDstPoin3D)
918{
919 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
920 IDirect3DVolume9Impl *src = (IDirect3DVolume9Impl *)pSourceVolume;
921 IDirect3DVolume9Impl *dst = (IDirect3DVolume9Impl *)pDestinationVolume;
922 HRESULT hr;
923
924 wined3d_mutex_lock();
925 hr = IWineD3DDevice_VolBlt(This->WineD3DDevice, src->wineD3DVolume, dst->wineD3DVolume, (WINED3DBOX*)pSrcBoxArg, pDstPoin3D);
926 wined3d_mutex_unlock();
927
928 return hr;
929}
930
931VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9VolTexBlt(IDirect3DDevice9Ex *iface,
932 IDirect3DVolumeTexture9 *pSourceTexture, IDirect3DVolumeTexture9 *pDestinationTexture,
933 const VBOXBOX3D *pSrcBoxArg,
934 const VBOXPOINT3D *pDstPoin3D)
935{
936 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
937 IDirect3DVolumeTexture9Impl *src = (IDirect3DVolumeTexture9Impl *)pSourceTexture;
938 IDirect3DVolumeTexture9Impl *dst = (IDirect3DVolumeTexture9Impl *)pDestinationTexture;
939 HRESULT hr;
940
941 wined3d_mutex_lock();
942 hr = IWineD3DDevice_VolTexBlt(This->WineD3DDevice, src->wineD3DVolumeTexture, dst->wineD3DVolumeTexture, (WINED3DBOX*)pSrcBoxArg, pDstPoin3D);
943 wined3d_mutex_unlock();
944
945 return hr;
946}
947#endif
948
949VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Update(IDirect3DDevice9Ex *iface, D3DPRESENT_PARAMETERS * pParams, IDirect3DDevice9Ex **outIface)
950{
951 IDirect3DDevice9_AddRef(iface);
952 *outIface = iface;
953 return D3D_OK;
954}
955
956VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Term(IDirect3DDevice9Ex *iface)
957{
958 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
959 IWineD3DDevice *WineD3DDevice = This->WineD3DDevice;
960 ULONG wined3dRefs;
961 if (This->ref != 1)
962 {
963 ERR("unexpected ref count %d, destroying in anyway", This->ref);
964 }
965 wined3dRefs = IDirect3DDevice9Impl_Term(This);
966 if (wined3dRefs)
967 {
968 ERR("unexpected wined3dRefs %d, destroying in anyway", wined3dRefs);
969 while (IWineD3DDevice_Release(WineD3DDevice)) {}
970 }
971 return D3D_OK;
972}
973
974VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9CreateCubeTexture(IDirect3DDevice9Ex *iface,
975 UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format,
976 D3DPOOL pool, IDirect3DCubeTexture9 **texture, HANDLE *shared_handle,
977 void **pavClientMem) /* <- extension arg to pass in the client memory buffer,
978 * applicable ONLY for SYSMEM textures */
979{
980 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
981 IDirect3DCubeTexture9Impl *object;
982 HRESULT hr;
983
984 TRACE("iface %p, edge_length %u, levels %u, usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n",
985 iface, edge_length, levels, usage, format, pool, texture, shared_handle);
986
987 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
988 if (!object)
989 {
990 ERR("Failed to allocate cube texture memory.\n");
991 return D3DERR_OUTOFVIDEOMEMORY;
992 }
993
994 hr = cubetexture_init(object, This, edge_length, levels, usage, format, pool, shared_handle, pavClientMem);
995 if (FAILED(hr))
996 {
997 WARN("Failed to initialize cube texture, hr %#x.\n", hr);
998 HeapFree(GetProcessHeap(), 0, object);
999 return hr;
1000 }
1001
1002 TRACE("Created cube texture %p.\n", object);
1003 *texture = (IDirect3DCubeTexture9 *)object;
1004
1005 return D3D_OK;
1006}
1007
1008#endif
1009
1010static HRESULT WINAPI IDirect3DDevice9Impl_CreateTexture(IDirect3DDevice9Ex *iface,
1011 UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format,
1012 D3DPOOL pool, IDirect3DTexture9 **texture, HANDLE *shared_handle)
1013{
1014#ifdef VBOX_WITH_WDDM
1015 return VBoxWineExD3DDev9CreateTexture(iface, width, height, levels, usage, format,
1016 pool, texture, shared_handle, NULL);
1017#else
1018 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1019 IDirect3DTexture9Impl *object;
1020 HRESULT hr;
1021
1022 TRACE("iface %p, width %u, height %u, levels %u, usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n",
1023 iface, width, height, levels, usage, format, pool, texture, shared_handle);
1024
1025 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1026 if (!object)
1027 {
1028 ERR("Failed to allocate texture memory.\n");
1029 ERR_D3D();
1030 return D3DERR_OUTOFVIDEOMEMORY;
1031 }
1032
1033 hr = texture_init(object, This, width, height, levels, usage, format, pool);
1034 if (FAILED(hr))
1035 {
1036 WARN("Failed to initialize texture, hr %#x.\n", hr);
1037 HeapFree(GetProcessHeap(), 0, object);
1038 ERR_D3D();
1039 return hr;
1040 }
1041
1042 TRACE("Created texture %p.\n", object);
1043 *texture = (IDirect3DTexture9 *)object;
1044
1045 return D3D_OK;
1046#endif
1047}
1048
1049static HRESULT WINAPI IDirect3DDevice9Impl_CreateVolumeTexture(IDirect3DDevice9Ex *iface,
1050 UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format,
1051 D3DPOOL pool, IDirect3DVolumeTexture9 **texture, HANDLE *shared_handle)
1052{
1053#ifdef VBOX_WITH_WDDM
1054 return VBoxWineExD3DDev9CreateVolumeTexture(iface, width, height, depth, levels, usage, format,
1055 pool, texture, shared_handle, NULL);
1056#else
1057 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1058 IDirect3DVolumeTexture9Impl *object;
1059 HRESULT hr;
1060
1061 TRACE("iface %p, width %u, height %u, depth %u, levels %u\n",
1062 iface, width, height, depth, levels);
1063 TRACE("usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n",
1064 usage, format, pool, texture, shared_handle);
1065
1066 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1067 if (!object)
1068 {
1069 ERR("Failed to allocate volume texture memory.\n");
1070 ERR_D3D();
1071 return D3DERR_OUTOFVIDEOMEMORY;
1072 }
1073
1074 hr = volumetexture_init(object, This, width, height, depth, levels, usage, format, pool);
1075 if (FAILED(hr))
1076 {
1077 ERR_D3D();
1078 WARN("Failed to initialize volume texture, hr %#x.\n", hr);
1079 HeapFree(GetProcessHeap(), 0, object);
1080 return hr;
1081 }
1082
1083 TRACE("Created volume texture %p.\n", object);
1084 *texture = (IDirect3DVolumeTexture9 *)object;
1085
1086 return D3D_OK;
1087#endif
1088}
1089
1090static HRESULT WINAPI IDirect3DDevice9Impl_CreateCubeTexture(IDirect3DDevice9Ex *iface,
1091 UINT edge_length, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool,
1092 IDirect3DCubeTexture9 **texture, HANDLE *shared_handle)
1093{
1094#ifdef VBOX_WITH_WDDM
1095 return VBoxWineExD3DDev9CreateCubeTexture(iface, edge_length, levels, usage, format,
1096 pool, texture, shared_handle, NULL);
1097#else
1098 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1099 IDirect3DCubeTexture9Impl *object;
1100 HRESULT hr;
1101
1102 TRACE("iface %p, edge_length %u, levels %u, usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n",
1103 iface, edge_length, levels, usage, format, pool, texture, shared_handle);
1104
1105 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1106 if (!object)
1107 {
1108 ERR("Failed to allocate cube texture memory.\n");
1109 ERR_D3D();
1110 return D3DERR_OUTOFVIDEOMEMORY;
1111 }
1112
1113 hr = cubetexture_init(object, This, edge_length, levels, usage, format, pool);
1114 if (FAILED(hr))
1115 {
1116 ERR_D3D();
1117 WARN("Failed to initialize cube texture, hr %#x.\n", hr);
1118 HeapFree(GetProcessHeap(), 0, object);
1119 return hr;
1120 }
1121
1122 TRACE("Created cube texture %p.\n", object);
1123 *texture = (IDirect3DCubeTexture9 *)object;
1124
1125 return D3D_OK;
1126#endif
1127}
1128
1129static HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexBuffer(IDirect3DDevice9Ex *iface, UINT size, DWORD usage,
1130 DWORD fvf, D3DPOOL pool, IDirect3DVertexBuffer9 **buffer, HANDLE *shared_handle)
1131{
1132 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1133 IDirect3DVertexBuffer9Impl *object;
1134 HRESULT hr;
1135
1136 TRACE("iface %p, size %u, usage %#x, fvf %#x, pool %#x, buffer %p, shared_handle %p.\n",
1137 iface, size, usage, fvf, pool, buffer, shared_handle);
1138
1139 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1140 if (!object)
1141 {
1142 ERR_D3D();
1143 ERR("Failed to allocate buffer memory.\n");
1144 return D3DERR_OUTOFVIDEOMEMORY;
1145 }
1146
1147 hr = vertexbuffer_init(object, This, size, usage, fvf, pool);
1148 if (FAILED(hr))
1149 {
1150 ERR_D3D();
1151 WARN("Failed to initialize vertex buffer, hr %#x.\n", hr);
1152 HeapFree(GetProcessHeap(), 0, object);
1153 return hr;
1154 }
1155
1156 TRACE("Created vertex buffer %p.\n", object);
1157 *buffer = (IDirect3DVertexBuffer9 *)object;
1158
1159 return D3D_OK;
1160}
1161
1162static HRESULT WINAPI IDirect3DDevice9Impl_CreateIndexBuffer(IDirect3DDevice9Ex *iface, UINT size, DWORD usage,
1163 D3DFORMAT format, D3DPOOL pool, IDirect3DIndexBuffer9 **buffer, HANDLE *shared_handle)
1164{
1165 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1166 IDirect3DIndexBuffer9Impl *object;
1167 HRESULT hr;
1168
1169 TRACE("iface %p, size %u, usage %#x, format %#x, pool %#x, buffer %p, shared_handle %p.\n",
1170 iface, size, usage, format, pool, buffer, shared_handle);
1171
1172 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1173 if (!object)
1174 {
1175 ERR_D3D();
1176 ERR("Failed to allocate buffer memory.\n");
1177 return D3DERR_OUTOFVIDEOMEMORY;
1178 }
1179
1180 hr = indexbuffer_init(object, This, size, usage, format, pool);
1181 if (FAILED(hr))
1182 {
1183 ERR_D3D();
1184 WARN("Failed to initialize index buffer, hr %#x.\n", hr);
1185 HeapFree(GetProcessHeap(), 0, object);
1186 return hr;
1187 }
1188
1189 TRACE("Created index buffer %p.\n", object);
1190 *buffer = (IDirect3DIndexBuffer9 *)object;
1191
1192 return D3D_OK;
1193}
1194
1195static HRESULT IDirect3DDevice9Impl_CreateSurface(LPDIRECT3DDEVICE9EX iface, UINT Width, UINT Height,
1196 D3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IDirect3DSurface9 **ppSurface,
1197 UINT Usage, D3DPOOL Pool, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality
1198#ifdef VBOX_WITH_WDDM
1199 , HANDLE *shared_handle
1200 , void *pvClientMem
1201#endif
1202 )
1203{
1204 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1205 IDirect3DSurface9Impl *object;
1206 HRESULT hr;
1207
1208 TRACE("iface %p, width %u, height %u, format %#x, lockable %#x, discard %#x, level %u, surface %p.\n"
1209 "usage %#x, pool %#x, multisample_type %#x, multisample_quality %u.\n",
1210 iface, Width, Height, Format, Lockable, Discard, Level, ppSurface,
1211 Usage, Pool, MultiSample, MultisampleQuality);
1212
1213 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DSurface9Impl));
1214 if (!object)
1215 {
1216 ERR_D3D();
1217 FIXME("Failed to allocate surface memory.\n");
1218 return D3DERR_OUTOFVIDEOMEMORY;
1219 }
1220
1221 hr = surface_init(object, This, Width, Height, Format, Lockable, Discard,
1222 Level, Usage, Pool, MultiSample, MultisampleQuality
1223#ifdef VBOX_WITH_WDDM
1224 , shared_handle
1225 , pvClientMem
1226#endif
1227 );
1228 if (FAILED(hr))
1229 {
1230 ERR_D3D();
1231 WARN("Failed to initialize surface, hr %#x.\n", hr);
1232 HeapFree(GetProcessHeap(), 0, object);
1233 return hr;
1234 }
1235
1236 TRACE("Created surface %p.\n", object);
1237 *ppSurface = (IDirect3DSurface9 *)object;
1238
1239 return D3D_OK;
1240}
1241
1242static HRESULT WINAPI IDirect3DDevice9Impl_CreateRenderTarget(IDirect3DDevice9Ex *iface, UINT Width, UINT Height,
1243 D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Lockable,
1244 IDirect3DSurface9 **ppSurface, HANDLE *pSharedHandle)
1245{
1246 HRESULT hr;
1247
1248 TRACE("iface %p, width %u, height %u, format %#x, multisample_type %#x, multisample_quality %u.\n"
1249 "lockable %#x, surface %p, shared_handle %p.\n",
1250 iface, Width, Height, Format, MultiSample, MultisampleQuality,
1251 Lockable, ppSurface, pSharedHandle);
1252
1253 hr = IDirect3DDevice9Impl_CreateSurface(iface, Width, Height, Format, Lockable, FALSE /* Discard */,
1254 0 /* Level */, ppSurface, D3DUSAGE_RENDERTARGET, D3DPOOL_DEFAULT, MultiSample, MultisampleQuality
1255#ifdef VBOX_WITH_WDDM
1256 , pSharedHandle
1257 , NULL
1258#endif
1259 );
1260
1261 ASSERT_D3D(hr == S_OK);
1262 return hr;
1263}
1264
1265static HRESULT WINAPI IDirect3DDevice9Impl_CreateDepthStencilSurface(LPDIRECT3DDEVICE9EX iface, UINT Width, UINT Height,
1266 D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample,
1267 DWORD MultisampleQuality, BOOL Discard,
1268 IDirect3DSurface9 **ppSurface, HANDLE* pSharedHandle) {
1269 HRESULT hr;
1270
1271 TRACE("iface %p, width %u, height %u, format %#x, multisample_type %#x, multisample_quality %u.\n"
1272 "discard %#x, surface %p, shared_handle %p.\n",
1273 iface, Width, Height, Format, MultiSample, MultisampleQuality,
1274 Discard, ppSurface, pSharedHandle);
1275
1276 hr = IDirect3DDevice9Impl_CreateSurface(iface, Width, Height, Format, TRUE /* Lockable */, Discard,
1277 0 /* Level */, ppSurface, D3DUSAGE_DEPTHSTENCIL, D3DPOOL_DEFAULT, MultiSample, MultisampleQuality
1278#ifdef VBOX_WITH_WDDM
1279 , pSharedHandle
1280 , NULL
1281#endif
1282 );
1283
1284 ASSERT_D3D(hr == S_OK);
1285 return hr;
1286}
1287
1288
1289static HRESULT WINAPI IDirect3DDevice9Impl_UpdateSurface(LPDIRECT3DDEVICE9EX iface, IDirect3DSurface9* pSourceSurface, CONST RECT* pSourceRect, IDirect3DSurface9* pDestinationSurface, CONST POINT* pDestPoint) {
1290 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1291 HRESULT hr;
1292
1293 TRACE("iface %p, src_surface %p, src_rect %p, dst_surface %p, dst_point %p.\n",
1294 iface, pSourceSurface, pSourceRect, pDestinationSurface, pDestPoint);
1295
1296 wined3d_mutex_lock();
1297 hr = IWineD3DDevice_UpdateSurface(This->WineD3DDevice, ((IDirect3DSurface9Impl *)pSourceSurface)->wineD3DSurface, pSourceRect, ((IDirect3DSurface9Impl *)pDestinationSurface)->wineD3DSurface, pDestPoint);
1298 wined3d_mutex_unlock();
1299
1300 ASSERT_D3D(hr == S_OK);
1301 return hr;
1302}
1303
1304static HRESULT WINAPI IDirect3DDevice9Impl_UpdateTexture(LPDIRECT3DDEVICE9EX iface, IDirect3DBaseTexture9* pSourceTexture, IDirect3DBaseTexture9* pDestinationTexture) {
1305 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1306 HRESULT hr;
1307
1308 TRACE("iface %p, src_texture %p, dst_texture %p.\n", iface, pSourceTexture, pDestinationTexture);
1309
1310 wined3d_mutex_lock();
1311 hr = IWineD3DDevice_UpdateTexture(This->WineD3DDevice, ((IDirect3DBaseTexture9Impl *)pSourceTexture)->wineD3DBaseTexture, ((IDirect3DBaseTexture9Impl *)pDestinationTexture)->wineD3DBaseTexture);
1312 wined3d_mutex_unlock();
1313
1314 ASSERT_D3D(hr == S_OK);
1315 return hr;
1316}
1317
1318static HRESULT WINAPI IDirect3DDevice9Impl_GetRenderTargetData(IDirect3DDevice9Ex *iface,
1319 IDirect3DSurface9 *pRenderTarget, IDirect3DSurface9 *pDestSurface)
1320{
1321 IDirect3DSurface9Impl *renderTarget = (IDirect3DSurface9Impl *)pRenderTarget;
1322 IDirect3DSurface9Impl *destSurface = (IDirect3DSurface9Impl *)pDestSurface;
1323 HRESULT hr;
1324
1325 TRACE("iface %p, render_target %p, dst_surface %p.\n", iface, pRenderTarget, pDestSurface);
1326
1327 wined3d_mutex_lock();
1328 hr = IWineD3DSurface_BltFast(destSurface->wineD3DSurface, 0, 0, renderTarget->wineD3DSurface, NULL, WINEDDBLTFAST_NOCOLORKEY);
1329 wined3d_mutex_unlock();
1330
1331 ASSERT_D3D(hr == S_OK);
1332 return hr;
1333}
1334
1335static HRESULT WINAPI IDirect3DDevice9Impl_GetFrontBufferData(LPDIRECT3DDEVICE9EX iface, UINT iSwapChain, IDirect3DSurface9* pDestSurface) {
1336 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1337 IDirect3DSurface9Impl *destSurface = (IDirect3DSurface9Impl *)pDestSurface;
1338 HRESULT hr;
1339
1340 TRACE("iface %p, swapchain %u, dst_surface %p.\n", iface, iSwapChain, pDestSurface);
1341
1342 wined3d_mutex_lock();
1343 hr = IWineD3DDevice_GetFrontBufferData(This->WineD3DDevice, iSwapChain, destSurface->wineD3DSurface);
1344 wined3d_mutex_unlock();
1345
1346 ASSERT_D3D(hr == S_OK);
1347 return hr;
1348}
1349
1350static HRESULT WINAPI IDirect3DDevice9Impl_StretchRect(IDirect3DDevice9Ex *iface, IDirect3DSurface9 *pSourceSurface,
1351 const RECT *pSourceRect, IDirect3DSurface9 *pDestSurface, const RECT *pDestRect, D3DTEXTUREFILTERTYPE Filter)
1352{
1353 IDirect3DSurface9Impl *src = (IDirect3DSurface9Impl *) pSourceSurface;
1354 IDirect3DSurface9Impl *dst = (IDirect3DSurface9Impl *) pDestSurface;
1355 HRESULT hr;
1356
1357 TRACE("iface %p, src_surface %p, src_rect %p, dst_surface %p, dst_rect %p, filter %#x.\n",
1358 iface, pSourceSurface, pSourceRect, pDestSurface, pDestRect, Filter);
1359
1360 wined3d_mutex_lock();
1361 hr = IWineD3DSurface_Blt(dst->wineD3DSurface, pDestRect, src->wineD3DSurface, pSourceRect, 0, NULL, Filter);
1362 wined3d_mutex_unlock();
1363
1364 ASSERT_D3D(hr == S_OK);
1365 return hr;
1366}
1367
1368static HRESULT WINAPI IDirect3DDevice9Impl_ColorFill(LPDIRECT3DDEVICE9EX iface, IDirect3DSurface9* pSurface, CONST RECT* pRect, D3DCOLOR color) {
1369 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1370 IDirect3DSurface9Impl *surface = (IDirect3DSurface9Impl *)pSurface;
1371 WINED3DPOOL pool;
1372 WINED3DRESOURCETYPE restype;
1373 DWORD usage;
1374 WINED3DSURFACE_DESC desc;
1375 HRESULT hr;
1376
1377 TRACE("iface %p, surface %p, rect %p, color 0x%08x.\n", iface, pSurface, pRect, color);
1378
1379 wined3d_mutex_lock();
1380
1381 IWineD3DSurface_GetDesc(surface->wineD3DSurface, &desc);
1382 usage = desc.usage;
1383 pool = desc.pool;
1384 restype = desc.resource_type;
1385
1386 /* This method is only allowed with surfaces that are render targets, or offscreen plain surfaces
1387 * in D3DPOOL_DEFAULT
1388 */
1389 if(!(usage & WINED3DUSAGE_RENDERTARGET) && (pool != WINED3DPOOL_DEFAULT || restype != WINED3DRTYPE_SURFACE)) {
1390 wined3d_mutex_unlock();
1391 WARN("Surface is not a render target, or not a stand-alone D3DPOOL_DEFAULT surface\n");
1392 ERR_D3D();
1393 return D3DERR_INVALIDCALL;
1394 }
1395
1396 /* Colorfill can only be used on rendertarget surfaces, or offscreen plain surfaces in D3DPOOL_DEFAULT */
1397 /* Note: D3DRECT is compatible with WINED3DRECT */
1398 hr = IWineD3DDevice_ColorFill(This->WineD3DDevice, surface->wineD3DSurface, (CONST WINED3DRECT*)pRect, color);
1399
1400 wined3d_mutex_unlock();
1401
1402 ASSERT_D3D(hr == S_OK);
1403 return hr;
1404}
1405
1406static HRESULT WINAPI IDirect3DDevice9Impl_CreateOffscreenPlainSurface(LPDIRECT3DDEVICE9EX iface, UINT Width, UINT Height, D3DFORMAT Format, D3DPOOL Pool, IDirect3DSurface9 **ppSurface, HANDLE* pSharedHandle) {
1407 HRESULT hr;
1408
1409 TRACE("iface %p, width %u, height %u, format %#x, pool %#x, surface %p, shared_handle %p.\n",
1410 iface, Width, Height, Format, Pool, ppSurface, pSharedHandle);
1411
1412 if(Pool == D3DPOOL_MANAGED ){
1413 ERR_D3D();
1414 FIXME("Attempting to create a managed offscreen plain surface\n");
1415 return D3DERR_INVALIDCALL;
1416 }
1417 /*
1418 'Off-screen plain surfaces are always lockable, regardless of their pool types.'
1419 but then...
1420 D3DPOOL_DEFAULT is the appropriate pool for use with the IDirect3DDevice9::StretchRect and IDirect3DDevice9::ColorFill.
1421 Why, their always lockable?
1422 should I change the usage to dynamic?
1423 */
1424 hr = IDirect3DDevice9Impl_CreateSurface(iface, Width, Height, Format, TRUE /* Lockable */, FALSE /* Discard */,
1425 0 /* Level */, ppSurface, 0 /* Usage (undefined/none) */, (WINED3DPOOL)Pool, D3DMULTISAMPLE_NONE,
1426 0 /* MultisampleQuality */
1427#ifdef VBOX_WITH_WDDM
1428 , pSharedHandle
1429 , NULL
1430#endif
1431 );
1432
1433 ASSERT_D3D(hr == S_OK);
1434 return hr;
1435}
1436
1437/* TODO: move to wineD3D */
1438static HRESULT WINAPI IDirect3DDevice9Impl_SetRenderTarget(LPDIRECT3DDEVICE9EX iface, DWORD RenderTargetIndex, IDirect3DSurface9* pRenderTarget) {
1439 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1440 IDirect3DSurface9Impl *pSurface = (IDirect3DSurface9Impl*)pRenderTarget;
1441 HRESULT hr;
1442
1443 TRACE("iface %p, idx %u, surface %p.\n", iface, RenderTargetIndex, pRenderTarget);
1444
1445 if (RenderTargetIndex >= D3D9_MAX_SIMULTANEOUS_RENDERTARGETS)
1446 {
1447 ERR_D3D();
1448 WARN("Invalid index %u specified.\n", RenderTargetIndex);
1449 return D3DERR_INVALIDCALL;
1450 }
1451
1452 wined3d_mutex_lock();
1453 hr = IWineD3DDevice_SetRenderTarget(This->WineD3DDevice, RenderTargetIndex, pSurface ? pSurface->wineD3DSurface : NULL, TRUE);
1454 wined3d_mutex_unlock();
1455
1456 ASSERT_D3D(hr == S_OK);
1457 return hr;
1458}
1459
1460static HRESULT WINAPI IDirect3DDevice9Impl_GetRenderTarget(LPDIRECT3DDEVICE9EX iface, DWORD RenderTargetIndex, IDirect3DSurface9 **ppRenderTarget) {
1461 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1462 IWineD3DSurface *pRenderTarget;
1463 HRESULT hr;
1464
1465 TRACE("iface %p, idx %u, surface %p.\n", iface, RenderTargetIndex, ppRenderTarget);
1466
1467 if (ppRenderTarget == NULL) {
1468 ERR_D3D();
1469 return D3DERR_INVALIDCALL;
1470 }
1471
1472 if (RenderTargetIndex >= D3D9_MAX_SIMULTANEOUS_RENDERTARGETS)
1473 {
1474 ERR_D3D();
1475 WARN("Invalid index %u specified.\n", RenderTargetIndex);
1476 return D3DERR_INVALIDCALL;
1477 }
1478
1479 wined3d_mutex_lock();
1480
1481 hr=IWineD3DDevice_GetRenderTarget(This->WineD3DDevice,RenderTargetIndex,&pRenderTarget);
1482
1483 if (FAILED(hr))
1484 {
1485 FIXME("Call to IWineD3DDevice_GetRenderTarget failed, hr %#x\n", hr);
1486 }
1487 else if (!pRenderTarget)
1488 {
1489 *ppRenderTarget = NULL;
1490 }
1491 else
1492 {
1493 IWineD3DSurface_GetParent(pRenderTarget, (IUnknown **)ppRenderTarget);
1494 IWineD3DSurface_Release(pRenderTarget);
1495 }
1496
1497 wined3d_mutex_unlock();
1498
1499 ASSERT_D3D(hr == S_OK);
1500 return hr;
1501}
1502
1503static HRESULT WINAPI IDirect3DDevice9Impl_SetDepthStencilSurface(LPDIRECT3DDEVICE9EX iface, IDirect3DSurface9* pZStencilSurface) {
1504 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1505 IDirect3DSurface9Impl *pSurface;
1506 IDirect3DSurface9 *pOldSurface;
1507 HRESULT hr;
1508
1509 TRACE("iface %p, depth_stencil %p.\n", iface, pZStencilSurface);
1510
1511 pSurface = (IDirect3DSurface9Impl*)pZStencilSurface;
1512
1513 wined3d_mutex_lock();
1514 hr = IDirect3DDevice9_GetDepthStencilSurface(iface, &pOldSurface);
1515 if (D3D_OK==hr) {
1516 IDirect3DSurface9_Release(pOldSurface);
1517 IDirect3DSurface9_Release(pOldSurface);
1518 }
1519 hr = IWineD3DDevice_SetDepthStencilSurface(This->WineD3DDevice, NULL==pSurface ? NULL : pSurface->wineD3DSurface);
1520 if (pZStencilSurface) {
1521 IDirect3DSurface9_AddRef(pZStencilSurface);
1522 }
1523 wined3d_mutex_unlock();
1524
1525 ASSERT_D3D(hr == S_OK);
1526 return hr;
1527}
1528
1529static HRESULT WINAPI IDirect3DDevice9Impl_GetDepthStencilSurface(LPDIRECT3DDEVICE9EX iface, IDirect3DSurface9 **ppZStencilSurface) {
1530 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1531 HRESULT hr = D3D_OK;
1532 IWineD3DSurface *pZStencilSurface;
1533
1534 TRACE("iface %p, depth_stencil %p.\n", iface, ppZStencilSurface);
1535
1536 if(ppZStencilSurface == NULL){
1537 ERR_D3D();
1538 return D3DERR_INVALIDCALL;
1539 }
1540
1541 wined3d_mutex_lock();
1542 hr = IWineD3DDevice_GetDepthStencilSurface(This->WineD3DDevice,&pZStencilSurface);
1543 if (hr == WINED3D_OK) {
1544 IWineD3DSurface_GetParent(pZStencilSurface,(IUnknown**)ppZStencilSurface);
1545 IWineD3DSurface_Release(pZStencilSurface);
1546 } else {
1547 if (hr != WINED3DERR_NOTFOUND)
1548 WARN("Call to IWineD3DDevice_GetDepthStencilSurface failed with 0x%08x\n", hr);
1549 *ppZStencilSurface = NULL;
1550 }
1551 wined3d_mutex_unlock();
1552
1553 ASSERT_D3D(hr == S_OK || hr == WINED3DERR_NOTFOUND);
1554 return hr;
1555}
1556
1557static HRESULT WINAPI IDirect3DDevice9Impl_BeginScene(LPDIRECT3DDEVICE9EX iface) {
1558 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1559 HRESULT hr;
1560
1561 TRACE("iface %p.\n", iface);
1562
1563 wined3d_mutex_lock();
1564 hr = IWineD3DDevice_BeginScene(This->WineD3DDevice);
1565 wined3d_mutex_unlock();
1566
1567 ASSERT_D3D(hr == S_OK);
1568 return hr;
1569}
1570
1571static HRESULT WINAPI DECLSPEC_HOTPATCH IDirect3DDevice9Impl_EndScene(LPDIRECT3DDEVICE9EX iface) {
1572 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1573 HRESULT hr;
1574
1575 TRACE("iface %p.\n", iface);
1576
1577 wined3d_mutex_lock();
1578 hr = IWineD3DDevice_EndScene(This->WineD3DDevice);
1579 wined3d_mutex_unlock();
1580
1581 ASSERT_D3D(hr == S_OK);
1582 return hr;
1583}
1584
1585static HRESULT WINAPI IDirect3DDevice9Impl_Clear(LPDIRECT3DDEVICE9EX iface, DWORD Count, CONST D3DRECT* pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil) {
1586 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1587 HRESULT hr;
1588
1589 TRACE("iface %p, rect_count %u, rects %p, flags %#x, color 0x%08x, z %.8e, stencil %u.\n",
1590 iface, Count, pRects, Flags, Color, Z, Stencil);
1591
1592 /* Note: D3DRECT is compatible with WINED3DRECT */
1593 wined3d_mutex_lock();
1594 hr = IWineD3DDevice_Clear(This->WineD3DDevice, Count, (CONST WINED3DRECT*) pRects, Flags, Color, Z, Stencil);
1595 wined3d_mutex_unlock();
1596
1597 ASSERT_D3D(hr == S_OK);
1598 return hr;
1599}
1600
1601static HRESULT WINAPI IDirect3DDevice9Impl_SetTransform(LPDIRECT3DDEVICE9EX iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* lpMatrix) {
1602 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1603 HRESULT hr;
1604
1605 TRACE("iface %p, state %#x, matrix %p.\n", iface, State, lpMatrix);
1606
1607 /* Note: D3DMATRIX is compatible with WINED3DMATRIX */
1608 wined3d_mutex_lock();
1609 hr = IWineD3DDevice_SetTransform(This->WineD3DDevice, State, (CONST WINED3DMATRIX*) lpMatrix);
1610 wined3d_mutex_unlock();
1611
1612 return hr;
1613}
1614
1615static HRESULT WINAPI IDirect3DDevice9Impl_GetTransform(LPDIRECT3DDEVICE9EX iface, D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix) {
1616 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1617 HRESULT hr;
1618
1619 TRACE("iface %p, state %#x, matrix %p.\n", iface, State, pMatrix);
1620
1621 /* Note: D3DMATRIX is compatible with WINED3DMATRIX */
1622 wined3d_mutex_lock();
1623 hr = IWineD3DDevice_GetTransform(This->WineD3DDevice, State, (WINED3DMATRIX*) pMatrix);
1624 wined3d_mutex_unlock();
1625
1626 ASSERT_D3D(hr == S_OK);
1627 return hr;
1628}
1629
1630static HRESULT WINAPI IDirect3DDevice9Impl_MultiplyTransform(LPDIRECT3DDEVICE9EX iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix) {
1631 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1632 HRESULT hr;
1633
1634 TRACE("iface %p, state %#x, matrix %p.\n", iface, State, pMatrix);
1635
1636 /* Note: D3DMATRIX is compatible with WINED3DMATRIX */
1637 wined3d_mutex_lock();
1638 hr = IWineD3DDevice_MultiplyTransform(This->WineD3DDevice, State, (CONST WINED3DMATRIX*) pMatrix);
1639 wined3d_mutex_unlock();
1640
1641 ASSERT_D3D(hr == S_OK);
1642 return hr;
1643}
1644
1645static HRESULT WINAPI IDirect3DDevice9Impl_SetViewport(LPDIRECT3DDEVICE9EX iface, CONST D3DVIEWPORT9* pViewport) {
1646 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1647 HRESULT hr;
1648
1649 TRACE("iface %p, viewport %p.\n", iface, pViewport);
1650
1651 /* Note: D3DVIEWPORT9 is compatible with WINED3DVIEWPORT */
1652 wined3d_mutex_lock();
1653 hr = IWineD3DDevice_SetViewport(This->WineD3DDevice, (const WINED3DVIEWPORT *)pViewport);
1654 wined3d_mutex_unlock();
1655
1656 ASSERT_D3D(hr == S_OK);
1657
1658 return hr;
1659}
1660
1661static HRESULT WINAPI IDirect3DDevice9Impl_GetViewport(LPDIRECT3DDEVICE9EX iface, D3DVIEWPORT9* pViewport) {
1662 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1663 HRESULT hr;
1664
1665 TRACE("iface %p, viewport %p.\n", iface, pViewport);
1666
1667 /* Note: D3DVIEWPORT9 is compatible with WINED3DVIEWPORT */
1668 wined3d_mutex_lock();
1669 hr = IWineD3DDevice_GetViewport(This->WineD3DDevice, (WINED3DVIEWPORT *)pViewport);
1670 wined3d_mutex_unlock();
1671
1672 ASSERT_D3D(hr == S_OK);
1673 return hr;
1674}
1675
1676static HRESULT WINAPI IDirect3DDevice9Impl_SetMaterial(LPDIRECT3DDEVICE9EX iface, CONST D3DMATERIAL9* pMaterial) {
1677 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1678 HRESULT hr;
1679
1680 TRACE("iface %p, material %p.\n", iface, pMaterial);
1681
1682 /* Note: D3DMATERIAL9 is compatible with WINED3DMATERIAL */
1683 wined3d_mutex_lock();
1684 hr = IWineD3DDevice_SetMaterial(This->WineD3DDevice, (const WINED3DMATERIAL *)pMaterial);
1685 wined3d_mutex_unlock();
1686
1687 ASSERT_D3D(hr == S_OK);
1688 return hr;
1689}
1690
1691static HRESULT WINAPI IDirect3DDevice9Impl_GetMaterial(LPDIRECT3DDEVICE9EX iface, D3DMATERIAL9* pMaterial) {
1692 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1693 HRESULT hr;
1694
1695 TRACE("iface %p, material %p.\n", iface, pMaterial);
1696
1697 /* Note: D3DMATERIAL9 is compatible with WINED3DMATERIAL */
1698 wined3d_mutex_lock();
1699 hr = IWineD3DDevice_GetMaterial(This->WineD3DDevice, (WINED3DMATERIAL *)pMaterial);
1700 wined3d_mutex_unlock();
1701
1702 ASSERT_D3D(hr == S_OK);
1703 return hr;
1704}
1705
1706static HRESULT WINAPI IDirect3DDevice9Impl_SetLight(LPDIRECT3DDEVICE9EX iface, DWORD Index, CONST D3DLIGHT9* pLight) {
1707 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1708 HRESULT hr;
1709
1710 TRACE("iface %p, index %u, light %p.\n", iface, Index, pLight);
1711
1712 /* Note: D3DLIGHT9 is compatible with WINED3DLIGHT */
1713 wined3d_mutex_lock();
1714 hr = IWineD3DDevice_SetLight(This->WineD3DDevice, Index, (const WINED3DLIGHT *)pLight);
1715 wined3d_mutex_unlock();
1716
1717 ASSERT_D3D(hr == S_OK);
1718 return hr;
1719}
1720
1721static HRESULT WINAPI IDirect3DDevice9Impl_GetLight(LPDIRECT3DDEVICE9EX iface, DWORD Index, D3DLIGHT9* pLight) {
1722 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1723 HRESULT hr;
1724
1725 TRACE("iface %p, index %u, light %p.\n", iface, Index, pLight);
1726
1727 /* Note: D3DLIGHT9 is compatible with WINED3DLIGHT */
1728 wined3d_mutex_lock();
1729 hr = IWineD3DDevice_GetLight(This->WineD3DDevice, Index, (WINED3DLIGHT *)pLight);
1730 wined3d_mutex_unlock();
1731
1732 ASSERT_D3D(hr == S_OK);
1733 return hr;
1734}
1735
1736static HRESULT WINAPI IDirect3DDevice9Impl_LightEnable(LPDIRECT3DDEVICE9EX iface, DWORD Index, BOOL Enable) {
1737 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1738 HRESULT hr;
1739
1740 TRACE("iface %p, index %u, enable %#x.\n", iface, Index, Enable);
1741
1742 wined3d_mutex_lock();
1743 hr = IWineD3DDevice_SetLightEnable(This->WineD3DDevice, Index, Enable);
1744 wined3d_mutex_unlock();
1745
1746 ASSERT_D3D(hr == S_OK);
1747 return hr;
1748}
1749
1750static HRESULT WINAPI IDirect3DDevice9Impl_GetLightEnable(LPDIRECT3DDEVICE9EX iface, DWORD Index, BOOL* pEnable) {
1751 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1752 HRESULT hr;
1753
1754 TRACE("iface %p, index %u, enable %p.\n", iface, Index, pEnable);
1755
1756 wined3d_mutex_lock();
1757 hr = IWineD3DDevice_GetLightEnable(This->WineD3DDevice, Index, pEnable);
1758 wined3d_mutex_unlock();
1759
1760 ASSERT_D3D(hr == S_OK);
1761 return hr;
1762}
1763
1764static HRESULT WINAPI IDirect3DDevice9Impl_SetClipPlane(LPDIRECT3DDEVICE9EX iface, DWORD Index, CONST float* pPlane) {
1765 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1766 HRESULT hr;
1767
1768 TRACE("iface %p, index %u, plane %p.\n", iface, Index, pPlane);
1769
1770 wined3d_mutex_lock();
1771 hr = IWineD3DDevice_SetClipPlane(This->WineD3DDevice, Index, pPlane);
1772 wined3d_mutex_unlock();
1773
1774 ASSERT_D3D(hr == S_OK);
1775 return hr;
1776}
1777
1778static HRESULT WINAPI IDirect3DDevice9Impl_GetClipPlane(LPDIRECT3DDEVICE9EX iface, DWORD Index, float* pPlane) {
1779 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1780 HRESULT hr;
1781
1782 TRACE("iface %p, index %u, plane %p.\n", iface, Index, pPlane);
1783
1784 wined3d_mutex_lock();
1785 hr = IWineD3DDevice_GetClipPlane(This->WineD3DDevice, Index, pPlane);
1786 wined3d_mutex_unlock();
1787
1788 ASSERT_D3D(hr == S_OK);
1789 return hr;
1790}
1791
1792static HRESULT WINAPI DECLSPEC_HOTPATCH IDirect3DDevice9Impl_SetRenderState(LPDIRECT3DDEVICE9EX iface, D3DRENDERSTATETYPE State, DWORD Value) {
1793 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1794 HRESULT hr;
1795
1796 TRACE("iface %p, state %#x, value %#x.\n", iface, State, Value);
1797
1798 wined3d_mutex_lock();
1799 hr = IWineD3DDevice_SetRenderState(This->WineD3DDevice, State, Value);
1800 wined3d_mutex_unlock();
1801
1802 ASSERT_D3D(hr == S_OK);
1803 return hr;
1804}
1805
1806static HRESULT WINAPI IDirect3DDevice9Impl_GetRenderState(LPDIRECT3DDEVICE9EX iface, D3DRENDERSTATETYPE State, DWORD* pValue) {
1807 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1808 HRESULT hr;
1809
1810 TRACE("iface %p, state %#x, value %p.\n", iface, State, pValue);
1811
1812 wined3d_mutex_lock();
1813 hr = IWineD3DDevice_GetRenderState(This->WineD3DDevice, State, pValue);
1814 wined3d_mutex_unlock();
1815
1816 ASSERT_D3D(hr == S_OK);
1817 return hr;
1818}
1819
1820static HRESULT WINAPI IDirect3DDevice9Impl_CreateStateBlock(IDirect3DDevice9Ex *iface,
1821 D3DSTATEBLOCKTYPE type, IDirect3DStateBlock9 **stateblock)
1822{
1823 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1824 IDirect3DStateBlock9Impl *object;
1825 HRESULT hr;
1826
1827 TRACE("iface %p, type %#x, stateblock %p.\n", iface, type, stateblock);
1828
1829 if (type != D3DSBT_ALL && type != D3DSBT_PIXELSTATE && type != D3DSBT_VERTEXSTATE)
1830 {
1831 ERR_D3D();
1832 WARN("Unexpected stateblock type, returning D3DERR_INVALIDCALL.\n");
1833 return D3DERR_INVALIDCALL;
1834 }
1835
1836 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1837 if (!object)
1838 {
1839 ERR_D3D();
1840 ERR("Failed to allocate stateblock memory.\n");
1841 return E_OUTOFMEMORY;
1842 }
1843
1844 hr = stateblock_init(object, This, type, NULL);
1845 if (FAILED(hr))
1846 {
1847 ERR_D3D();
1848 WARN("Failed to initialize stateblock, hr %#x.\n", hr);
1849 HeapFree(GetProcessHeap(), 0, object);
1850 return hr;
1851 }
1852
1853 TRACE("Created stateblock %p.\n", object);
1854 *stateblock = (IDirect3DStateBlock9 *)object;
1855
1856 return D3D_OK;
1857}
1858
1859static HRESULT WINAPI IDirect3DDevice9Impl_BeginStateBlock(IDirect3DDevice9Ex *iface)
1860{
1861 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1862 HRESULT hr;
1863
1864 TRACE("iface %p.\n", iface);
1865
1866 wined3d_mutex_lock();
1867 hr = IWineD3DDevice_BeginStateBlock(This->WineD3DDevice);
1868 wined3d_mutex_unlock();
1869
1870 ASSERT_D3D(hr == S_OK);
1871 return hr;
1872}
1873
1874static HRESULT WINAPI IDirect3DDevice9Impl_EndStateBlock(IDirect3DDevice9Ex *iface, IDirect3DStateBlock9 **stateblock)
1875{
1876 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1877 IWineD3DStateBlock *wined3d_stateblock;
1878 IDirect3DStateBlock9Impl *object;
1879 HRESULT hr;
1880
1881 TRACE("iface %p, stateblock %p.\n", iface, stateblock);
1882
1883 wined3d_mutex_lock();
1884 hr = IWineD3DDevice_EndStateBlock(This->WineD3DDevice, &wined3d_stateblock);
1885 wined3d_mutex_unlock();
1886 if (FAILED(hr))
1887 {
1888 ERR_D3D();
1889 WARN("IWineD3DDevice_EndStateBlock() failed, hr %#x.\n", hr);
1890 return hr;
1891 }
1892
1893 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1894 if (!object)
1895 {
1896 ERR_D3D();
1897 ERR("Failed to allocate stateblock memory.\n");
1898 IWineD3DStateBlock_Release(wined3d_stateblock);
1899 return E_OUTOFMEMORY;
1900 }
1901
1902 hr = stateblock_init(object, This, 0, wined3d_stateblock);
1903 if (FAILED(hr))
1904 {
1905 ERR_D3D();
1906 WARN("Failed to initialize stateblock, hr %#x.\n", hr);
1907 IWineD3DStateBlock_Release(wined3d_stateblock);
1908 HeapFree(GetProcessHeap(), 0, object);
1909 return hr;
1910 }
1911
1912 TRACE("Created stateblock %p.\n", object);
1913 *stateblock = (IDirect3DStateBlock9 *)object;
1914
1915 return D3D_OK;
1916}
1917
1918static HRESULT WINAPI IDirect3DDevice9Impl_SetClipStatus(LPDIRECT3DDEVICE9EX iface, CONST D3DCLIPSTATUS9* pClipStatus) {
1919 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1920 HRESULT hr;
1921
1922 TRACE("iface %p, clip_status %p.\n", iface, pClipStatus);
1923
1924 wined3d_mutex_lock();
1925 hr = IWineD3DDevice_SetClipStatus(This->WineD3DDevice, (const WINED3DCLIPSTATUS *)pClipStatus);
1926 wined3d_mutex_unlock();
1927
1928 ASSERT_D3D(hr == S_OK);
1929 return hr;
1930}
1931
1932static HRESULT WINAPI IDirect3DDevice9Impl_GetClipStatus(LPDIRECT3DDEVICE9EX iface, D3DCLIPSTATUS9* pClipStatus) {
1933 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1934 HRESULT hr;
1935
1936 TRACE("iface %p, clip_status %p.\n", iface, pClipStatus);
1937
1938 wined3d_mutex_lock();
1939 hr = IWineD3DDevice_GetClipStatus(This->WineD3DDevice, (WINED3DCLIPSTATUS *)pClipStatus);
1940 wined3d_mutex_unlock();
1941
1942
1943 ASSERT_D3D(hr == S_OK);
1944 return hr;
1945}
1946
1947static HRESULT WINAPI IDirect3DDevice9Impl_GetTexture(LPDIRECT3DDEVICE9EX iface, DWORD Stage, IDirect3DBaseTexture9 **ppTexture) {
1948 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1949 IWineD3DBaseTexture *retTexture = NULL;
1950 HRESULT rc = D3D_OK;
1951
1952 TRACE("iface %p, stage %u, texture %p.\n", iface, Stage, ppTexture);
1953
1954 if(ppTexture == NULL){
1955 ERR_D3D();
1956 return D3DERR_INVALIDCALL;
1957 }
1958
1959 wined3d_mutex_lock();
1960 rc = IWineD3DDevice_GetTexture(This->WineD3DDevice, Stage, &retTexture);
1961 if (SUCCEEDED(rc) && NULL != retTexture) {
1962 IWineD3DBaseTexture_GetParent(retTexture, (IUnknown **)ppTexture);
1963 IWineD3DBaseTexture_Release(retTexture);
1964 } else {
1965 if(FAILED(rc)) {
1966 WARN("Call to get texture (%d) failed (%p)\n", Stage, retTexture);
1967 }
1968 *ppTexture = NULL;
1969 }
1970 wined3d_mutex_unlock();
1971
1972 ASSERT_D3D(rc == S_OK);
1973 return rc;
1974}
1975
1976static HRESULT WINAPI IDirect3DDevice9Impl_SetTexture(LPDIRECT3DDEVICE9EX iface, DWORD Stage, IDirect3DBaseTexture9* pTexture) {
1977 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
1978 HRESULT hr;
1979
1980 TRACE("iface %p, stage %u, texture %p.\n", iface, Stage, pTexture);
1981
1982 wined3d_mutex_lock();
1983 hr = IWineD3DDevice_SetTexture(This->WineD3DDevice, Stage,
1984 pTexture==NULL ? NULL:((IDirect3DBaseTexture9Impl *)pTexture)->wineD3DBaseTexture);
1985 wined3d_mutex_unlock();
1986
1987 ASSERT_D3D(hr == S_OK);
1988 return hr;
1989}
1990
1991static const WINED3DTEXTURESTAGESTATETYPE tss_lookup[] =
1992{
1993 WINED3DTSS_FORCE_DWORD, /* 0, unused */
1994 WINED3DTSS_COLOROP, /* 1, D3DTSS_COLOROP */
1995 WINED3DTSS_COLORARG1, /* 2, D3DTSS_COLORARG1 */
1996 WINED3DTSS_COLORARG2, /* 3, D3DTSS_COLORARG2 */
1997 WINED3DTSS_ALPHAOP, /* 4, D3DTSS_ALPHAOP */
1998 WINED3DTSS_ALPHAARG1, /* 5, D3DTSS_ALPHAARG1 */
1999 WINED3DTSS_ALPHAARG2, /* 6, D3DTSS_ALPHAARG2 */
2000 WINED3DTSS_BUMPENVMAT00, /* 7, D3DTSS_BUMPENVMAT00 */
2001 WINED3DTSS_BUMPENVMAT01, /* 8, D3DTSS_BUMPENVMAT01 */
2002 WINED3DTSS_BUMPENVMAT10, /* 9, D3DTSS_BUMPENVMAT10 */
2003 WINED3DTSS_BUMPENVMAT11, /* 10, D3DTSS_BUMPENVMAT11 */
2004 WINED3DTSS_TEXCOORDINDEX, /* 11, D3DTSS_TEXCOORDINDEX */
2005 WINED3DTSS_FORCE_DWORD, /* 12, unused */
2006 WINED3DTSS_FORCE_DWORD, /* 13, unused */
2007 WINED3DTSS_FORCE_DWORD, /* 14, unused */
2008 WINED3DTSS_FORCE_DWORD, /* 15, unused */
2009 WINED3DTSS_FORCE_DWORD, /* 16, unused */
2010 WINED3DTSS_FORCE_DWORD, /* 17, unused */
2011 WINED3DTSS_FORCE_DWORD, /* 18, unused */
2012 WINED3DTSS_FORCE_DWORD, /* 19, unused */
2013 WINED3DTSS_FORCE_DWORD, /* 20, unused */
2014 WINED3DTSS_FORCE_DWORD, /* 21, unused */
2015 WINED3DTSS_BUMPENVLSCALE, /* 22, D3DTSS_BUMPENVLSCALE */
2016 WINED3DTSS_BUMPENVLOFFSET, /* 23, D3DTSS_BUMPENVLOFFSET */
2017 WINED3DTSS_TEXTURETRANSFORMFLAGS, /* 24, D3DTSS_TEXTURETRANSFORMFLAGS */
2018 WINED3DTSS_FORCE_DWORD, /* 25, unused */
2019 WINED3DTSS_COLORARG0, /* 26, D3DTSS_COLORARG0 */
2020 WINED3DTSS_ALPHAARG0, /* 27, D3DTSS_ALPHAARG0 */
2021 WINED3DTSS_RESULTARG, /* 28, D3DTSS_RESULTARG */
2022 WINED3DTSS_FORCE_DWORD, /* 29, unused */
2023 WINED3DTSS_FORCE_DWORD, /* 30, unused */
2024 WINED3DTSS_FORCE_DWORD, /* 31, unused */
2025 WINED3DTSS_CONSTANT, /* 32, D3DTSS_CONSTANT */
2026};
2027
2028static HRESULT WINAPI IDirect3DDevice9Impl_GetTextureStageState(LPDIRECT3DDEVICE9EX iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD* pValue) {
2029 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2030 HRESULT hr;
2031
2032 TRACE("iface %p, stage %u, state %#x, value %p.\n", iface, Stage, Type, pValue);
2033
2034 wined3d_mutex_lock();
2035 hr = IWineD3DDevice_GetTextureStageState(This->WineD3DDevice, Stage, tss_lookup[Type], pValue);
2036 wined3d_mutex_unlock();
2037
2038 ASSERT_D3D(hr == S_OK);
2039 return hr;
2040}
2041
2042static HRESULT WINAPI IDirect3DDevice9Impl_SetTextureStageState(LPDIRECT3DDEVICE9EX iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value) {
2043 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2044 HRESULT hr;
2045
2046 TRACE("iface %p, stage %u, state %#x, value %#x.\n", iface, Stage, Type, Value);
2047
2048 wined3d_mutex_lock();
2049 hr = IWineD3DDevice_SetTextureStageState(This->WineD3DDevice, Stage, tss_lookup[Type], Value);
2050 wined3d_mutex_unlock();
2051
2052 ASSERT_D3D(hr == S_OK);
2053 return hr;
2054}
2055
2056static HRESULT WINAPI IDirect3DDevice9Impl_GetSamplerState(IDirect3DDevice9Ex *iface, DWORD Sampler,
2057 D3DSAMPLERSTATETYPE Type, DWORD *pValue)
2058{
2059 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2060 HRESULT hr;
2061
2062 TRACE("iface %p, sampler %u, state %#x, value %p.\n", iface, Sampler, Type, pValue);
2063
2064 wined3d_mutex_lock();
2065 hr = IWineD3DDevice_GetSamplerState(This->WineD3DDevice, Sampler, Type, pValue);
2066 wined3d_mutex_unlock();
2067
2068 ASSERT_D3D(hr == S_OK);
2069 return hr;
2070}
2071
2072static HRESULT WINAPI DECLSPEC_HOTPATCH IDirect3DDevice9Impl_SetSamplerState(LPDIRECT3DDEVICE9EX iface, DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value) {
2073 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2074 HRESULT hr;
2075
2076 TRACE("iface %p, sampler %u, state %#x, value %#x.\n", iface, Sampler, Type, Value);
2077
2078 wined3d_mutex_lock();
2079 hr = IWineD3DDevice_SetSamplerState(This->WineD3DDevice, Sampler, Type, Value);
2080 wined3d_mutex_unlock();
2081
2082 ASSERT_D3D(hr == S_OK);
2083 return hr;
2084}
2085
2086static HRESULT WINAPI IDirect3DDevice9Impl_ValidateDevice(LPDIRECT3DDEVICE9EX iface, DWORD* pNumPasses) {
2087 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2088 HRESULT hr;
2089
2090 TRACE("iface %p, pass_count %p.\n", iface, pNumPasses);
2091
2092 wined3d_mutex_lock();
2093 hr = IWineD3DDevice_ValidateDevice(This->WineD3DDevice, pNumPasses);
2094 wined3d_mutex_unlock();
2095
2096 ASSERT_D3D(hr == S_OK);
2097 return hr;
2098}
2099
2100static HRESULT WINAPI IDirect3DDevice9Impl_SetPaletteEntries(IDirect3DDevice9Ex *iface, UINT PaletteNumber,
2101 const PALETTEENTRY *pEntries)
2102{
2103 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2104 HRESULT hr;
2105
2106 TRACE("iface %p, palette_idx %u, entries %p.\n", iface, PaletteNumber, pEntries);
2107
2108 wined3d_mutex_lock();
2109 hr = IWineD3DDevice_SetPaletteEntries(This->WineD3DDevice, PaletteNumber, pEntries);
2110 wined3d_mutex_unlock();
2111
2112 ASSERT_D3D(hr == S_OK);
2113 return hr;
2114}
2115
2116static HRESULT WINAPI IDirect3DDevice9Impl_GetPaletteEntries(LPDIRECT3DDEVICE9EX iface, UINT PaletteNumber, PALETTEENTRY* pEntries) {
2117 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2118 HRESULT hr;
2119
2120 TRACE("iface %p, palette_idx %u, entries %p.\n", iface, PaletteNumber, pEntries);
2121
2122 wined3d_mutex_lock();
2123 hr = IWineD3DDevice_GetPaletteEntries(This->WineD3DDevice, PaletteNumber, pEntries);
2124 wined3d_mutex_unlock();
2125
2126 ASSERT_D3D(hr == S_OK);
2127 return hr;
2128}
2129
2130static HRESULT WINAPI IDirect3DDevice9Impl_SetCurrentTexturePalette(LPDIRECT3DDEVICE9EX iface, UINT PaletteNumber) {
2131 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2132 HRESULT hr;
2133
2134 TRACE("iface %p, palette_idx %u.\n", iface, PaletteNumber);
2135
2136 wined3d_mutex_lock();
2137 hr = IWineD3DDevice_SetCurrentTexturePalette(This->WineD3DDevice, PaletteNumber);
2138 wined3d_mutex_unlock();
2139
2140 ASSERT_D3D(hr == S_OK);
2141 return hr;
2142}
2143
2144static HRESULT WINAPI IDirect3DDevice9Impl_GetCurrentTexturePalette(LPDIRECT3DDEVICE9EX iface, UINT* PaletteNumber) {
2145 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2146 HRESULT hr;
2147
2148 TRACE("iface %p, palette_idx %p.\n", iface, PaletteNumber);
2149
2150 wined3d_mutex_lock();
2151 hr = IWineD3DDevice_GetCurrentTexturePalette(This->WineD3DDevice, PaletteNumber);
2152 wined3d_mutex_unlock();
2153
2154 ASSERT_D3D(hr == S_OK);
2155 return hr;
2156}
2157
2158static HRESULT WINAPI IDirect3DDevice9Impl_SetScissorRect(LPDIRECT3DDEVICE9EX iface, CONST RECT* pRect) {
2159 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2160 HRESULT hr;
2161
2162 TRACE("iface %p, rect %p.\n", iface, pRect);
2163
2164 wined3d_mutex_lock();
2165 hr = IWineD3DDevice_SetScissorRect(This->WineD3DDevice, pRect);
2166 wined3d_mutex_unlock();
2167
2168 ASSERT_D3D(hr == S_OK);
2169 return hr;
2170}
2171
2172static HRESULT WINAPI IDirect3DDevice9Impl_GetScissorRect(LPDIRECT3DDEVICE9EX iface, RECT* pRect) {
2173 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2174 HRESULT hr;
2175
2176 TRACE("iface %p, rect %p.\n", iface, pRect);
2177
2178 wined3d_mutex_lock();
2179 hr = IWineD3DDevice_GetScissorRect(This->WineD3DDevice, pRect);
2180 wined3d_mutex_unlock();
2181
2182 ASSERT_D3D(hr == S_OK);
2183 return hr;
2184}
2185
2186static HRESULT WINAPI IDirect3DDevice9Impl_SetSoftwareVertexProcessing(LPDIRECT3DDEVICE9EX iface, BOOL bSoftware) {
2187 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2188 HRESULT hr;
2189
2190 TRACE("iface %p, software %#x.\n", iface, bSoftware);
2191
2192 wined3d_mutex_lock();
2193 hr = IWineD3DDevice_SetSoftwareVertexProcessing(This->WineD3DDevice, bSoftware);
2194 wined3d_mutex_unlock();
2195
2196 ASSERT_D3D(hr == S_OK);
2197 return hr;
2198}
2199
2200static BOOL WINAPI IDirect3DDevice9Impl_GetSoftwareVertexProcessing(LPDIRECT3DDEVICE9EX iface) {
2201 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2202 BOOL ret;
2203
2204 TRACE("iface %p.\n", iface);
2205
2206 wined3d_mutex_lock();
2207 ret = IWineD3DDevice_GetSoftwareVertexProcessing(This->WineD3DDevice);
2208 wined3d_mutex_unlock();
2209
2210 return ret;
2211}
2212
2213static HRESULT WINAPI IDirect3DDevice9Impl_SetNPatchMode(LPDIRECT3DDEVICE9EX iface, float nSegments) {
2214 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2215 HRESULT hr;
2216
2217 TRACE("iface %p, segment_count %.8e.\n", iface, nSegments);
2218
2219 wined3d_mutex_lock();
2220 hr = IWineD3DDevice_SetNPatchMode(This->WineD3DDevice, nSegments);
2221 wined3d_mutex_unlock();
2222
2223 ASSERT_D3D(hr == S_OK);
2224 return hr;
2225}
2226
2227static float WINAPI IDirect3DDevice9Impl_GetNPatchMode(LPDIRECT3DDEVICE9EX iface) {
2228 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2229 float ret;
2230
2231 TRACE("iface %p.\n", iface);
2232
2233 wined3d_mutex_lock();
2234 ret = IWineD3DDevice_GetNPatchMode(This->WineD3DDevice);
2235 wined3d_mutex_unlock();
2236
2237 return ret;
2238}
2239
2240static HRESULT WINAPI IDirect3DDevice9Impl_DrawPrimitive(IDirect3DDevice9Ex *iface, D3DPRIMITIVETYPE PrimitiveType,
2241 UINT StartVertex, UINT PrimitiveCount)
2242{
2243 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2244 HRESULT hr;
2245
2246 TRACE("iface %p, primitive_type %#x, start_vertex %u, primitive_count %u.\n",
2247 iface, PrimitiveType, StartVertex, PrimitiveCount);
2248
2249 wined3d_mutex_lock();
2250 IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
2251 hr = IWineD3DDevice_DrawPrimitive(This->WineD3DDevice, StartVertex,
2252 vertex_count_from_primitive_count(PrimitiveType, PrimitiveCount));
2253 wined3d_mutex_unlock();
2254
2255 ASSERT_D3D(hr == S_OK);
2256 return hr;
2257}
2258
2259static HRESULT WINAPI IDirect3DDevice9Impl_DrawIndexedPrimitive(LPDIRECT3DDEVICE9EX iface, D3DPRIMITIVETYPE PrimitiveType,
2260 INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount) {
2261 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2262 HRESULT hr;
2263
2264 TRACE("iface %p, primitive_type %#x, base_vertex_idx %u, min_vertex_idx %u,\n"
2265 "vertex_count %u, start_idx %u, primitive_count %u.\n",
2266 iface, PrimitiveType, BaseVertexIndex, MinVertexIndex,
2267 NumVertices, startIndex, primCount);
2268
2269 wined3d_mutex_lock();
2270 IWineD3DDevice_SetBaseVertexIndex(This->WineD3DDevice, BaseVertexIndex);
2271 IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
2272 hr = IWineD3DDevice_DrawIndexedPrimitive(This->WineD3DDevice, startIndex,
2273 vertex_count_from_primitive_count(PrimitiveType, primCount));
2274 wined3d_mutex_unlock();
2275
2276 ASSERT_D3D(hr == S_OK);
2277 return hr;
2278}
2279
2280static HRESULT WINAPI IDirect3DDevice9Impl_DrawPrimitiveUP(IDirect3DDevice9Ex *iface, D3DPRIMITIVETYPE PrimitiveType,
2281 UINT PrimitiveCount, const void *pVertexStreamZeroData, UINT VertexStreamZeroStride)
2282{
2283 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2284 HRESULT hr;
2285
2286 TRACE("iface %p, primitive_type %#x, primitive_count %u, data %p, stride %u.\n",
2287 iface, PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
2288
2289 wined3d_mutex_lock();
2290 IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
2291 hr = IWineD3DDevice_DrawPrimitiveUP(This->WineD3DDevice,
2292 vertex_count_from_primitive_count(PrimitiveType, PrimitiveCount),
2293 pVertexStreamZeroData, VertexStreamZeroStride);
2294 wined3d_mutex_unlock();
2295
2296 ASSERT_D3D(hr == S_OK);
2297 return hr;
2298}
2299
2300static HRESULT WINAPI IDirect3DDevice9Impl_DrawIndexedPrimitiveUP(LPDIRECT3DDEVICE9EX iface, D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex,
2301 UINT NumVertexIndices, UINT PrimitiveCount, CONST void* pIndexData,
2302 D3DFORMAT IndexDataFormat, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) {
2303 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2304 HRESULT hr;
2305
2306 TRACE("iface %p, primitive_type %#x, min_vertex_idx %u, index_count %u, primitive_count %u,\n"
2307 "index_data %p, index_format %#x, vertex_data %p, vertex_stride %u.\n",
2308 iface, PrimitiveType, MinVertexIndex, NumVertexIndices, PrimitiveCount,
2309 pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride);
2310
2311 wined3d_mutex_lock();
2312 IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
2313 hr = IWineD3DDevice_DrawIndexedPrimitiveUP(This->WineD3DDevice,
2314 vertex_count_from_primitive_count(PrimitiveType, PrimitiveCount), pIndexData,
2315 wined3dformat_from_d3dformat(IndexDataFormat), pVertexStreamZeroData, VertexStreamZeroStride);
2316 wined3d_mutex_unlock();
2317
2318 ASSERT_D3D(hr == S_OK);
2319 return hr;
2320}
2321
2322static HRESULT WINAPI IDirect3DDevice9Impl_ProcessVertices(LPDIRECT3DDEVICE9EX iface, UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IDirect3DVertexBuffer9* pDestBuffer, IDirect3DVertexDeclaration9* pVertexDecl, DWORD Flags) {
2323 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2324 IDirect3DVertexDeclaration9Impl *Decl = (IDirect3DVertexDeclaration9Impl *) pVertexDecl;
2325 HRESULT hr;
2326 IDirect3DVertexBuffer9Impl *dest = (IDirect3DVertexBuffer9Impl *) pDestBuffer;
2327
2328 TRACE("iface %p, src_start_idx %u, dst_idx %u, vertex_count %u, dst_buffer %p, declaration %p, flags %#x.\n",
2329 iface, SrcStartIndex, DestIndex, VertexCount, pDestBuffer, pVertexDecl, Flags);
2330
2331 wined3d_mutex_lock();
2332 hr = IWineD3DDevice_ProcessVertices(This->WineD3DDevice,SrcStartIndex, DestIndex, VertexCount, dest->wineD3DVertexBuffer, Decl ? Decl->wineD3DVertexDeclaration : NULL, Flags, dest->fvf);
2333 wined3d_mutex_unlock();
2334
2335 ASSERT_D3D(hr == S_OK);
2336 return hr;
2337}
2338
2339static HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexDeclaration(IDirect3DDevice9Ex *iface,
2340 const D3DVERTEXELEMENT9 *elements, IDirect3DVertexDeclaration9 **declaration)
2341{
2342 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2343 IDirect3DVertexDeclaration9Impl *object;
2344 HRESULT hr;
2345
2346 TRACE("iface %p, elements %p, declaration %p.\n", iface, elements, declaration);
2347
2348 if (!declaration)
2349 {
2350 ERR_D3D();
2351 WARN("Caller passed a NULL declaration, returning D3DERR_INVALIDCALL.\n");
2352 return D3DERR_INVALIDCALL;
2353 }
2354
2355 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2356 if (!object)
2357 {
2358 ERR_D3D();
2359 ERR("Failed to allocate vertex declaration memory.\n");
2360 return E_OUTOFMEMORY;
2361 }
2362
2363 hr = vertexdeclaration_init(object, This, elements);
2364 if (FAILED(hr))
2365 {
2366 ERR_D3D();
2367 WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
2368 HeapFree(GetProcessHeap(), 0, object);
2369 return hr;
2370 }
2371
2372 TRACE("Created vertex declaration %p.\n", object);
2373 *declaration = (IDirect3DVertexDeclaration9 *)object;
2374
2375 return D3D_OK;
2376}
2377
2378static IDirect3DVertexDeclaration9 *getConvertedDecl(IDirect3DDevice9Impl *This, DWORD fvf) {
2379 HRESULT hr;
2380 D3DVERTEXELEMENT9* elements = NULL;
2381 IDirect3DVertexDeclaration9* pDecl = NULL;
2382 int p, low, high; /* deliberately signed */
2383 IDirect3DVertexDeclaration9 **convertedDecls = This->convertedDecls;
2384
2385 TRACE("Searching for declaration for fvf %08x... ", fvf);
2386
2387 low = 0;
2388 high = This->numConvertedDecls - 1;
2389 while(low <= high) {
2390 p = (low + high) >> 1;
2391 TRACE("%d ", p);
2392 if(((IDirect3DVertexDeclaration9Impl *) convertedDecls[p])->convFVF == fvf) {
2393 TRACE("found %p\n", convertedDecls[p]);
2394 return convertedDecls[p];
2395 } else if(((IDirect3DVertexDeclaration9Impl *) convertedDecls[p])->convFVF < fvf) {
2396 low = p + 1;
2397 } else {
2398 high = p - 1;
2399 }
2400 }
2401 TRACE("not found. Creating and inserting at position %d.\n", low);
2402
2403 hr = vdecl_convert_fvf(fvf, &elements);
2404 if (hr != S_OK) return NULL;
2405
2406 hr = IDirect3DDevice9Impl_CreateVertexDeclaration((IDirect3DDevice9Ex *) This, elements, &pDecl);
2407 HeapFree(GetProcessHeap(), 0, elements); /* CreateVertexDeclaration makes a copy */
2408 if (hr != S_OK) return NULL;
2409
2410 if(This->declArraySize == This->numConvertedDecls) {
2411 int grow = max(This->declArraySize / 2, 8);
2412 convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls,
2413 sizeof(convertedDecls[0]) * (This->numConvertedDecls + grow));
2414 if(!convertedDecls) {
2415 /* This will destroy it */
2416 IDirect3DVertexDeclaration9_Release(pDecl);
2417 return NULL;
2418 }
2419 This->convertedDecls = convertedDecls;
2420 This->declArraySize += grow;
2421 }
2422
2423 memmove(convertedDecls + low + 1, convertedDecls + low, sizeof(IDirect3DVertexDeclaration9Impl *) * (This->numConvertedDecls - low));
2424 convertedDecls[low] = pDecl;
2425 This->numConvertedDecls++;
2426
2427 /* Will prevent the decl from being destroyed */
2428 ((IDirect3DVertexDeclaration9Impl *) pDecl)->convFVF = fvf;
2429 IDirect3DVertexDeclaration9_Release(pDecl); /* Does not destroy now */
2430
2431 TRACE("Returning %p. %d decls in array\n", pDecl, This->numConvertedDecls);
2432 return pDecl;
2433}
2434
2435static HRESULT WINAPI IDirect3DDevice9Impl_SetFVF(LPDIRECT3DDEVICE9EX iface, DWORD FVF) {
2436 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2437 IDirect3DVertexDeclaration9 *decl;
2438 HRESULT hr;
2439
2440 TRACE("iface %p, fvf %#x.\n", iface, FVF);
2441
2442 if (!FVF)
2443 {
2444 WARN("%#x is not a valid FVF\n", FVF);
2445 return D3D_OK;
2446 }
2447
2448 wined3d_mutex_lock();
2449 decl = getConvertedDecl(This, FVF);
2450 wined3d_mutex_unlock();
2451
2452 if (!decl)
2453 {
2454 ERR_D3D();
2455 /* Any situation when this should happen, except out of memory? */
2456 ERR("Failed to create a converted vertex declaration\n");
2457 return D3DERR_DRIVERINTERNALERROR;
2458 }
2459
2460 hr = IDirect3DDevice9Impl_SetVertexDeclaration(iface, decl);
2461 if (FAILED(hr)) ERR("Failed to set vertex declaration\n");
2462
2463 ASSERT_D3D(hr == S_OK);
2464 return hr;
2465}
2466
2467static HRESULT WINAPI IDirect3DDevice9Impl_GetFVF(IDirect3DDevice9Ex *iface, DWORD *pFVF)
2468{
2469 IDirect3DVertexDeclaration9 *decl;
2470 HRESULT hr;
2471
2472 TRACE("iface %p, fvf %p.\n", iface, pFVF);
2473
2474 hr = IDirect3DDevice9_GetVertexDeclaration(iface, &decl);
2475 if (FAILED(hr))
2476 {
2477 ERR_D3D();
2478 WARN("Failed to get vertex declaration, %#x\n", hr);
2479 *pFVF = 0;
2480 return hr;
2481 }
2482
2483 if (decl)
2484 {
2485 *pFVF = ((IDirect3DVertexDeclaration9Impl *)decl)->convFVF;
2486 IDirect3DVertexDeclaration9_Release(decl);
2487 }
2488 else
2489 {
2490 *pFVF = 0;
2491 }
2492
2493 TRACE("Returning FVF %#x\n", *pFVF);
2494
2495 ASSERT_D3D(hr == S_OK);
2496 return hr;
2497}
2498
2499static HRESULT WINAPI IDirect3DDevice9Impl_CreateVertexShader(IDirect3DDevice9Ex *iface,
2500 const DWORD *byte_code, IDirect3DVertexShader9 **shader)
2501{
2502 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2503 IDirect3DVertexShader9Impl *object;
2504 HRESULT hr;
2505
2506 TRACE("iface %p, byte_code %p, shader %p.\n", iface, byte_code, shader);
2507
2508 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2509 if (!object)
2510 {
2511 ERR_D3D();
2512 ERR("Failed to allocate vertex shader memory.\n");
2513 return E_OUTOFMEMORY;
2514 }
2515
2516 hr = vertexshader_init(object, This, byte_code);
2517 if (FAILED(hr))
2518 {
2519 ERR_D3D();
2520 WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
2521 HeapFree(GetProcessHeap(), 0, object);
2522 return hr;
2523 }
2524
2525 TRACE("Created vertex shader %p.\n", object);
2526 *shader = (IDirect3DVertexShader9 *)object;
2527
2528 return D3D_OK;
2529}
2530
2531static HRESULT WINAPI IDirect3DDevice9Impl_SetStreamSource(LPDIRECT3DDEVICE9EX iface, UINT StreamNumber, IDirect3DVertexBuffer9* pStreamData, UINT OffsetInBytes, UINT Stride) {
2532 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2533 HRESULT hr;
2534
2535 TRACE("iface %p, stream_idx %u, buffer %p, offset %u, stride %u.\n",
2536 iface, StreamNumber, pStreamData, OffsetInBytes, Stride);
2537
2538 wined3d_mutex_lock();
2539 hr = IWineD3DDevice_SetStreamSource(This->WineD3DDevice, StreamNumber,
2540 pStreamData ? ((IDirect3DVertexBuffer9Impl *)pStreamData)->wineD3DVertexBuffer : NULL,
2541 OffsetInBytes, Stride);
2542 wined3d_mutex_unlock();
2543
2544 ASSERT_D3D(hr == S_OK);
2545 return hr;
2546}
2547
2548static HRESULT WINAPI IDirect3DDevice9Impl_GetStreamSource(LPDIRECT3DDEVICE9EX iface, UINT StreamNumber, IDirect3DVertexBuffer9 **pStream, UINT* OffsetInBytes, UINT* pStride) {
2549 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2550 IWineD3DBuffer *retStream = NULL;
2551 HRESULT rc = D3D_OK;
2552
2553 TRACE("iface %p, stream_idx %u, buffer %p, offset %p, stride %p.\n",
2554 iface, StreamNumber, pStream, OffsetInBytes, pStride);
2555
2556 if(pStream == NULL){
2557 ERR_D3D();
2558 return D3DERR_INVALIDCALL;
2559 }
2560
2561 wined3d_mutex_lock();
2562 rc = IWineD3DDevice_GetStreamSource(This->WineD3DDevice, StreamNumber, &retStream, OffsetInBytes, pStride);
2563 if (rc == D3D_OK && NULL != retStream) {
2564 IWineD3DBuffer_GetParent(retStream, (IUnknown **)pStream);
2565 IWineD3DBuffer_Release(retStream);
2566 }else{
2567 if (rc != D3D_OK){
2568 FIXME("Call to GetStreamSource failed %p %p\n", OffsetInBytes, pStride);
2569 }
2570 *pStream = NULL;
2571 }
2572 wined3d_mutex_unlock();
2573
2574 ASSERT_D3D(rc == S_OK);
2575 return rc;
2576}
2577
2578static HRESULT WINAPI IDirect3DDevice9Impl_SetStreamSourceFreq(IDirect3DDevice9Ex *iface, UINT StreamNumber,
2579 UINT Divider)
2580{
2581 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2582 HRESULT hr;
2583
2584 TRACE("iface %p, stream_idx %u, freq %u.\n", iface, StreamNumber, Divider);
2585
2586 wined3d_mutex_lock();
2587 hr = IWineD3DDevice_SetStreamSourceFreq(This->WineD3DDevice, StreamNumber, Divider);
2588 wined3d_mutex_unlock();
2589
2590 ASSERT_D3D(hr == S_OK);
2591 return hr;
2592}
2593
2594static HRESULT WINAPI IDirect3DDevice9Impl_GetStreamSourceFreq(LPDIRECT3DDEVICE9EX iface, UINT StreamNumber, UINT* Divider) {
2595 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2596 HRESULT hr;
2597
2598 TRACE("iface %p, stream_idx %u, freq %p.\n", iface, StreamNumber, Divider);
2599
2600 wined3d_mutex_lock();
2601 hr = IWineD3DDevice_GetStreamSourceFreq(This->WineD3DDevice, StreamNumber, Divider);
2602 wined3d_mutex_unlock();
2603
2604 ASSERT_D3D(hr == S_OK);
2605 return hr;
2606}
2607
2608static HRESULT WINAPI IDirect3DDevice9Impl_SetIndices(LPDIRECT3DDEVICE9EX iface, IDirect3DIndexBuffer9* pIndexData) {
2609 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2610 HRESULT hr;
2611 IDirect3DIndexBuffer9Impl *ib = (IDirect3DIndexBuffer9Impl *) pIndexData;
2612
2613 TRACE("iface %p, buffer %p.\n", iface, pIndexData);
2614
2615 wined3d_mutex_lock();
2616 hr = IWineD3DDevice_SetIndexBuffer(This->WineD3DDevice,
2617 ib ? ib->wineD3DIndexBuffer : NULL,
2618 ib ? ib->format : WINED3DFMT_UNKNOWN);
2619 wined3d_mutex_unlock();
2620
2621 ASSERT_D3D(hr == S_OK);
2622 return hr;
2623}
2624
2625static HRESULT WINAPI IDirect3DDevice9Impl_GetIndices(LPDIRECT3DDEVICE9EX iface, IDirect3DIndexBuffer9 **ppIndexData) {
2626 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2627 IWineD3DBuffer *retIndexData = NULL;
2628 HRESULT rc = D3D_OK;
2629
2630 TRACE("iface %p, buffer %p.\n", iface, ppIndexData);
2631
2632 if(ppIndexData == NULL){
2633 ERR_D3D();
2634 return D3DERR_INVALIDCALL;
2635 }
2636
2637 wined3d_mutex_lock();
2638 rc = IWineD3DDevice_GetIndexBuffer(This->WineD3DDevice, &retIndexData);
2639 if (SUCCEEDED(rc) && retIndexData) {
2640 IWineD3DBuffer_GetParent(retIndexData, (IUnknown **)ppIndexData);
2641 IWineD3DBuffer_Release(retIndexData);
2642 } else {
2643 if (FAILED(rc)) FIXME("Call to GetIndices failed\n");
2644 *ppIndexData = NULL;
2645 }
2646 wined3d_mutex_unlock();
2647
2648 ASSERT_D3D(rc == S_OK);
2649 return rc;
2650}
2651
2652static HRESULT WINAPI IDirect3DDevice9Impl_CreatePixelShader(IDirect3DDevice9Ex *iface,
2653 const DWORD *byte_code, IDirect3DPixelShader9 **shader)
2654{
2655 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2656 IDirect3DPixelShader9Impl *object;
2657 HRESULT hr;
2658
2659 TRACE("iface %p, byte_code %p, shader %p.\n", iface, byte_code, shader);
2660
2661 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2662 if (!object)
2663 {
2664 ERR_D3D();
2665 FIXME("Failed to allocate pixel shader memory.\n");
2666 return E_OUTOFMEMORY;
2667 }
2668
2669 hr = pixelshader_init(object, This, byte_code);
2670 if (FAILED(hr))
2671 {
2672 ERR_D3D();
2673 WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
2674 HeapFree(GetProcessHeap(), 0, object);
2675 return hr;
2676 }
2677
2678 TRACE("Created pixel shader %p.\n", object);
2679 *shader = (IDirect3DPixelShader9 *)object;
2680
2681 return D3D_OK;
2682}
2683
2684static HRESULT WINAPI IDirect3DDevice9Impl_DrawRectPatch(LPDIRECT3DDEVICE9EX iface, UINT Handle, CONST float* pNumSegs, CONST D3DRECTPATCH_INFO* pRectPatchInfo) {
2685 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2686 HRESULT hr;
2687
2688 TRACE("iface %p, handle %#x, segment_count %p, patch_info %p.\n",
2689 iface, Handle, pNumSegs, pRectPatchInfo);
2690
2691 wined3d_mutex_lock();
2692 hr = IWineD3DDevice_DrawRectPatch(This->WineD3DDevice, Handle, pNumSegs, (CONST WINED3DRECTPATCH_INFO *)pRectPatchInfo);
2693 wined3d_mutex_unlock();
2694
2695 ASSERT_D3D(hr == S_OK);
2696 return hr;
2697}
2698
2699static HRESULT WINAPI IDirect3DDevice9Impl_DrawTriPatch(LPDIRECT3DDEVICE9EX iface, UINT Handle, CONST float* pNumSegs, CONST D3DTRIPATCH_INFO* pTriPatchInfo) {
2700 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2701 HRESULT hr;
2702
2703 TRACE("iface %p, handle %#x, segment_count %p, patch_info %p.\n",
2704 iface, Handle, pNumSegs, pTriPatchInfo);
2705
2706 wined3d_mutex_lock();
2707 hr = IWineD3DDevice_DrawTriPatch(This->WineD3DDevice, Handle, pNumSegs, (CONST WINED3DTRIPATCH_INFO *)pTriPatchInfo);
2708 wined3d_mutex_unlock();
2709
2710 ASSERT_D3D(hr == S_OK);
2711 return hr;
2712}
2713
2714static HRESULT WINAPI IDirect3DDevice9Impl_DeletePatch(LPDIRECT3DDEVICE9EX iface, UINT Handle) {
2715 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2716 HRESULT hr;
2717
2718 TRACE("iface %p, handle %#x.\n", iface, Handle);
2719
2720 wined3d_mutex_lock();
2721 hr = IWineD3DDevice_DeletePatch(This->WineD3DDevice, Handle);
2722 wined3d_mutex_unlock();
2723
2724 ASSERT_D3D(hr == S_OK);
2725 return hr;
2726}
2727
2728static HRESULT WINAPI IDirect3DDevice9Impl_CreateQuery(IDirect3DDevice9Ex *iface,
2729 D3DQUERYTYPE type, IDirect3DQuery9 **query)
2730{
2731 IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
2732 IDirect3DQuery9Impl *object;
2733 HRESULT hr;
2734
2735 TRACE("iface %p, type %#x, query %p.\n", iface, type, query);
2736
2737 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2738 if (!object)
2739 {
2740 ERR_D3D();
2741 ERR("Failed to allocate query memory.\n");
2742 return E_OUTOFMEMORY;
2743 }
2744
2745 hr = query_init(object, This, type);
2746 if (FAILED(hr))
2747 {
2748 ERR_D3D();
2749 WARN("Failed to initialize query, hr %#x.\n", hr);
2750 HeapFree(GetProcessHeap(), 0, object);
2751 return hr;
2752 }
2753
2754 TRACE("Created query %p.\n", object);
2755 if (query) *query = (IDirect3DQuery9 *)object;
2756 else IDirect3DQuery9_Release((IDirect3DQuery9 *)object);
2757
2758 return D3D_OK;
2759}
2760
2761static HRESULT WINAPI IDirect3DDevice9ExImpl_SetConvolutionMonoKernel(IDirect3DDevice9Ex *iface,
2762 UINT width, UINT height, float *rows, float *columns)
2763{
2764 FIXME("iface %p, width %u, height %u, rows %p, columns %p stub!\n",
2765 iface, width, height, rows, columns);
2766
2767 ERR_D3D();
2768 return WINED3DERR_INVALIDCALL;
2769}
2770
2771static HRESULT WINAPI IDirect3DDevice9ExImpl_ComposeRects(IDirect3DDevice9Ex *iface,
2772 IDirect3DSurface9 *src_surface, IDirect3DSurface9 *dst_surface, IDirect3DVertexBuffer9 *src_descs,
2773 UINT rect_count, IDirect3DVertexBuffer9 *dst_descs, D3DCOMPOSERECTSOP operation, INT offset_x, INT offset_y)
2774{
2775 FIXME("iface %p, src_surface %p, dst_surface %p, src_descs %p, rect_count %u,\n"
2776 "dst_descs %p, operation %#x, offset_x %u, offset_y %u stub!\n",
2777 iface, src_surface, dst_surface, src_descs, rect_count,
2778 dst_descs, operation, offset_x, offset_y);
2779
2780 ERR_D3D();
2781 return WINED3DERR_INVALIDCALL;
2782}
2783
2784static HRESULT WINAPI IDirect3DDevice9ExImpl_PresentEx(IDirect3DDevice9Ex *iface,
2785 const RECT *src_rect, const RECT *dst_rect, HWND dst_window_override,
2786 const RGNDATA *dirty_region, DWORD flags)
2787{
2788 FIXME("iface %p, src_rect %p, dst_rect %p, dst_window_override %p, dirty_region %p, flags %#x stub!\n",
2789 iface, src_rect, dst_rect, dst_window_override, dirty_region, flags);
2790
2791 ERR_D3D();
2792 return WINED3DERR_INVALIDCALL;
2793}
2794
2795static HRESULT WINAPI IDirect3DDevice9ExImpl_GetGPUThreadPriority(IDirect3DDevice9Ex *iface, INT *priority)
2796{
2797 FIXME("iface %p, priority %p stub!\n", iface, priority);
2798
2799 ERR_D3D();
2800 return WINED3DERR_INVALIDCALL;
2801}
2802
2803static HRESULT WINAPI IDirect3DDevice9ExImpl_SetGPUThreadPriority(IDirect3DDevice9Ex *iface, INT priority)
2804{
2805 FIXME("iface %p, priority %d stub!\n", iface, priority);
2806
2807 ERR_D3D();
2808 return WINED3DERR_INVALIDCALL;
2809}
2810
2811static HRESULT WINAPI IDirect3DDevice9ExImpl_WaitForVBlank(IDirect3DDevice9Ex *iface, UINT swapchain_idx)
2812{
2813 FIXME("iface %p, swapchain_idx %u stub!\n", iface, swapchain_idx);
2814
2815 ERR_D3D();
2816 return WINED3DERR_INVALIDCALL;
2817}
2818
2819static HRESULT WINAPI IDirect3DDevice9ExImpl_CheckResourceResidency(IDirect3DDevice9Ex *iface,
2820 IDirect3DResource9 **resources, UINT32 resource_count)
2821{
2822 FIXME("iface %p, resources %p, resource_count %u stub!\n",
2823 iface, resources, resource_count);
2824
2825 ERR_D3D();
2826 return WINED3DERR_INVALIDCALL;
2827}
2828
2829static HRESULT WINAPI IDirect3DDevice9ExImpl_SetMaximumFrameLatency(IDirect3DDevice9Ex *iface, UINT max_latency)
2830{
2831 FIXME("iface %p, max_latency %u stub!\n", iface, max_latency);
2832
2833 ERR_D3D();
2834 return WINED3DERR_INVALIDCALL;
2835}
2836
2837static HRESULT WINAPI IDirect3DDevice9ExImpl_GetMaximumFrameLatency(IDirect3DDevice9Ex *iface, UINT *max_latency)
2838{
2839 FIXME("iface %p, max_latency %p stub!\n", iface, max_latency);
2840
2841 *max_latency = 2;
2842
2843 ERR_D3D();
2844 return WINED3DERR_INVALIDCALL;
2845}
2846
2847static HRESULT WINAPI IDirect3DDevice9ExImpl_CheckDeviceState(IDirect3DDevice9Ex *iface, HWND dst_window)
2848{
2849 FIXME("iface %p, dst_window %p stub!\n", iface, dst_window);
2850
2851 ERR_D3D();
2852 return WINED3DERR_INVALIDCALL;
2853}
2854
2855static HRESULT WINAPI IDirect3DDevice9ExImpl_CreateRenderTargetEx(IDirect3DDevice9Ex *iface,
2856 UINT width, UINT height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality,
2857 BOOL lockable, IDirect3DSurface9 **surface, HANDLE *shared_handle, DWORD usage)
2858{
2859 FIXME("iface %p, width %u, height %u, format %#x, multisample_type %#x, multisample_quality %u,\n"
2860 "lockable %#x, surface %p, shared_handle %p, usage %#x stub!\n",
2861 iface, width, height, format, multisample_type, multisample_quality,
2862 lockable, surface, shared_handle, usage);
2863
2864 ERR_D3D();
2865 return WINED3DERR_INVALIDCALL;
2866}
2867
2868static HRESULT WINAPI IDirect3DDevice9ExImpl_CreateOffscreenPlainSurfaceEx(IDirect3DDevice9Ex *iface,
2869 UINT width, UINT height, D3DFORMAT format, D3DPOOL pool, IDirect3DSurface9 **surface,
2870 HANDLE *shared_handle, DWORD usage)
2871{
2872 FIXME("iface %p, width %u, height %u, format %#x, pool %#x, surface %p, shared_handle %p, usage %#x stub!\n",
2873 iface, width, height, format, pool, surface, shared_handle, usage);
2874
2875 ERR_D3D();
2876 return WINED3DERR_INVALIDCALL;
2877}
2878
2879static HRESULT WINAPI IDirect3DDevice9ExImpl_CreateDepthStencilSurfaceEx(IDirect3DDevice9Ex *iface,
2880 UINT width, UINT height, D3DFORMAT format, D3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality,
2881 BOOL discard, IDirect3DSurface9 **surface, HANDLE *shared_handle, DWORD usage)
2882{
2883 FIXME("iface %p, width %u, height %u, format %#x, multisample_type %#x, multisample_quality %u,\n"
2884 "discard %#x, surface %p, shared_handle %p, usage %#x stub!\n",
2885 iface, width, height, format, multisample_type, multisample_quality,
2886 discard, surface, shared_handle, usage);
2887
2888 ERR_D3D();
2889 return WINED3DERR_INVALIDCALL;
2890}
2891
2892static HRESULT WINAPI IDirect3DDevice9ExImpl_ResetEx(IDirect3DDevice9Ex *iface,
2893 D3DPRESENT_PARAMETERS *present_parameters, D3DDISPLAYMODEEX *mode)
2894{
2895 FIXME("iface %p, present_parameters %p, mode %p stub!\n", iface, present_parameters, mode);
2896
2897 ERR_D3D();
2898 return WINED3DERR_INVALIDCALL;
2899}
2900
2901static HRESULT WINAPI IDirect3DDevice9ExImpl_GetDisplayModeEx(IDirect3DDevice9Ex *iface,
2902 UINT swapchain_idx, D3DDISPLAYMODEEX *mode, D3DDISPLAYROTATION *rotation)
2903{
2904 FIXME("iface %p, swapchain_idx %u, mode %p, rotation %p stub!\n", iface, swapchain_idx, mode, rotation);
2905
2906 ERR_D3D();
2907 return WINED3DERR_INVALIDCALL;
2908}
2909
2910static const IDirect3DDevice9ExVtbl Direct3DDevice9_Vtbl =
2911{
2912 /* IUnknown */
2913 IDirect3DDevice9Impl_QueryInterface,
2914 IDirect3DDevice9Impl_AddRef,
2915 IDirect3DDevice9Impl_Release,
2916 /* IDirect3DDevice9 */
2917 IDirect3DDevice9Impl_TestCooperativeLevel,
2918 IDirect3DDevice9Impl_GetAvailableTextureMem,
2919 IDirect3DDevice9Impl_EvictManagedResources,
2920 IDirect3DDevice9Impl_GetDirect3D,
2921 IDirect3DDevice9Impl_GetDeviceCaps,
2922 IDirect3DDevice9Impl_GetDisplayMode,
2923 IDirect3DDevice9Impl_GetCreationParameters,
2924 IDirect3DDevice9Impl_SetCursorProperties,
2925 IDirect3DDevice9Impl_SetCursorPosition,
2926 IDirect3DDevice9Impl_ShowCursor,
2927 IDirect3DDevice9Impl_CreateAdditionalSwapChain,
2928 IDirect3DDevice9Impl_GetSwapChain,
2929 IDirect3DDevice9Impl_GetNumberOfSwapChains,
2930 IDirect3DDevice9Impl_Reset,
2931 IDirect3DDevice9Impl_Present,
2932 IDirect3DDevice9Impl_GetBackBuffer,
2933 IDirect3DDevice9Impl_GetRasterStatus,
2934 IDirect3DDevice9Impl_SetDialogBoxMode,
2935 IDirect3DDevice9Impl_SetGammaRamp,
2936 IDirect3DDevice9Impl_GetGammaRamp,
2937 IDirect3DDevice9Impl_CreateTexture,
2938 IDirect3DDevice9Impl_CreateVolumeTexture,
2939 IDirect3DDevice9Impl_CreateCubeTexture,
2940 IDirect3DDevice9Impl_CreateVertexBuffer,
2941 IDirect3DDevice9Impl_CreateIndexBuffer,
2942 IDirect3DDevice9Impl_CreateRenderTarget,
2943 IDirect3DDevice9Impl_CreateDepthStencilSurface,
2944 IDirect3DDevice9Impl_UpdateSurface,
2945 IDirect3DDevice9Impl_UpdateTexture,
2946 IDirect3DDevice9Impl_GetRenderTargetData,
2947 IDirect3DDevice9Impl_GetFrontBufferData,
2948 IDirect3DDevice9Impl_StretchRect,
2949 IDirect3DDevice9Impl_ColorFill,
2950 IDirect3DDevice9Impl_CreateOffscreenPlainSurface,
2951 IDirect3DDevice9Impl_SetRenderTarget,
2952 IDirect3DDevice9Impl_GetRenderTarget,
2953 IDirect3DDevice9Impl_SetDepthStencilSurface,
2954 IDirect3DDevice9Impl_GetDepthStencilSurface,
2955 IDirect3DDevice9Impl_BeginScene,
2956 IDirect3DDevice9Impl_EndScene,
2957 IDirect3DDevice9Impl_Clear,
2958 IDirect3DDevice9Impl_SetTransform,
2959 IDirect3DDevice9Impl_GetTransform,
2960 IDirect3DDevice9Impl_MultiplyTransform,
2961 IDirect3DDevice9Impl_SetViewport,
2962 IDirect3DDevice9Impl_GetViewport,
2963 IDirect3DDevice9Impl_SetMaterial,
2964 IDirect3DDevice9Impl_GetMaterial,
2965 IDirect3DDevice9Impl_SetLight,
2966 IDirect3DDevice9Impl_GetLight,
2967 IDirect3DDevice9Impl_LightEnable,
2968 IDirect3DDevice9Impl_GetLightEnable,
2969 IDirect3DDevice9Impl_SetClipPlane,
2970 IDirect3DDevice9Impl_GetClipPlane,
2971 IDirect3DDevice9Impl_SetRenderState,
2972 IDirect3DDevice9Impl_GetRenderState,
2973 IDirect3DDevice9Impl_CreateStateBlock,
2974 IDirect3DDevice9Impl_BeginStateBlock,
2975 IDirect3DDevice9Impl_EndStateBlock,
2976 IDirect3DDevice9Impl_SetClipStatus,
2977 IDirect3DDevice9Impl_GetClipStatus,
2978 IDirect3DDevice9Impl_GetTexture,
2979 IDirect3DDevice9Impl_SetTexture,
2980 IDirect3DDevice9Impl_GetTextureStageState,
2981 IDirect3DDevice9Impl_SetTextureStageState,
2982 IDirect3DDevice9Impl_GetSamplerState,
2983 IDirect3DDevice9Impl_SetSamplerState,
2984 IDirect3DDevice9Impl_ValidateDevice,
2985 IDirect3DDevice9Impl_SetPaletteEntries,
2986 IDirect3DDevice9Impl_GetPaletteEntries,
2987 IDirect3DDevice9Impl_SetCurrentTexturePalette,
2988 IDirect3DDevice9Impl_GetCurrentTexturePalette,
2989 IDirect3DDevice9Impl_SetScissorRect,
2990 IDirect3DDevice9Impl_GetScissorRect,
2991 IDirect3DDevice9Impl_SetSoftwareVertexProcessing,
2992 IDirect3DDevice9Impl_GetSoftwareVertexProcessing,
2993 IDirect3DDevice9Impl_SetNPatchMode,
2994 IDirect3DDevice9Impl_GetNPatchMode,
2995 IDirect3DDevice9Impl_DrawPrimitive,
2996 IDirect3DDevice9Impl_DrawIndexedPrimitive,
2997 IDirect3DDevice9Impl_DrawPrimitiveUP,
2998 IDirect3DDevice9Impl_DrawIndexedPrimitiveUP,
2999 IDirect3DDevice9Impl_ProcessVertices,
3000 IDirect3DDevice9Impl_CreateVertexDeclaration,
3001 IDirect3DDevice9Impl_SetVertexDeclaration,
3002 IDirect3DDevice9Impl_GetVertexDeclaration,
3003 IDirect3DDevice9Impl_SetFVF,
3004 IDirect3DDevice9Impl_GetFVF,
3005 IDirect3DDevice9Impl_CreateVertexShader,
3006 IDirect3DDevice9Impl_SetVertexShader,
3007 IDirect3DDevice9Impl_GetVertexShader,
3008 IDirect3DDevice9Impl_SetVertexShaderConstantF,
3009 IDirect3DDevice9Impl_GetVertexShaderConstantF,
3010 IDirect3DDevice9Impl_SetVertexShaderConstantI,
3011 IDirect3DDevice9Impl_GetVertexShaderConstantI,
3012 IDirect3DDevice9Impl_SetVertexShaderConstantB,
3013 IDirect3DDevice9Impl_GetVertexShaderConstantB,
3014 IDirect3DDevice9Impl_SetStreamSource,
3015 IDirect3DDevice9Impl_GetStreamSource,
3016 IDirect3DDevice9Impl_SetStreamSourceFreq,
3017 IDirect3DDevice9Impl_GetStreamSourceFreq,
3018 IDirect3DDevice9Impl_SetIndices,
3019 IDirect3DDevice9Impl_GetIndices,
3020 IDirect3DDevice9Impl_CreatePixelShader,
3021 IDirect3DDevice9Impl_SetPixelShader,
3022 IDirect3DDevice9Impl_GetPixelShader,
3023 IDirect3DDevice9Impl_SetPixelShaderConstantF,
3024 IDirect3DDevice9Impl_GetPixelShaderConstantF,
3025 IDirect3DDevice9Impl_SetPixelShaderConstantI,
3026 IDirect3DDevice9Impl_GetPixelShaderConstantI,
3027 IDirect3DDevice9Impl_SetPixelShaderConstantB,
3028 IDirect3DDevice9Impl_GetPixelShaderConstantB,
3029 IDirect3DDevice9Impl_DrawRectPatch,
3030 IDirect3DDevice9Impl_DrawTriPatch,
3031 IDirect3DDevice9Impl_DeletePatch,
3032 IDirect3DDevice9Impl_CreateQuery,
3033 /* IDirect3DDevice9Ex */
3034 IDirect3DDevice9ExImpl_SetConvolutionMonoKernel,
3035 IDirect3DDevice9ExImpl_ComposeRects,
3036 IDirect3DDevice9ExImpl_PresentEx,
3037 IDirect3DDevice9ExImpl_GetGPUThreadPriority,
3038 IDirect3DDevice9ExImpl_SetGPUThreadPriority,
3039 IDirect3DDevice9ExImpl_WaitForVBlank,
3040 IDirect3DDevice9ExImpl_CheckResourceResidency,
3041 IDirect3DDevice9ExImpl_SetMaximumFrameLatency,
3042 IDirect3DDevice9ExImpl_GetMaximumFrameLatency,
3043 IDirect3DDevice9ExImpl_CheckDeviceState,
3044 IDirect3DDevice9ExImpl_CreateRenderTargetEx,
3045 IDirect3DDevice9ExImpl_CreateOffscreenPlainSurfaceEx,
3046 IDirect3DDevice9ExImpl_CreateDepthStencilSurfaceEx,
3047 IDirect3DDevice9ExImpl_ResetEx,
3048 IDirect3DDevice9ExImpl_GetDisplayModeEx
3049};
3050
3051/* IWineD3DDeviceParent IUnknown methods */
3052
3053static inline struct IDirect3DDevice9Impl *device_from_device_parent(IWineD3DDeviceParent *iface)
3054{
3055 return (struct IDirect3DDevice9Impl *)((char*)iface
3056 - FIELD_OFFSET(struct IDirect3DDevice9Impl, device_parent_vtbl));
3057}
3058
3059static HRESULT STDMETHODCALLTYPE device_parent_QueryInterface(IWineD3DDeviceParent *iface, REFIID riid, void **object)
3060{
3061 struct IDirect3DDevice9Impl *This = device_from_device_parent(iface);
3062 return IDirect3DDevice9Impl_QueryInterface((IDirect3DDevice9Ex *)This, riid, object);
3063}
3064
3065static ULONG STDMETHODCALLTYPE device_parent_AddRef(IWineD3DDeviceParent *iface)
3066{
3067 struct IDirect3DDevice9Impl *This = device_from_device_parent(iface);
3068 return IDirect3DDevice9Impl_AddRef((IDirect3DDevice9Ex *)This);
3069}
3070
3071static ULONG STDMETHODCALLTYPE device_parent_Release(IWineD3DDeviceParent *iface)
3072{
3073 struct IDirect3DDevice9Impl *This = device_from_device_parent(iface);
3074 return IDirect3DDevice9Impl_Release((IDirect3DDevice9Ex *)This);
3075}
3076
3077/* IWineD3DDeviceParent methods */
3078
3079static void STDMETHODCALLTYPE device_parent_WineD3DDeviceCreated(IWineD3DDeviceParent *iface, IWineD3DDevice *device)
3080{
3081 TRACE("iface %p, device %p\n", iface, device);
3082}
3083
3084static HRESULT STDMETHODCALLTYPE device_parent_CreateSurface(IWineD3DDeviceParent *iface,
3085 IUnknown *superior, UINT width, UINT height, WINED3DFORMAT format, DWORD usage,
3086 WINED3DPOOL pool, UINT level, WINED3DCUBEMAP_FACES face, IWineD3DSurface **surface
3087#ifdef VBOX_WITH_WDDM
3088 , HANDLE *shared_handle
3089 , void *pvClientMem
3090#endif
3091 )
3092{
3093 struct IDirect3DDevice9Impl *This = device_from_device_parent(iface);
3094 IDirect3DSurface9Impl *d3d_surface;
3095 BOOL lockable = TRUE;
3096 HRESULT hr;
3097
3098 TRACE("iface %p, superior %p, width %u, height %u, format %#x, usage %#x,\n"
3099 "\tpool %#x, level %u, face %u, surface %p\n",
3100 iface, superior, width, height, format, usage, pool, level, face, surface);
3101
3102 if (pool == WINED3DPOOL_DEFAULT && !(usage & D3DUSAGE_DYNAMIC))
3103 lockable = FALSE;
3104
3105 hr = IDirect3DDevice9Impl_CreateSurface((IDirect3DDevice9Ex *)This, width, height,
3106 d3dformat_from_wined3dformat(format), lockable, FALSE /* Discard */, level,
3107 (IDirect3DSurface9 **)&d3d_surface, usage, pool, D3DMULTISAMPLE_NONE, 0 /* MultisampleQuality */
3108#ifdef VBOX_WITH_WDDM
3109 , shared_handle
3110 , pvClientMem
3111#endif
3112 );
3113 if (FAILED(hr))
3114 {
3115 ERR("(%p) CreateSurface failed, returning %#x\n", iface, hr);
3116 return hr;
3117 }
3118
3119 *surface = d3d_surface->wineD3DSurface;
3120 IWineD3DSurface_AddRef(*surface);
3121
3122 d3d_surface->container = superior;
3123 IDirect3DDevice9Ex_Release(d3d_surface->parentDevice);
3124 d3d_surface->parentDevice = NULL;
3125
3126 IDirect3DSurface9_Release((IDirect3DSurface9 *)d3d_surface);
3127 d3d_surface->forwardReference = superior;
3128
3129 return hr;
3130}
3131
3132static HRESULT STDMETHODCALLTYPE device_parent_CreateRenderTarget(IWineD3DDeviceParent *iface,
3133 IUnknown *superior, UINT width, UINT height, WINED3DFORMAT format, WINED3DMULTISAMPLE_TYPE multisample_type,
3134 DWORD multisample_quality, BOOL lockable, IWineD3DSurface **surface)
3135{
3136 struct IDirect3DDevice9Impl *This = device_from_device_parent(iface);
3137 IDirect3DSurface9Impl *d3d_surface;
3138 HRESULT hr;
3139
3140 TRACE("iface %p, superior %p, width %u, height %u, format %#x, multisample_type %#x,\n"
3141 "\tmultisample_quality %u, lockable %u, surface %p\n",
3142 iface, superior, width, height, format, multisample_type, multisample_quality, lockable, surface);
3143
3144 hr = IDirect3DDevice9Impl_CreateRenderTarget((IDirect3DDevice9Ex *)This, width, height,
3145 d3dformat_from_wined3dformat(format), multisample_type, multisample_quality, lockable,
3146 (IDirect3DSurface9 **)&d3d_surface, NULL);
3147 if (FAILED(hr))
3148 {
3149 ERR("(%p) CreateRenderTarget failed, returning %#x\n", iface, hr);
3150 return hr;
3151 }
3152
3153 *surface = d3d_surface->wineD3DSurface;
3154 IWineD3DSurface_AddRef(*surface);
3155
3156 d3d_surface->container = superior;
3157 /* Implicit surfaces are created with an refcount of 0 */
3158 IDirect3DSurface9_Release((IDirect3DSurface9 *)d3d_surface);
3159
3160 return hr;
3161}
3162
3163static HRESULT STDMETHODCALLTYPE device_parent_CreateDepthStencilSurface(IWineD3DDeviceParent *iface,
3164 IUnknown *superior, UINT width, UINT height, WINED3DFORMAT format, WINED3DMULTISAMPLE_TYPE multisample_type,
3165 DWORD multisample_quality, BOOL discard, IWineD3DSurface **surface)
3166{
3167 struct IDirect3DDevice9Impl *This = device_from_device_parent(iface);
3168 IDirect3DSurface9Impl *d3d_surface;
3169 HRESULT hr;
3170
3171 TRACE("iface %p, superior %p, width %u, height %u, format %#x, multisample_type %#x,\n"
3172 "\tmultisample_quality %u, discard %u, surface %p\n",
3173 iface, superior, width, height, format, multisample_type, multisample_quality, discard, surface);
3174
3175 hr = IDirect3DDevice9Impl_CreateDepthStencilSurface((IDirect3DDevice9Ex *)This, width, height,
3176 d3dformat_from_wined3dformat(format), multisample_type, multisample_quality, discard,
3177 (IDirect3DSurface9 **)&d3d_surface, NULL);
3178 if (FAILED(hr))
3179 {
3180 ERR("(%p) CreateDepthStencilSurface failed, returning %#x\n", iface, hr);
3181 return hr;
3182 }
3183
3184 *surface = d3d_surface->wineD3DSurface;
3185 IWineD3DSurface_AddRef(*surface);
3186 d3d_surface->container = (IUnknown *)This;
3187 /* Implicit surfaces are created with an refcount of 0 */
3188 IDirect3DSurface9_Release((IDirect3DSurface9 *)d3d_surface);
3189
3190 return hr;
3191}
3192
3193static HRESULT STDMETHODCALLTYPE device_parent_CreateVolume(IWineD3DDeviceParent *iface,
3194 IUnknown *superior, UINT width, UINT height, UINT depth, WINED3DFORMAT format,
3195 WINED3DPOOL pool, DWORD usage, IWineD3DVolume **volume
3196#ifdef VBOX_WITH_WDDM
3197 , HANDLE *shared_handle
3198 , void *pvClientMem
3199#endif
3200 )
3201{
3202 struct IDirect3DDevice9Impl *This = device_from_device_parent(iface);
3203 IDirect3DVolume9Impl *object;
3204 HRESULT hr;
3205
3206 TRACE("iface %p, superior %p, width %u, height %u, depth %u, format %#x, pool %#x, usage %#x, volume %p\n",
3207 iface, superior, width, height, depth, format, pool, usage, volume);
3208
3209 /* Allocate the storage for the device */
3210 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
3211 if (!object)
3212 {
3213 FIXME("Allocation of memory failed\n");
3214 *volume = NULL;
3215 return D3DERR_OUTOFVIDEOMEMORY;
3216 }
3217
3218 hr = volume_init(object, This, width, height, depth, usage, format, pool
3219#ifdef VBOX_WITH_WDDM
3220 , shared_handle, pvClientMem
3221#endif
3222 );
3223 if (FAILED(hr))
3224 {
3225 WARN("Failed to initialize volume, hr %#x.\n", hr);
3226 HeapFree(GetProcessHeap(), 0, object);
3227 return hr;
3228 }
3229
3230 *volume = object->wineD3DVolume;
3231 IWineD3DVolume_AddRef(*volume);
3232 IDirect3DVolume9_Release((IDirect3DVolume9 *)object);
3233
3234 object->container = superior;
3235 object->forwardReference = superior;
3236
3237 TRACE("(%p) Created volume %p\n", iface, object);
3238
3239 return hr;
3240}
3241
3242static HRESULT STDMETHODCALLTYPE device_parent_CreateSwapChain(IWineD3DDeviceParent *iface,
3243 WINED3DPRESENT_PARAMETERS *present_parameters, IWineD3DSwapChain **swapchain)
3244{
3245 struct IDirect3DDevice9Impl *This = device_from_device_parent(iface);
3246 IDirect3DSwapChain9Impl *d3d_swapchain;
3247 D3DPRESENT_PARAMETERS local_parameters;
3248 HRESULT hr;
3249
3250 TRACE("iface %p, present_parameters %p, swapchain %p\n", iface, present_parameters, swapchain);
3251
3252 /* Copy the presentation parameters */
3253 local_parameters.BackBufferWidth = present_parameters->BackBufferWidth;
3254 local_parameters.BackBufferHeight = present_parameters->BackBufferHeight;
3255 local_parameters.BackBufferFormat = d3dformat_from_wined3dformat(present_parameters->BackBufferFormat);
3256 local_parameters.BackBufferCount = present_parameters->BackBufferCount;
3257 local_parameters.MultiSampleType = present_parameters->MultiSampleType;
3258 local_parameters.MultiSampleQuality = present_parameters->MultiSampleQuality;
3259 local_parameters.SwapEffect = present_parameters->SwapEffect;
3260 local_parameters.hDeviceWindow = present_parameters->hDeviceWindow;
3261 local_parameters.Windowed = present_parameters->Windowed;
3262 local_parameters.EnableAutoDepthStencil = present_parameters->EnableAutoDepthStencil;
3263 local_parameters.AutoDepthStencilFormat = d3dformat_from_wined3dformat(present_parameters->AutoDepthStencilFormat);
3264 local_parameters.Flags = present_parameters->Flags;
3265 local_parameters.FullScreen_RefreshRateInHz = present_parameters->FullScreen_RefreshRateInHz;
3266 local_parameters.PresentationInterval = present_parameters->PresentationInterval;
3267
3268 hr = IDirect3DDevice9Impl_DoCreateAdditionalSwapChain((IDirect3DDevice9Ex *)This,
3269 &local_parameters, (IDirect3DSwapChain9 **)&d3d_swapchain);
3270 if (FAILED(hr))
3271 {
3272 ERR("(%p) CreateAdditionalSwapChain failed, returning %#x\n", iface, hr);
3273 *swapchain = NULL;
3274 return hr;
3275 }
3276
3277 *swapchain = d3d_swapchain->wineD3DSwapChain;
3278 d3d_swapchain->isImplicit = TRUE;
3279 /* Implicit swap chains are created with an refcount of 0 */
3280 IDirect3DSwapChain9_Release((IDirect3DSwapChain9 *)d3d_swapchain);
3281
3282 /* Copy back the presentation parameters */
3283 present_parameters->BackBufferWidth = local_parameters.BackBufferWidth;
3284 present_parameters->BackBufferHeight = local_parameters.BackBufferHeight;
3285 present_parameters->BackBufferFormat = wined3dformat_from_d3dformat(local_parameters.BackBufferFormat);
3286 present_parameters->BackBufferCount = local_parameters.BackBufferCount;
3287 present_parameters->MultiSampleType = local_parameters.MultiSampleType;
3288 present_parameters->MultiSampleQuality = local_parameters.MultiSampleQuality;
3289 present_parameters->SwapEffect = local_parameters.SwapEffect;
3290 present_parameters->hDeviceWindow = local_parameters.hDeviceWindow;
3291 present_parameters->Windowed = local_parameters.Windowed;
3292 present_parameters->EnableAutoDepthStencil = local_parameters.EnableAutoDepthStencil;
3293 present_parameters->AutoDepthStencilFormat = wined3dformat_from_d3dformat(local_parameters.AutoDepthStencilFormat);
3294 present_parameters->Flags = local_parameters.Flags;
3295 present_parameters->FullScreen_RefreshRateInHz = local_parameters.FullScreen_RefreshRateInHz;
3296 present_parameters->PresentationInterval = local_parameters.PresentationInterval;
3297
3298 return hr;
3299}
3300
3301static const IWineD3DDeviceParentVtbl d3d9_wined3d_device_parent_vtbl =
3302{
3303 /* IUnknown methods */
3304 device_parent_QueryInterface,
3305 device_parent_AddRef,
3306 device_parent_Release,
3307 /* IWineD3DDeviceParent methods */
3308 device_parent_WineD3DDeviceCreated,
3309 device_parent_CreateSurface,
3310 device_parent_CreateRenderTarget,
3311 device_parent_CreateDepthStencilSurface,
3312 device_parent_CreateVolume,
3313 device_parent_CreateSwapChain,
3314};
3315
3316#ifdef VBOX_WITH_WDDM
3317# define PP_BASE(_p) (&(_p)->Base)
3318#else
3319# define PP_BASE(_p) (_p)
3320#endif
3321HRESULT device_init(IDirect3DDevice9Impl *device, IWineD3D *wined3d, UINT adapter, D3DDEVTYPE device_type,
3322 HWND focus_window, DWORD flags
3323#ifdef VBOX_WITH_WDDM
3324 , VBOXWINEEX_D3DPRESENT_PARAMETERS *parameters
3325#else
3326 , D3DPRESENT_PARAMETERS *parameters
3327#endif
3328 )
3329{
3330 WINED3DPRESENT_PARAMETERS *wined3d_parameters;
3331 UINT i, count = 1;
3332 HRESULT hr;
3333
3334 device->lpVtbl = &Direct3DDevice9_Vtbl;
3335 device->device_parent_vtbl = &d3d9_wined3d_device_parent_vtbl;
3336 device->ref = 1;
3337
3338 wined3d_mutex_lock();
3339 hr = IWineD3D_CreateDevice(wined3d, adapter, device_type, focus_window, flags, (IUnknown *)device,
3340 (IWineD3DDeviceParent *)&device->device_parent_vtbl, &device->WineD3DDevice);
3341 if (FAILED(hr))
3342 {
3343 WARN("Failed to create wined3d device, hr %#x.\n", hr);
3344 wined3d_mutex_unlock();
3345 return hr;
3346 }
3347
3348#ifndef VBOX_WITH_WDDM
3349 if (!parameters->Windowed)
3350 {
3351 if (!focus_window) focus_window = parameters->hDeviceWindow;
3352 if (FAILED(hr = IWineD3DDevice_AcquireFocusWindow(device->WineD3DDevice, focus_window)))
3353 {
3354 ERR("Failed to acquire focus window, hr %#x.\n", hr);
3355 IWineD3DDevice_Release(device->WineD3DDevice);
3356 wined3d_mutex_unlock();
3357 return hr;
3358 }
3359 }
3360#endif
3361
3362 if (flags & D3DCREATE_ADAPTERGROUP_DEVICE)
3363 {
3364 WINED3DCAPS caps;
3365
3366 IWineD3D_GetDeviceCaps(wined3d, adapter, device_type, &caps);
3367 count = caps.NumberOfAdaptersInGroup;
3368 }
3369
3370 if (flags & D3DCREATE_MULTITHREADED) IWineD3DDevice_SetMultithreaded(device->WineD3DDevice);
3371
3372 wined3d_parameters = HeapAlloc(GetProcessHeap(), 0, sizeof(*wined3d_parameters) * count);
3373 if (!wined3d_parameters)
3374 {
3375 ERR("Failed to allocate wined3d parameters.\n");
3376 IWineD3DDevice_Release(device->WineD3DDevice);
3377 wined3d_mutex_unlock();
3378 return E_OUTOFMEMORY;
3379 }
3380
3381 for (i = 0; i < count; ++i)
3382 {
3383 wined3d_parameters[i].BackBufferWidth = PP_BASE(&parameters[i])->BackBufferWidth;
3384 wined3d_parameters[i].BackBufferHeight =PP_BASE(&parameters[i])->BackBufferHeight;
3385 wined3d_parameters[i].BackBufferFormat = wined3dformat_from_d3dformat(PP_BASE(&parameters[i])->BackBufferFormat);
3386 wined3d_parameters[i].BackBufferCount = PP_BASE(&parameters[i])->BackBufferCount;
3387 wined3d_parameters[i].MultiSampleType =PP_BASE(&parameters[i])->MultiSampleType;
3388 wined3d_parameters[i].MultiSampleQuality =PP_BASE(&parameters[i])->MultiSampleQuality;
3389 wined3d_parameters[i].SwapEffect =PP_BASE(&parameters[i])->SwapEffect;
3390 wined3d_parameters[i].hDeviceWindow =PP_BASE(&parameters[i])->hDeviceWindow;
3391 wined3d_parameters[i].Windowed =PP_BASE(&parameters[i])->Windowed;
3392 wined3d_parameters[i].EnableAutoDepthStencil =PP_BASE(&parameters[i])->EnableAutoDepthStencil;
3393 wined3d_parameters[i].AutoDepthStencilFormat =
3394 wined3dformat_from_d3dformat(PP_BASE(&parameters[i])->AutoDepthStencilFormat);
3395 wined3d_parameters[i].Flags =PP_BASE(&parameters[i])->Flags;
3396 wined3d_parameters[i].FullScreen_RefreshRateInHz =PP_BASE(&parameters[i])->FullScreen_RefreshRateInHz;
3397 wined3d_parameters[i].PresentationInterval =PP_BASE(&parameters[i])->PresentationInterval;
3398 wined3d_parameters[i].AutoRestoreDisplayMode = TRUE;
3399#ifdef VBOX_WITH_WDDM
3400 wined3d_parameters[i].pHgsmi = parameters[i].pHgsmi;
3401#endif
3402 }
3403
3404 hr = IWineD3DDevice_Init3D(device->WineD3DDevice, wined3d_parameters);
3405 if (FAILED(hr))
3406 {
3407 WARN("Failed to initialize 3D, hr %#x.\n", hr);
3408#ifndef VBOX_WITH_WDDM
3409 IWineD3DDevice_ReleaseFocusWindow(device->WineD3DDevice);
3410#endif
3411 HeapFree(GetProcessHeap(), 0, wined3d_parameters);
3412 IWineD3DDevice_Release(device->WineD3DDevice);
3413 wined3d_mutex_unlock();
3414 return hr;
3415 }
3416
3417 wined3d_mutex_unlock();
3418
3419 for (i = 0; i < count; ++i)
3420 {
3421 PP_BASE(&parameters[i])->BackBufferWidth = wined3d_parameters[i].BackBufferWidth;
3422 PP_BASE(&parameters[i])->BackBufferHeight = wined3d_parameters[i].BackBufferHeight;
3423 PP_BASE(&parameters[i])->BackBufferFormat = d3dformat_from_wined3dformat(wined3d_parameters[i].BackBufferFormat);
3424 PP_BASE(&parameters[i])->BackBufferCount = wined3d_parameters[i].BackBufferCount;
3425 PP_BASE(&parameters[i])->MultiSampleType = wined3d_parameters[i].MultiSampleType;
3426 PP_BASE(&parameters[i])->MultiSampleQuality = wined3d_parameters[i].MultiSampleQuality;
3427 PP_BASE(&parameters[i])->SwapEffect = wined3d_parameters[i].SwapEffect;
3428 PP_BASE(&parameters[i])->hDeviceWindow = wined3d_parameters[i].hDeviceWindow;
3429 PP_BASE(&parameters[i])->Windowed = wined3d_parameters[i].Windowed;
3430 PP_BASE(&parameters[i])->EnableAutoDepthStencil = wined3d_parameters[i].EnableAutoDepthStencil;
3431 PP_BASE(&parameters[i])->AutoDepthStencilFormat =
3432 d3dformat_from_wined3dformat(wined3d_parameters[i].AutoDepthStencilFormat);
3433 PP_BASE(&parameters[i])->Flags = wined3d_parameters[i].Flags;
3434 PP_BASE(&parameters[i])->FullScreen_RefreshRateInHz = wined3d_parameters[i].FullScreen_RefreshRateInHz;
3435 PP_BASE(&parameters[i])->PresentationInterval = wined3d_parameters[i].PresentationInterval;
3436 }
3437 HeapFree(GetProcessHeap(), 0, wined3d_parameters);
3438
3439 /* Initialize the converted declaration array. This creates a valid pointer
3440 * and when adding decls HeapReAlloc() can be used without further checking. */
3441 device->convertedDecls = HeapAlloc(GetProcessHeap(), 0, 0);
3442 if (!device->convertedDecls)
3443 {
3444 ERR("Failed to allocate FVF vertex declaration map memory.\n");
3445 wined3d_mutex_lock();
3446 IWineD3DDevice_Uninit3D(device->WineD3DDevice, D3D9CB_DestroySwapChain);
3447#ifndef VBOX_WITH_WDDM
3448 IWineD3DDevice_ReleaseFocusWindow(device->WineD3DDevice);
3449#endif
3450 IWineD3DDevice_Release(device->WineD3DDevice);
3451 wined3d_mutex_unlock();
3452 return E_OUTOFMEMORY;
3453 }
3454
3455 return D3D_OK;
3456}
3457
3458#ifdef VBOX_WITH_WDDM
3459VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DRc9SetShRcState(IDirect3DResource9 *iface, VBOXWINEEX_SHRC_STATE enmState)
3460{
3461 D3DRESOURCETYPE enmType = IDirect3DResource9_GetType(iface);
3462 HRESULT hr;
3463 switch (enmType)
3464 {
3465 case D3DRTYPE_SURFACE:
3466 {
3467 IDirect3DSurface9Impl *This = (IDirect3DSurface9Impl*)iface ;
3468 wined3d_mutex_lock();
3469 hr = IWineD3DResource_SetShRcState((IWineD3DResource*)This->wineD3DSurface, enmState);
3470 wined3d_mutex_unlock();
3471 break;
3472 }
3473 case D3DRTYPE_VOLUME:
3474 {
3475 IDirect3DVolume9Impl *This = (IDirect3DVolume9Impl*)iface ;
3476 wined3d_mutex_lock();
3477 hr = IWineD3DResource_SetShRcState((IWineD3DResource*)This->wineD3DVolume, enmState);
3478 wined3d_mutex_unlock();
3479 break;
3480 }
3481 case D3DRTYPE_TEXTURE:
3482 {
3483 IDirect3DTexture9Impl *This = (IDirect3DTexture9Impl*)iface ;
3484 wined3d_mutex_lock();
3485 hr = IWineD3DResource_SetShRcState((IWineD3DResource*)This->wineD3DTexture, enmState);
3486 wined3d_mutex_unlock();
3487 break;
3488 }
3489 case D3DRTYPE_VOLUMETEXTURE:
3490 {
3491 IDirect3DVolumeTexture9Impl *This = (IDirect3DVolumeTexture9Impl*)iface ;
3492 wined3d_mutex_lock();
3493 hr = IWineD3DResource_SetShRcState((IWineD3DResource*)This->wineD3DVolumeTexture, enmState);
3494 wined3d_mutex_unlock();
3495 break;
3496 }
3497 case D3DRTYPE_CUBETEXTURE:
3498 {
3499 IDirect3DCubeTexture9Impl *This = (IDirect3DCubeTexture9Impl*)iface ;
3500 wined3d_mutex_lock();
3501 hr = IWineD3DResource_SetShRcState((IWineD3DResource*)This->wineD3DCubeTexture, enmState);
3502 wined3d_mutex_unlock();
3503 break;
3504 }
3505 case D3DRTYPE_VERTEXBUFFER:
3506 {
3507 IDirect3DVertexBuffer9Impl *This = (IDirect3DVertexBuffer9Impl*)iface ;
3508 wined3d_mutex_lock();
3509 hr = IWineD3DResource_SetShRcState((IWineD3DResource*)This->wineD3DVertexBuffer, enmState);
3510 wined3d_mutex_unlock();
3511 break;
3512 }
3513 case D3DRTYPE_INDEXBUFFER:
3514 {
3515 IDirect3DIndexBuffer9Impl *This = (IDirect3DIndexBuffer9Impl*)iface ;
3516 wined3d_mutex_lock();
3517 hr = IWineD3DResource_SetShRcState((IWineD3DResource*)This->wineD3DIndexBuffer, enmState);
3518 wined3d_mutex_unlock();
3519 break;
3520 }
3521 default:
3522 ERR("invalid arg");
3523 hr = E_INVALIDARG;
3524 break;
3525 }
3526 return hr;
3527}
3528#endif
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette