?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 52d6b63ba2f2d4f9b02b6b922d27bff05a60596f
[wine/hacks.git] / dlls / d3d8 / device.c
blobd0504edaaa696f333097266799b9a717afebb7cf
1 /*
2 * IDirect3DDevice8 implementation
3 *
4 * Copyright 2002-2004 Jason Edmeades
5 * Copyright 2004 Christian Costa
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23
24 #include <math.h>
25 #include <stdarg.h>
26
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winuser.h"
32 #include "wingdi.h"
33 #include "wine/debug.h"
34
35 #include "d3d8_private.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
38
39 D3DFORMAT d3dformat_from_wined3dformat(WINED3DFORMAT format)
40 {
41 BYTE *c = (BYTE *)&format;
42
43 /* Don't translate FOURCC formats */
44 if (isprint(c[0]) && isprint(c[1]) && isprint(c[2]) && isprint(c[3])) return format;
45
46 switch(format)
47 {
48 case WINED3DFMT_UNKNOWN: return D3DFMT_UNKNOWN;
49 case WINED3DFMT_B8G8R8_UNORM: return D3DFMT_R8G8B8;
50 case WINED3DFMT_B8G8R8A8_UNORM: return D3DFMT_A8R8G8B8;
51 case WINED3DFMT_B8G8R8X8_UNORM: return D3DFMT_X8R8G8B8;
52 case WINED3DFMT_B5G6R5_UNORM: return D3DFMT_R5G6B5;
53 case WINED3DFMT_B5G5R5X1_UNORM: return D3DFMT_X1R5G5B5;
54 case WINED3DFMT_B5G5R5A1_UNORM: return D3DFMT_A1R5G5B5;
55 case WINED3DFMT_B4G4R4A4_UNORM: return D3DFMT_A4R4G4B4;
56 case WINED3DFMT_B2G3R3_UNORM: return D3DFMT_R3G3B2;
57 case WINED3DFMT_A8_UNORM: return D3DFMT_A8;
58 case WINED3DFMT_B2G3R3A8_UNORM: return D3DFMT_A8R3G3B2;
59 case WINED3DFMT_B4G4R4X4_UNORM: return D3DFMT_X4R4G4B4;
60 case WINED3DFMT_R10G10B10A2_UNORM: return D3DFMT_A2B10G10R10;
61 case WINED3DFMT_R16G16_UNORM: return D3DFMT_G16R16;
62 case WINED3DFMT_P8_UINT_A8_UNORM: return D3DFMT_A8P8;
63 case WINED3DFMT_P8_UINT: return D3DFMT_P8;
64 case WINED3DFMT_L8_UNORM: return D3DFMT_L8;
65 case WINED3DFMT_L8A8_UNORM: return D3DFMT_A8L8;
66 case WINED3DFMT_L4A4_UNORM: return D3DFMT_A4L4;
67 case WINED3DFMT_R8G8_SNORM: return D3DFMT_V8U8;
68 case WINED3DFMT_R5G5_SNORM_L6_UNORM: return D3DFMT_L6V5U5;
69 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM: return D3DFMT_X8L8V8U8;
70 case WINED3DFMT_R8G8B8A8_SNORM: return D3DFMT_Q8W8V8U8;
71 case WINED3DFMT_R16G16_SNORM: return D3DFMT_V16U16;
72 case WINED3DFMT_R10G11B11_SNORM: return D3DFMT_W11V11U10;
73 case WINED3DFMT_R10G10B10_SNORM_A2_UNORM: return D3DFMT_A2W10V10U10;
74 case WINED3DFMT_D16_LOCKABLE: return D3DFMT_D16_LOCKABLE;
75 case WINED3DFMT_D32_UNORM: return D3DFMT_D32;
76 case WINED3DFMT_S1_UINT_D15_UNORM: return D3DFMT_D15S1;
77 case WINED3DFMT_D24_UNORM_S8_UINT: return D3DFMT_D24S8;
78 case WINED3DFMT_X8D24_UNORM: return D3DFMT_D24X8;
79 case WINED3DFMT_S4X4_UINT_D24_UNORM: return D3DFMT_D24X4S4;
80 case WINED3DFMT_D16_UNORM: return D3DFMT_D16;
81 case WINED3DFMT_VERTEXDATA: return D3DFMT_VERTEXDATA;
82 case WINED3DFMT_R16_UINT: return D3DFMT_INDEX16;
83 case WINED3DFMT_R32_UINT: return D3DFMT_INDEX32;
84 default:
85 FIXME("Unhandled WINED3DFORMAT %#x\n", format);
86 return D3DFMT_UNKNOWN;
87 }
88 }
89
90 WINED3DFORMAT wined3dformat_from_d3dformat(D3DFORMAT format)
91 {
92 BYTE *c = (BYTE *)&format;
93
94 /* Don't translate FOURCC formats */
95 if (isprint(c[0]) && isprint(c[1]) && isprint(c[2]) && isprint(c[3])) return format;
96
97 switch(format)
98 {
99 case D3DFMT_UNKNOWN: return WINED3DFMT_UNKNOWN;
100 case D3DFMT_R8G8B8: return WINED3DFMT_B8G8R8_UNORM;
101 case D3DFMT_A8R8G8B8: return WINED3DFMT_B8G8R8A8_UNORM;
102 case D3DFMT_X8R8G8B8: return WINED3DFMT_B8G8R8X8_UNORM;
103 case D3DFMT_R5G6B5: return WINED3DFMT_B5G6R5_UNORM;
104 case D3DFMT_X1R5G5B5: return WINED3DFMT_B5G5R5X1_UNORM;
105 case D3DFMT_A1R5G5B5: return WINED3DFMT_B5G5R5A1_UNORM;
106 case D3DFMT_A4R4G4B4: return WINED3DFMT_B4G4R4A4_UNORM;
107 case D3DFMT_R3G3B2: return WINED3DFMT_B2G3R3_UNORM;
108 case D3DFMT_A8: return WINED3DFMT_A8_UNORM;
109 case D3DFMT_A8R3G3B2: return WINED3DFMT_B2G3R3A8_UNORM;
110 case D3DFMT_X4R4G4B4: return WINED3DFMT_B4G4R4X4_UNORM;
111 case D3DFMT_A2B10G10R10: return WINED3DFMT_R10G10B10A2_UNORM;
112 case D3DFMT_G16R16: return WINED3DFMT_R16G16_UNORM;
113 case D3DFMT_A8P8: return WINED3DFMT_P8_UINT_A8_UNORM;
114 case D3DFMT_P8: return WINED3DFMT_P8_UINT;
115 case D3DFMT_L8: return WINED3DFMT_L8_UNORM;
116 case D3DFMT_A8L8: return WINED3DFMT_L8A8_UNORM;
117 case D3DFMT_A4L4: return WINED3DFMT_L4A4_UNORM;
118 case D3DFMT_V8U8: return WINED3DFMT_R8G8_SNORM;
119 case D3DFMT_L6V5U5: return WINED3DFMT_R5G5_SNORM_L6_UNORM;
120 case D3DFMT_X8L8V8U8: return WINED3DFMT_R8G8_SNORM_L8X8_UNORM;
121 case D3DFMT_Q8W8V8U8: return WINED3DFMT_R8G8B8A8_SNORM;
122 case D3DFMT_V16U16: return WINED3DFMT_R16G16_SNORM;
123 case D3DFMT_W11V11U10: return WINED3DFMT_R10G11B11_SNORM;
124 case D3DFMT_A2W10V10U10: return WINED3DFMT_R10G10B10_SNORM_A2_UNORM;
125 case D3DFMT_D16_LOCKABLE: return WINED3DFMT_D16_LOCKABLE;
126 case D3DFMT_D32: return WINED3DFMT_D32_UNORM;
127 case D3DFMT_D15S1: return WINED3DFMT_S1_UINT_D15_UNORM;
128 case D3DFMT_D24S8: return WINED3DFMT_D24_UNORM_S8_UINT;
129 case D3DFMT_D24X8: return WINED3DFMT_X8D24_UNORM;
130 case D3DFMT_D24X4S4: return WINED3DFMT_S4X4_UINT_D24_UNORM;
131 case D3DFMT_D16: return WINED3DFMT_D16_UNORM;
132 case D3DFMT_VERTEXDATA: return WINED3DFMT_VERTEXDATA;
133 case D3DFMT_INDEX16: return WINED3DFMT_R16_UINT;
134 case D3DFMT_INDEX32: return WINED3DFMT_R32_UINT;
135 default:
136 FIXME("Unhandled D3DFORMAT %#x\n", format);
137 return WINED3DFMT_UNKNOWN;
138 }
139 }
140
141 static UINT vertex_count_from_primitive_count(D3DPRIMITIVETYPE primitive_type, UINT primitive_count)
142 {
143 switch(primitive_type)
144 {
145 case D3DPT_POINTLIST:
146 return primitive_count;
147
148 case D3DPT_LINELIST:
149 return primitive_count * 2;
150
151 case D3DPT_LINESTRIP:
152 return primitive_count + 1;
153
154 case D3DPT_TRIANGLELIST:
155 return primitive_count * 3;
156
157 case D3DPT_TRIANGLESTRIP:
158 case D3DPT_TRIANGLEFAN:
159 return primitive_count + 2;
160
161 default:
162 FIXME("Unhandled primitive type %#x\n", primitive_type);
163 return 0;
164 }
165 }
166
167 /* Handle table functions */
168 static DWORD d3d8_allocate_handle(struct d3d8_handle_table *t, void *object, enum d3d8_handle_type type)
169 {
170 struct d3d8_handle_entry *entry;
171
172 if (t->free_entries)
173 {
174 /* Use a free handle */
175 entry = t->free_entries;
176 if (entry->type != D3D8_HANDLE_FREE)
177 {
178 ERR("Handle %u(%p) is in the free list, but has type %#x.\n", (entry - t->entries), entry, entry->type);
179 return D3D8_INVALID_HANDLE;
180 }
181 t->free_entries = entry->object;
182 entry->object = object;
183 entry->type = type;
184
185 return entry - t->entries;
186 }
187
188 if (!(t->entry_count < t->table_size))
189 {
190 /* Grow the table */
191 UINT new_size = t->table_size + (t->table_size >> 1);
192 struct d3d8_handle_entry *new_entries = HeapReAlloc(GetProcessHeap(),
193 0, t->entries, new_size * sizeof(*t->entries));
194 if (!new_entries)
195 {
196 ERR("Failed to grow the handle table.\n");
197 return D3D8_INVALID_HANDLE;
198 }
199 t->entries = new_entries;
200 t->table_size = new_size;
201 }
202
203 entry = &t->entries[t->entry_count];
204 entry->object = object;
205 entry->type = type;
206
207 return t->entry_count++;
208 }
209
210 static void *d3d8_free_handle(struct d3d8_handle_table *t, DWORD handle, enum d3d8_handle_type type)
211 {
212 struct d3d8_handle_entry *entry;
213 void *object;
214
215 if (handle == D3D8_INVALID_HANDLE || handle >= t->entry_count)
216 {
217 WARN("Invalid handle %u passed.\n", handle);
218 return NULL;
219 }
220
221 entry = &t->entries[handle];
222 if (entry->type != type)
223 {
224 WARN("Handle %u(%p) is not of type %#x.\n", handle, entry, type);
225 return NULL;
226 }
227
228 object = entry->object;
229 entry->object = t->free_entries;
230 entry->type = D3D8_HANDLE_FREE;
231 t->free_entries = entry;
232
233 return object;
234 }
235
236 static void *d3d8_get_object(struct d3d8_handle_table *t, DWORD handle, enum d3d8_handle_type type)
237 {
238 struct d3d8_handle_entry *entry;
239
240 if (handle == D3D8_INVALID_HANDLE || handle >= t->entry_count)
241 {
242 WARN("Invalid handle %u passed.\n", handle);
243 return NULL;
244 }
245
246 entry = &t->entries[handle];
247 if (entry->type != type)
248 {
249 WARN("Handle %u(%p) is not of type %#x.\n", handle, entry, type);
250 return NULL;
251 }
252
253 return entry->object;
254 }
255
256 /* IDirect3D IUnknown parts follow: */
257 static HRESULT WINAPI IDirect3DDevice8Impl_QueryInterface(LPDIRECT3DDEVICE8 iface,REFIID riid,LPVOID *ppobj)
258 {
259 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
260
261 TRACE("iface %p, riid %s, object %p.\n",
262 iface, debugstr_guid(riid), ppobj);
263
264 if (IsEqualGUID(riid, &IID_IUnknown)
265 || IsEqualGUID(riid, &IID_IDirect3DDevice8)) {
266 IUnknown_AddRef(iface);
267 *ppobj = This;
268 return S_OK;
269 }
270
271 if (IsEqualGUID(riid, &IID_IWineD3DDeviceParent))
272 {
273 IUnknown_AddRef((IUnknown *)&This->device_parent_vtbl);
274 *ppobj = &This->device_parent_vtbl;
275 return S_OK;
276 }
277
278 WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
279 *ppobj = NULL;
280 return E_NOINTERFACE;
281 }
282
283 static ULONG WINAPI IDirect3DDevice8Impl_AddRef(LPDIRECT3DDEVICE8 iface) {
284 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
285 ULONG ref = InterlockedIncrement(&This->ref);
286
287 TRACE("%p increasing refcount to %u.\n", iface, ref);
288
289 return ref;
290 }
291
292 static ULONG WINAPI IDirect3DDevice8Impl_Release(LPDIRECT3DDEVICE8 iface) {
293 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
294 ULONG ref;
295
296 if (This->inDestruction) return 0;
297 ref = InterlockedDecrement(&This->ref);
298
299 TRACE("%p decreasing refcount to %u.\n", iface, ref);
300
301 if (ref == 0) {
302 unsigned i;
303
304 TRACE("Releasing wined3d device %p\n", This->WineD3DDevice);
305
306 wined3d_mutex_lock();
307
308 This->inDestruction = TRUE;
309
310 for(i = 0; i < This->numConvertedDecls; i++) {
311 IDirect3DVertexDeclaration8_Release(This->decls[i].decl);
312 }
313 HeapFree(GetProcessHeap(), 0, This->decls);
314
315 IWineD3DDevice_Uninit3D(This->WineD3DDevice, D3D8CB_DestroySwapChain);
316 IWineD3DDevice_Release(This->WineD3DDevice);
317 HeapFree(GetProcessHeap(), 0, This->handle_table.entries);
318 HeapFree(GetProcessHeap(), 0, This);
319
320 wined3d_mutex_unlock();
321 }
322 return ref;
323 }
324
325 /* IDirect3DDevice Interface follow: */
326 static HRESULT WINAPI IDirect3DDevice8Impl_TestCooperativeLevel(LPDIRECT3DDEVICE8 iface) {
327 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
328 HRESULT hr;
329
330 TRACE("iface %p.\n", iface);
331
332 wined3d_mutex_lock();
333 hr = IWineD3DDevice_TestCooperativeLevel(This->WineD3DDevice);
334 wined3d_mutex_unlock();
335
336 return hr;
337 }
338
339 static UINT WINAPI IDirect3DDevice8Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE8 iface) {
340 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
341 HRESULT hr;
342
343 TRACE("iface %p.\n", iface);
344
345 wined3d_mutex_lock();
346 hr = IWineD3DDevice_GetAvailableTextureMem(This->WineD3DDevice);
347 wined3d_mutex_unlock();
348
349 return hr;
350 }
351
352 static HRESULT WINAPI IDirect3DDevice8Impl_ResourceManagerDiscardBytes(LPDIRECT3DDEVICE8 iface, DWORD Bytes) {
353 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
354 HRESULT hr;
355
356 TRACE("iface %p, byte_count %u.\n", iface, Bytes);
357 FIXME("Byte count ignored.\n");
358
359 wined3d_mutex_lock();
360 hr = IWineD3DDevice_EvictManagedResources(This->WineD3DDevice);
361 wined3d_mutex_unlock();
362
363 return hr;
364 }
365
366 static HRESULT WINAPI IDirect3DDevice8Impl_GetDirect3D(LPDIRECT3DDEVICE8 iface, IDirect3D8** ppD3D8) {
367 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
368 HRESULT hr = D3D_OK;
369 IWineD3D* pWineD3D;
370
371 TRACE("iface %p, d3d8 %p.\n", iface, ppD3D8);
372
373 if (NULL == ppD3D8) {
374 return D3DERR_INVALIDCALL;
375 }
376
377 wined3d_mutex_lock();
378 hr = IWineD3DDevice_GetDirect3D(This->WineD3DDevice, &pWineD3D);
379 if (hr == D3D_OK && pWineD3D != NULL)
380 {
381 IWineD3D_GetParent(pWineD3D,(IUnknown **)ppD3D8);
382 IWineD3D_Release(pWineD3D);
383 } else {
384 FIXME("Call to IWineD3DDevice_GetDirect3D failed\n");
385 *ppD3D8 = NULL;
386 }
387 wined3d_mutex_unlock();
388
389 TRACE("(%p) returning %p\n",This , *ppD3D8);
390
391 return hr;
392 }
393
394 static HRESULT WINAPI IDirect3DDevice8Impl_GetDeviceCaps(LPDIRECT3DDEVICE8 iface, D3DCAPS8* pCaps) {
395 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
396 HRESULT hrc = D3D_OK;
397 WINED3DCAPS *pWineCaps;
398
399 TRACE("iface %p, caps %p.\n", iface, pCaps);
400
401 if(NULL == pCaps){
402 return D3DERR_INVALIDCALL;
403 }
404 pWineCaps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINED3DCAPS));
405 if(pWineCaps == NULL){
406 return D3DERR_INVALIDCALL; /* well this is what MSDN says to return */
407 }
408
409 wined3d_mutex_lock();
410 hrc = IWineD3DDevice_GetDeviceCaps(This->WineD3DDevice, pWineCaps);
411 wined3d_mutex_unlock();
412
413 fixup_caps(pWineCaps);
414 WINECAPSTOD3D8CAPS(pCaps, pWineCaps)
415 HeapFree(GetProcessHeap(), 0, pWineCaps);
416
417 TRACE("Returning %p %p\n", This, pCaps);
418 return hrc;
419 }
420
421 static HRESULT WINAPI IDirect3DDevice8Impl_GetDisplayMode(LPDIRECT3DDEVICE8 iface, D3DDISPLAYMODE* pMode) {
422 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
423 HRESULT hr;
424
425 TRACE("iface %p, mode %p.\n", iface, pMode);
426
427 wined3d_mutex_lock();
428 hr = IWineD3DDevice_GetDisplayMode(This->WineD3DDevice, 0, (WINED3DDISPLAYMODE *) pMode);
429 wined3d_mutex_unlock();
430
431 if (SUCCEEDED(hr)) pMode->Format = d3dformat_from_wined3dformat(pMode->Format);
432
433 return hr;
434 }
435
436 static HRESULT WINAPI IDirect3DDevice8Impl_GetCreationParameters(LPDIRECT3DDEVICE8 iface, D3DDEVICE_CREATION_PARAMETERS *pParameters) {
437 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
438 HRESULT hr;
439
440 TRACE("iface %p, parameters %p.\n", iface, pParameters);
441
442 wined3d_mutex_lock();
443 hr = IWineD3DDevice_GetCreationParameters(This->WineD3DDevice, (WINED3DDEVICE_CREATION_PARAMETERS *) pParameters);
444 wined3d_mutex_unlock();
445
446 return hr;
447 }
448
449 static HRESULT WINAPI IDirect3DDevice8Impl_SetCursorProperties(LPDIRECT3DDEVICE8 iface, UINT XHotSpot, UINT YHotSpot, IDirect3DSurface8* pCursorBitmap) {
450 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
451 IDirect3DSurface8Impl *pSurface = (IDirect3DSurface8Impl*)pCursorBitmap;
452 HRESULT hr;
453
454 TRACE("iface %p, hotspot_x %u, hotspot_y %u, bitmap %p.\n",
455 iface, XHotSpot, YHotSpot, pCursorBitmap);
456
457 if(!pCursorBitmap) {
458 WARN("No cursor bitmap, returning WINED3DERR_INVALIDCALL\n");
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 return hr;
467 }
468
469 static void WINAPI IDirect3DDevice8Impl_SetCursorPosition(LPDIRECT3DDEVICE8 iface, UINT XScreenSpace, UINT YScreenSpace, DWORD Flags) {
470 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
471
472 TRACE("iface %p, x %u, y %u, flags %#x.\n",
473 iface, XScreenSpace, YScreenSpace, Flags);
474
475 wined3d_mutex_lock();
476 IWineD3DDevice_SetCursorPosition(This->WineD3DDevice, XScreenSpace, YScreenSpace, Flags);
477 wined3d_mutex_unlock();
478 }
479
480 static BOOL WINAPI IDirect3DDevice8Impl_ShowCursor(LPDIRECT3DDEVICE8 iface, BOOL bShow) {
481 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)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
493 static HRESULT WINAPI IDirect3DDevice8Impl_CreateAdditionalSwapChain(LPDIRECT3DDEVICE8 iface, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain8** pSwapChain) {
494 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
495 IDirect3DSwapChain8Impl* object;
496 HRESULT hrc = D3D_OK;
497 WINED3DPRESENT_PARAMETERS localParameters;
498
499 TRACE("iface %p, present_parameters %p, swapchain %p.\n",
500 iface, pPresentationParameters, pSwapChain);
501
502 /* Fix the back buffer count */
503 if(pPresentationParameters->BackBufferCount == 0) {
504 pPresentationParameters->BackBufferCount = 1;
505 }
506
507 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
508 if (NULL == object) {
509 FIXME("Allocation of memory failed\n");
510 *pSwapChain = NULL;
511 return D3DERR_OUTOFVIDEOMEMORY;
512 }
513 object->ref = 1;
514 object->lpVtbl = &Direct3DSwapChain8_Vtbl;
515
516 /* Allocate an associated WineD3DDevice object */
517 localParameters.BackBufferWidth = pPresentationParameters->BackBufferWidth;
518 localParameters.BackBufferHeight = pPresentationParameters->BackBufferHeight;
519 localParameters.BackBufferFormat = wined3dformat_from_d3dformat(pPresentationParameters->BackBufferFormat);
520 localParameters.BackBufferCount = pPresentationParameters->BackBufferCount;
521 localParameters.MultiSampleType = pPresentationParameters->MultiSampleType;
522 localParameters.MultiSampleQuality = 0; /* d3d9 only */
523 localParameters.SwapEffect = pPresentationParameters->SwapEffect;
524 localParameters.hDeviceWindow = pPresentationParameters->hDeviceWindow;
525 localParameters.Windowed = pPresentationParameters->Windowed;
526 localParameters.EnableAutoDepthStencil = pPresentationParameters->EnableAutoDepthStencil;
527 localParameters.AutoDepthStencilFormat = wined3dformat_from_d3dformat(pPresentationParameters->AutoDepthStencilFormat);
528 localParameters.Flags = pPresentationParameters->Flags;
529 localParameters.FullScreen_RefreshRateInHz = pPresentationParameters->FullScreen_RefreshRateInHz;
530 localParameters.PresentationInterval = pPresentationParameters->FullScreen_PresentationInterval;
531 localParameters.AutoRestoreDisplayMode = TRUE;
532
533 wined3d_mutex_lock();
534 hrc = IWineD3DDevice_CreateSwapChain(This->WineD3DDevice, &localParameters,
535 &object->wineD3DSwapChain, (IUnknown *)object, SURFACE_OPENGL);
536 wined3d_mutex_unlock();
537
538 pPresentationParameters->BackBufferWidth = localParameters.BackBufferWidth;
539 pPresentationParameters->BackBufferHeight = localParameters.BackBufferHeight;
540 pPresentationParameters->BackBufferFormat = d3dformat_from_wined3dformat(localParameters.BackBufferFormat);
541 pPresentationParameters->BackBufferCount = localParameters.BackBufferCount;
542 pPresentationParameters->MultiSampleType = localParameters.MultiSampleType;
543 pPresentationParameters->SwapEffect = localParameters.SwapEffect;
544 pPresentationParameters->hDeviceWindow = localParameters.hDeviceWindow;
545 pPresentationParameters->Windowed = localParameters.Windowed;
546 pPresentationParameters->EnableAutoDepthStencil = localParameters.EnableAutoDepthStencil;
547 pPresentationParameters->AutoDepthStencilFormat = d3dformat_from_wined3dformat(localParameters.AutoDepthStencilFormat);
548 pPresentationParameters->Flags = localParameters.Flags;
549 pPresentationParameters->FullScreen_RefreshRateInHz = localParameters.FullScreen_RefreshRateInHz;
550 pPresentationParameters->FullScreen_PresentationInterval = localParameters.PresentationInterval;
551
552 if (hrc != D3D_OK) {
553 FIXME("(%p) call to IWineD3DDevice_CreateSwapChain failed\n", This);
554 HeapFree(GetProcessHeap(), 0 , object);
555 *pSwapChain = NULL;
556 }else{
557 IUnknown_AddRef(iface);
558 object->parentDevice = iface;
559 *pSwapChain = (IDirect3DSwapChain8 *)object;
560 }
561 TRACE("(%p) returning %p\n", This, *pSwapChain);
562 return hrc;
563 }
564
565 static HRESULT WINAPI IDirect3DDevice8Impl_Reset(LPDIRECT3DDEVICE8 iface, D3DPRESENT_PARAMETERS* pPresentationParameters) {
566 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
567 WINED3DPRESENT_PARAMETERS localParameters;
568 HRESULT hr;
569
570 TRACE("iface %p, present_parameters %p.\n", iface, pPresentationParameters);
571
572 localParameters.BackBufferWidth = pPresentationParameters->BackBufferWidth;
573 localParameters.BackBufferHeight = pPresentationParameters->BackBufferHeight;
574 localParameters.BackBufferFormat = wined3dformat_from_d3dformat(pPresentationParameters->BackBufferFormat);
575 localParameters.BackBufferCount = pPresentationParameters->BackBufferCount;
576 localParameters.MultiSampleType = pPresentationParameters->MultiSampleType;
577 localParameters.MultiSampleQuality = 0; /* d3d9 only */
578 localParameters.SwapEffect = pPresentationParameters->SwapEffect;
579 localParameters.hDeviceWindow = pPresentationParameters->hDeviceWindow;
580 localParameters.Windowed = pPresentationParameters->Windowed;
581 localParameters.EnableAutoDepthStencil = pPresentationParameters->EnableAutoDepthStencil;
582 localParameters.AutoDepthStencilFormat = wined3dformat_from_d3dformat(pPresentationParameters->AutoDepthStencilFormat);
583 localParameters.Flags = pPresentationParameters->Flags;
584 localParameters.FullScreen_RefreshRateInHz = pPresentationParameters->FullScreen_RefreshRateInHz;
585 localParameters.PresentationInterval = pPresentationParameters->FullScreen_PresentationInterval;
586 localParameters.AutoRestoreDisplayMode = TRUE;
587
588 wined3d_mutex_lock();
589 hr = IWineD3DDevice_Reset(This->WineD3DDevice, &localParameters);
590 wined3d_mutex_unlock();
591
592 pPresentationParameters->BackBufferWidth = localParameters.BackBufferWidth;
593 pPresentationParameters->BackBufferHeight = localParameters.BackBufferHeight;
594 pPresentationParameters->BackBufferFormat = d3dformat_from_wined3dformat(localParameters.BackBufferFormat);
595 pPresentationParameters->BackBufferCount = localParameters.BackBufferCount;
596 pPresentationParameters->MultiSampleType = localParameters.MultiSampleType;
597 pPresentationParameters->SwapEffect = localParameters.SwapEffect;
598 pPresentationParameters->hDeviceWindow = localParameters.hDeviceWindow;
599 pPresentationParameters->Windowed = localParameters.Windowed;
600 pPresentationParameters->EnableAutoDepthStencil = localParameters.EnableAutoDepthStencil;
601 pPresentationParameters->AutoDepthStencilFormat = d3dformat_from_wined3dformat(localParameters.AutoDepthStencilFormat);
602 pPresentationParameters->Flags = localParameters.Flags;
603 pPresentationParameters->FullScreen_RefreshRateInHz = localParameters.FullScreen_RefreshRateInHz;
604 pPresentationParameters->FullScreen_PresentationInterval = localParameters.PresentationInterval;
605
606 return hr;
607 }
608
609 static HRESULT WINAPI IDirect3DDevice8Impl_Present(LPDIRECT3DDEVICE8 iface, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) {
610 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
611 HRESULT hr;
612
613 TRACE("iface %p, src_rect %p, dst_rect %p, dst_window_override %p, dirty_region %p.\n",
614 iface, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
615
616 wined3d_mutex_lock();
617 hr = IWineD3DDevice_Present(This->WineD3DDevice, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
618 wined3d_mutex_unlock();
619
620 return hr;
621 }
622
623 static HRESULT WINAPI IDirect3DDevice8Impl_GetBackBuffer(LPDIRECT3DDEVICE8 iface, UINT BackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface8** ppBackBuffer) {
624 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
625 IWineD3DSurface *retSurface = NULL;
626 HRESULT rc = D3D_OK;
627
628 TRACE("iface %p, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n",
629 iface, BackBuffer, Type, ppBackBuffer);
630
631 wined3d_mutex_lock();
632 rc = IWineD3DDevice_GetBackBuffer(This->WineD3DDevice, 0, BackBuffer, (WINED3DBACKBUFFER_TYPE) Type, &retSurface);
633 if (rc == D3D_OK && NULL != retSurface && NULL != ppBackBuffer) {
634 IWineD3DSurface_GetParent(retSurface, (IUnknown **)ppBackBuffer);
635 IWineD3DSurface_Release(retSurface);
636 }
637 wined3d_mutex_unlock();
638
639 return rc;
640 }
641
642 static HRESULT WINAPI IDirect3DDevice8Impl_GetRasterStatus(LPDIRECT3DDEVICE8 iface, D3DRASTER_STATUS* pRasterStatus) {
643 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
644 HRESULT hr;
645
646 TRACE("iface %p, raster_status %p.\n", iface, pRasterStatus);
647
648 wined3d_mutex_lock();
649 hr = IWineD3DDevice_GetRasterStatus(This->WineD3DDevice, 0, (WINED3DRASTER_STATUS *) pRasterStatus);
650 wined3d_mutex_unlock();
651
652 return hr;
653 }
654
655 static void WINAPI IDirect3DDevice8Impl_SetGammaRamp(LPDIRECT3DDEVICE8 iface, DWORD Flags, CONST D3DGAMMARAMP* pRamp) {
656 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
657
658 TRACE("iface %p, flags %#x, ramp %p.\n", iface, Flags, pRamp);
659
660 /* Note: D3DGAMMARAMP is compatible with WINED3DGAMMARAMP */
661 wined3d_mutex_lock();
662 IWineD3DDevice_SetGammaRamp(This->WineD3DDevice, 0, Flags, (CONST WINED3DGAMMARAMP *) pRamp);
663 wined3d_mutex_unlock();
664 }
665
666 static void WINAPI IDirect3DDevice8Impl_GetGammaRamp(LPDIRECT3DDEVICE8 iface, D3DGAMMARAMP* pRamp) {
667 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
668
669 TRACE("iface %p, ramp %p.\n", iface, pRamp);
670
671 /* Note: D3DGAMMARAMP is compatible with WINED3DGAMMARAMP */
672 wined3d_mutex_lock();
673 IWineD3DDevice_GetGammaRamp(This->WineD3DDevice, 0, (WINED3DGAMMARAMP *) pRamp);
674 wined3d_mutex_unlock();
675 }
676
677 static HRESULT WINAPI IDirect3DDevice8Impl_CreateTexture(IDirect3DDevice8 *iface,
678 UINT width, UINT height, UINT levels, DWORD usage, D3DFORMAT format,
679 D3DPOOL pool, IDirect3DTexture8 **texture)
680 {
681 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
682 IDirect3DTexture8Impl *object;
683 HRESULT hr;
684
685 TRACE("iface %p, width %u, height %u, levels %u, usage %#x, format %#x, pool %#x, texture %p.\n",
686 iface, width, height, levels, usage, format, pool, texture);
687
688 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
689 if (!object)
690 {
691 ERR("Failed to allocate texture memory.\n");
692 return D3DERR_OUTOFVIDEOMEMORY;
693 }
694
695 hr = texture_init(object, This, width, height, levels, usage, format, pool);
696 if (FAILED(hr))
697 {
698 WARN("Failed to initialize texture, hr %#x.\n", hr);
699 HeapFree(GetProcessHeap(), 0, object);
700 return hr;
701 }
702
703 TRACE("Created texture %p.\n", object);
704 *texture = (IDirect3DTexture8 *)object;
705
706 return D3D_OK;
707 }
708
709 static HRESULT WINAPI IDirect3DDevice8Impl_CreateVolumeTexture(IDirect3DDevice8 *iface,
710 UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format,
711 D3DPOOL pool, IDirect3DVolumeTexture8 **texture)
712 {
713 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
714 IDirect3DVolumeTexture8Impl *object;
715 HRESULT hr;
716
717 TRACE("iface %p, width %u, height %u, depth %u, levels %u, usage %#x, format %#x, pool %#x, texture %p.\n",
718 iface, width, height, depth, levels, usage, format, pool, texture);
719
720 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
721 if (!object)
722 {
723 ERR("Failed to allocate volume texture memory.\n");
724 return D3DERR_OUTOFVIDEOMEMORY;
725 }
726
727 hr = volumetexture_init(object, This, width, height, depth, levels, usage, format, pool);
728 if (FAILED(hr))
729 {
730 WARN("Failed to initialize volume texture, hr %#x.\n", hr);
731 HeapFree(GetProcessHeap(), 0, object);
732 return hr;
733 }
734
735 TRACE("Created volume texture %p.\n", object);
736 *texture = (IDirect3DVolumeTexture8 *)object;
737
738 return D3D_OK;
739 }
740
741 static HRESULT WINAPI IDirect3DDevice8Impl_CreateCubeTexture(IDirect3DDevice8 *iface, UINT edge_length,
742 UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool, IDirect3DCubeTexture8 **texture)
743 {
744 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
745 IDirect3DCubeTexture8Impl *object;
746 HRESULT hr;
747
748 TRACE("iface %p, edge_length %u, levels %u, usage %#x, format %#x, pool %#x, texture %p.\n",
749 iface, edge_length, levels, usage, format, pool, texture);
750
751 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
752 if (!object)
753 {
754 ERR("Failed to allocate cube texture memory.\n");
755 return D3DERR_OUTOFVIDEOMEMORY;
756 }
757
758 hr = cubetexture_init(object, This, edge_length, levels, usage, format, pool);
759 if (FAILED(hr))
760 {
761 WARN("Failed to initialize cube texture, hr %#x.\n", hr);
762 HeapFree(GetProcessHeap(), 0, object);
763 return hr;
764 }
765
766 TRACE("Created cube texture %p.\n", object);
767 *texture = (IDirect3DCubeTexture8 *)object;
768
769 return hr;
770 }
771
772 static HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexBuffer(IDirect3DDevice8 *iface, UINT size, DWORD usage,
773 DWORD fvf, D3DPOOL pool, IDirect3DVertexBuffer8 **buffer)
774 {
775 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
776 IDirect3DVertexBuffer8Impl *object;
777 HRESULT hr;
778
779 TRACE("iface %p, size %u, usage %#x, fvf %#x, pool %#x, buffer %p.\n",
780 iface, size, usage, fvf, pool, buffer);
781
782 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
783 if (!object)
784 {
785 ERR("Failed to allocate buffer memory.\n");
786 return D3DERR_OUTOFVIDEOMEMORY;
787 }
788
789 hr = vertexbuffer_init(object, This, size, usage, fvf, pool);
790 if (FAILED(hr))
791 {
792 WARN("Failed to initialize vertex buffer, hr %#x.\n", hr);
793 HeapFree(GetProcessHeap(), 0, object);
794 return hr;
795 }
796
797 TRACE("Created vertex buffer %p.\n", object);
798 *buffer = (IDirect3DVertexBuffer8 *)object;
799
800 return D3D_OK;
801 }
802
803 static HRESULT WINAPI IDirect3DDevice8Impl_CreateIndexBuffer(IDirect3DDevice8 *iface, UINT size, DWORD usage,
804 D3DFORMAT format, D3DPOOL pool, IDirect3DIndexBuffer8 **buffer)
805 {
806 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
807 IDirect3DIndexBuffer8Impl *object;
808 HRESULT hr;
809
810 TRACE("iface %p, size %u, usage %#x, format %#x, pool %#x, buffer %p.\n",
811 iface, size, usage, format, pool, buffer);
812
813 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
814 if (!object)
815 {
816 ERR("Failed to allocate buffer memory.\n");
817 return D3DERR_OUTOFVIDEOMEMORY;
818 }
819
820 hr = indexbuffer_init(object, This, size, usage, format, pool);
821 if (FAILED(hr))
822 {
823 WARN("Failed to initialize index buffer, hr %#x.\n", hr);
824 HeapFree(GetProcessHeap(), 0, object);
825 return hr;
826 }
827
828 TRACE("Created index buffer %p.\n", object);
829 *buffer = (IDirect3DIndexBuffer8 *)object;
830
831 return D3D_OK;
832 }
833
834 static HRESULT IDirect3DDevice8Impl_CreateSurface(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height,
835 D3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IDirect3DSurface8 **ppSurface,
836 UINT Usage, D3DPOOL Pool, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality)
837 {
838 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
839 IDirect3DSurface8Impl *object;
840 HRESULT hr;
841
842 TRACE("iface %p, width %u, height %u, format %#x, lockable %#x, discard %#x, level %u, surface %p,\n"
843 "\tusage %#x, pool %#x, multisample_type %#x, multisample_quality %u.\n",
844 iface, Width, Height, Format, Lockable, Discard, Level, ppSurface,
845 Usage, Pool, MultiSample, MultisampleQuality);
846
847 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DSurface8Impl));
848 if (!object)
849 {
850 FIXME("Failed to allocate surface memory.\n");
851 return D3DERR_OUTOFVIDEOMEMORY;
852 }
853
854 hr = surface_init(object, This, Width, Height, Format, Lockable, Discard,
855 Level, Usage, Pool, MultiSample, MultisampleQuality);
856 if (FAILED(hr))
857 {
858 WARN("Failed to initialize surface, hr %#x.\n", hr);
859 HeapFree(GetProcessHeap(), 0, object);
860 return hr;
861 }
862
863 TRACE("Created surface %p.\n", object);
864 *ppSurface = (IDirect3DSurface8 *)object;
865
866 return D3D_OK;
867 }
868
869 static HRESULT WINAPI IDirect3DDevice8Impl_CreateRenderTarget(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, BOOL Lockable, IDirect3DSurface8** ppSurface) {
870 HRESULT hr;
871
872 TRACE("iface %p, width %u, height %u, format %#x, multisample_type %#x, lockable %#x, surface %p.\n",
873 iface, Width, Height, Format, MultiSample, Lockable, ppSurface);
874
875 hr = IDirect3DDevice8Impl_CreateSurface(iface, Width, Height, Format, Lockable, FALSE /* Discard */,
876 0 /* Level */, ppSurface, D3DUSAGE_RENDERTARGET, D3DPOOL_DEFAULT, MultiSample, 0);
877
878 return hr;
879 }
880
881 static HRESULT WINAPI IDirect3DDevice8Impl_CreateDepthStencilSurface(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, IDirect3DSurface8** ppSurface) {
882 HRESULT hr;
883
884 TRACE("iface %p, width %u, height %u, format %#x, multisample_type %#x, surface %p.\n",
885 iface, Width, Height, Format, MultiSample, ppSurface);
886
887 /* TODO: Verify that Discard is false */
888 hr = IDirect3DDevice8Impl_CreateSurface(iface, Width, Height, Format, TRUE /* Lockable */, FALSE,
889 0 /* Level */, ppSurface, D3DUSAGE_DEPTHSTENCIL, D3DPOOL_DEFAULT, MultiSample, 0);
890
891 return hr;
892 }
893
894 /* IDirect3DDevice8Impl::CreateImageSurface returns surface with pool type SYSTEMMEM */
895 static HRESULT WINAPI IDirect3DDevice8Impl_CreateImageSurface(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, IDirect3DSurface8** ppSurface) {
896 HRESULT hr;
897
898 TRACE("iface %p, width %u, height %u, format %#x, surface %p.\n",
899 iface, Width, Height, Format, ppSurface);
900
901 hr = IDirect3DDevice8Impl_CreateSurface(iface, Width, Height, Format, TRUE /* Lockable */, FALSE /* Discard */,
902 0 /* Level */, ppSurface, 0 /* Usage (undefined/none) */, D3DPOOL_SYSTEMMEM, D3DMULTISAMPLE_NONE,
903 0 /* MultisampleQuality */);
904
905 return hr;
906 }
907
908 static HRESULT WINAPI IDirect3DDevice8Impl_CopyRects(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8 *pSourceSurface, CONST RECT *pSourceRects, UINT cRects, IDirect3DSurface8 *pDestinationSurface, CONST POINT *pDestPoints) {
909 IDirect3DSurface8Impl *Source = (IDirect3DSurface8Impl *) pSourceSurface;
910 IDirect3DSurface8Impl *Dest = (IDirect3DSurface8Impl *) pDestinationSurface;
911
912 HRESULT hr = WINED3D_OK;
913 WINED3DFORMAT srcFormat, destFormat;
914 WINED3DSURFACE_DESC winedesc;
915
916 TRACE("iface %p, src_surface %p, src_rects %p, rect_count %u, dst_surface %p, dst_points %p.\n",
917 iface, pSourceSurface, pSourceRects, cRects, pDestinationSurface, pDestPoints);
918
919 /* Check that the source texture is in WINED3DPOOL_SYSTEMMEM and the
920 * destination texture is in WINED3DPOOL_DEFAULT. */
921
922 wined3d_mutex_lock();
923 IWineD3DSurface_GetDesc(Source->wineD3DSurface, &winedesc);
924 srcFormat = winedesc.format;
925
926 IWineD3DSurface_GetDesc(Dest->wineD3DSurface, &winedesc);
927 destFormat = winedesc.format;
928
929 /* Check that the source and destination formats match */
930 if (srcFormat != destFormat && WINED3DFMT_UNKNOWN != destFormat) {
931 WARN("(%p) source %p format must match the dest %p format, returning WINED3DERR_INVALIDCALL\n", iface, pSourceSurface, pDestinationSurface);
932 wined3d_mutex_unlock();
933 return WINED3DERR_INVALIDCALL;
934 } else if (WINED3DFMT_UNKNOWN == destFormat) {
935 TRACE("(%p) : Converting destination surface from WINED3DFMT_UNKNOWN to the source format\n", iface);
936 IWineD3DSurface_SetFormat(Dest->wineD3DSurface, srcFormat);
937 }
938
939 /* Quick if complete copy ... */
940 if (cRects == 0 && pSourceRects == NULL && pDestPoints == NULL) {
941 IWineD3DSurface_BltFast(Dest->wineD3DSurface, 0, 0, Source->wineD3DSurface, NULL, WINEDDBLTFAST_NOCOLORKEY);
942 } else {
943 unsigned int i;
944 /* Copy rect by rect */
945 if (NULL != pSourceRects && NULL != pDestPoints) {
946 for (i = 0; i < cRects; ++i) {
947 IWineD3DSurface_BltFast(Dest->wineD3DSurface, pDestPoints[i].x, pDestPoints[i].y, Source->wineD3DSurface, &pSourceRects[i], WINEDDBLTFAST_NOCOLORKEY);
948 }
949 } else {
950 for (i = 0; i < cRects; ++i) {
951 IWineD3DSurface_BltFast(Dest->wineD3DSurface, 0, 0, Source->wineD3DSurface, &pSourceRects[i], WINEDDBLTFAST_NOCOLORKEY);
952 }
953 }
954 }
955 wined3d_mutex_unlock();
956
957 return hr;
958 }
959
960 static HRESULT WINAPI IDirect3DDevice8Impl_UpdateTexture(LPDIRECT3DDEVICE8 iface, IDirect3DBaseTexture8* pSourceTexture, IDirect3DBaseTexture8* pDestinationTexture) {
961 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
962 HRESULT hr;
963
964 TRACE("iface %p, src_texture %p, dst_texture %p.\n", iface, pSourceTexture, pDestinationTexture);
965
966 wined3d_mutex_lock();
967 hr = IWineD3DDevice_UpdateTexture(This->WineD3DDevice, ((IDirect3DBaseTexture8Impl *)pSourceTexture)->wineD3DBaseTexture, ((IDirect3DBaseTexture8Impl *)pDestinationTexture)->wineD3DBaseTexture);
968 wined3d_mutex_unlock();
969
970 return hr;
971 }
972
973 static HRESULT WINAPI IDirect3DDevice8Impl_GetFrontBuffer(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pDestSurface) {
974 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
975 IDirect3DSurface8Impl *destSurface = (IDirect3DSurface8Impl *)pDestSurface;
976 HRESULT hr;
977
978 TRACE("iface %p, dst_surface %p.\n", iface, pDestSurface);
979
980 if (pDestSurface == NULL) {
981 WARN("(%p) : Caller passed NULL as pDestSurface returning D3DERR_INVALIDCALL\n", This);
982 return D3DERR_INVALIDCALL;
983 }
984
985 wined3d_mutex_lock();
986 hr = IWineD3DDevice_GetFrontBufferData(This->WineD3DDevice, 0, destSurface->wineD3DSurface);
987 wined3d_mutex_unlock();
988
989 return hr;
990 }
991
992 static HRESULT WINAPI IDirect3DDevice8Impl_SetRenderTarget(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pRenderTarget, IDirect3DSurface8* pNewZStencil) {
993 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
994 IDirect3DSurface8Impl *pSurface = (IDirect3DSurface8Impl *)pRenderTarget;
995 IDirect3DSurface8Impl *pZSurface = (IDirect3DSurface8Impl *)pNewZStencil;
996 IWineD3DSurface *original_ds = NULL;
997 HRESULT hr;
998
999 TRACE("iface %p, render_target %p, depth_stencil %p.\n", iface, pRenderTarget, pNewZStencil);
1000
1001 wined3d_mutex_lock();
1002
1003 hr = IWineD3DDevice_GetDepthStencilSurface(This->WineD3DDevice, &original_ds);
1004 if (hr == WINED3D_OK || hr == WINED3DERR_NOTFOUND)
1005 {
1006 hr = IWineD3DDevice_SetDepthStencilSurface(This->WineD3DDevice, pZSurface ? pZSurface->wineD3DSurface : NULL);
1007 if (SUCCEEDED(hr) && pSurface)
1008 hr = IWineD3DDevice_SetRenderTarget(This->WineD3DDevice, 0, pSurface->wineD3DSurface);
1009 if (FAILED(hr)) IWineD3DDevice_SetDepthStencilSurface(This->WineD3DDevice, original_ds);
1010 }
1011 if (original_ds) IWineD3DSurface_Release(original_ds);
1012
1013 wined3d_mutex_unlock();
1014
1015 return hr;
1016 }
1017
1018 static HRESULT WINAPI IDirect3DDevice8Impl_GetRenderTarget(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8** ppRenderTarget) {
1019 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1020 HRESULT hr = D3D_OK;
1021 IWineD3DSurface *pRenderTarget;
1022
1023 TRACE("iface %p, render_target %p.\n", iface, ppRenderTarget);
1024
1025 if (ppRenderTarget == NULL) {
1026 return D3DERR_INVALIDCALL;
1027 }
1028
1029 wined3d_mutex_lock();
1030 hr = IWineD3DDevice_GetRenderTarget(This->WineD3DDevice, 0, &pRenderTarget);
1031
1032 if (hr == D3D_OK && pRenderTarget != NULL) {
1033 IWineD3DSurface_GetParent(pRenderTarget,(IUnknown**)ppRenderTarget);
1034 IWineD3DSurface_Release(pRenderTarget);
1035 } else {
1036 FIXME("Call to IWineD3DDevice_GetRenderTarget failed\n");
1037 *ppRenderTarget = NULL;
1038 }
1039 wined3d_mutex_unlock();
1040
1041 return hr;
1042 }
1043
1044 static HRESULT WINAPI IDirect3DDevice8Impl_GetDepthStencilSurface(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8** ppZStencilSurface) {
1045 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1046 HRESULT hr = D3D_OK;
1047 IWineD3DSurface *pZStencilSurface;
1048
1049 TRACE("iface %p, depth_stencil %p.\n", iface, ppZStencilSurface);
1050
1051 if(ppZStencilSurface == NULL){
1052 return D3DERR_INVALIDCALL;
1053 }
1054
1055 wined3d_mutex_lock();
1056 hr=IWineD3DDevice_GetDepthStencilSurface(This->WineD3DDevice,&pZStencilSurface);
1057 if (hr == WINED3D_OK) {
1058 IWineD3DSurface_GetParent(pZStencilSurface,(IUnknown**)ppZStencilSurface);
1059 IWineD3DSurface_Release(pZStencilSurface);
1060 }else{
1061 if (hr != WINED3DERR_NOTFOUND)
1062 FIXME("Call to IWineD3DDevice_GetDepthStencilSurface failed with 0x%08x\n", hr);
1063 *ppZStencilSurface = NULL;
1064 }
1065 wined3d_mutex_unlock();
1066
1067 return hr;
1068 }
1069
1070 static HRESULT WINAPI IDirect3DDevice8Impl_BeginScene(LPDIRECT3DDEVICE8 iface) {
1071 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1072 HRESULT hr;
1073
1074 TRACE("iface %p.\n", iface);
1075
1076 wined3d_mutex_lock();
1077 hr = IWineD3DDevice_BeginScene(This->WineD3DDevice);
1078 wined3d_mutex_unlock();
1079
1080 return hr;
1081 }
1082
1083 static HRESULT WINAPI DECLSPEC_HOTPATCH IDirect3DDevice8Impl_EndScene(LPDIRECT3DDEVICE8 iface) {
1084 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1085 HRESULT hr;
1086
1087 TRACE("iface %p.\n", iface);
1088
1089 wined3d_mutex_lock();
1090 hr = IWineD3DDevice_EndScene(This->WineD3DDevice);
1091 wined3d_mutex_unlock();
1092
1093 return hr;
1094 }
1095
1096 static HRESULT WINAPI IDirect3DDevice8Impl_Clear(LPDIRECT3DDEVICE8 iface, DWORD Count, CONST D3DRECT* pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil) {
1097 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1098 HRESULT hr;
1099
1100 TRACE("iface %p, rect_count %u, rects %p, flags %#x, color 0x%08x, z %.8e, stencil %u.\n",
1101 iface, Count, pRects, Flags, Color, Z, Stencil);
1102
1103 /* Note: D3DRECT is compatible with WINED3DRECT */
1104 wined3d_mutex_lock();
1105 hr = IWineD3DDevice_Clear(This->WineD3DDevice, Count, (CONST WINED3DRECT*) pRects, Flags, Color, Z, Stencil);
1106 wined3d_mutex_unlock();
1107
1108 return hr;
1109 }
1110
1111 static HRESULT WINAPI IDirect3DDevice8Impl_SetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* lpMatrix) {
1112 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1113 HRESULT hr;
1114
1115 TRACE("iface %p, state %#x, matrix %p.\n", iface, State, lpMatrix);
1116
1117 /* Note: D3DMATRIX is compatible with WINED3DMATRIX */
1118 wined3d_mutex_lock();
1119 hr = IWineD3DDevice_SetTransform(This->WineD3DDevice, State, (CONST WINED3DMATRIX*) lpMatrix);
1120 wined3d_mutex_unlock();
1121
1122 return hr;
1123 }
1124
1125 static HRESULT WINAPI IDirect3DDevice8Impl_GetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix) {
1126 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1127 HRESULT hr;
1128
1129 TRACE("iface %p, state %#x, matrix %p.\n", iface, State, pMatrix);
1130
1131 /* Note: D3DMATRIX is compatible with WINED3DMATRIX */
1132 wined3d_mutex_lock();
1133 hr = IWineD3DDevice_GetTransform(This->WineD3DDevice, State, (WINED3DMATRIX*) pMatrix);
1134 wined3d_mutex_unlock();
1135
1136 return hr;
1137 }
1138
1139 static HRESULT WINAPI IDirect3DDevice8Impl_MultiplyTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix) {
1140 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1141 HRESULT hr;
1142
1143 TRACE("iface %p, state %#x, matrix %p.\n", iface, State, pMatrix);
1144
1145 /* Note: D3DMATRIX is compatible with WINED3DMATRIX */
1146 wined3d_mutex_lock();
1147 hr = IWineD3DDevice_MultiplyTransform(This->WineD3DDevice, State, (CONST WINED3DMATRIX*) pMatrix);
1148 wined3d_mutex_unlock();
1149
1150 return hr;
1151 }
1152
1153 static HRESULT WINAPI IDirect3DDevice8Impl_SetViewport(LPDIRECT3DDEVICE8 iface, CONST D3DVIEWPORT8* pViewport) {
1154 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1155 HRESULT hr;
1156
1157 TRACE("iface %p, viewport %p.\n", iface, pViewport);
1158
1159 /* Note: D3DVIEWPORT8 is compatible with WINED3DVIEWPORT */
1160 wined3d_mutex_lock();
1161 hr = IWineD3DDevice_SetViewport(This->WineD3DDevice, (const WINED3DVIEWPORT *)pViewport);
1162 wined3d_mutex_unlock();
1163
1164 return hr;
1165 }
1166
1167 static HRESULT WINAPI IDirect3DDevice8Impl_GetViewport(LPDIRECT3DDEVICE8 iface, D3DVIEWPORT8* pViewport) {
1168 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1169 HRESULT hr;
1170
1171 TRACE("iface %p, viewport %p.\n", iface, pViewport);
1172
1173 /* Note: D3DVIEWPORT8 is compatible with WINED3DVIEWPORT */
1174 wined3d_mutex_lock();
1175 hr = IWineD3DDevice_GetViewport(This->WineD3DDevice, (WINED3DVIEWPORT *)pViewport);
1176 wined3d_mutex_unlock();
1177
1178 return hr;
1179 }
1180
1181 static HRESULT WINAPI IDirect3DDevice8Impl_SetMaterial(LPDIRECT3DDEVICE8 iface, CONST D3DMATERIAL8* pMaterial) {
1182 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1183 HRESULT hr;
1184
1185 TRACE("iface %p, material %p.\n", iface, pMaterial);
1186
1187 /* Note: D3DMATERIAL8 is compatible with WINED3DMATERIAL */
1188 wined3d_mutex_lock();
1189 hr = IWineD3DDevice_SetMaterial(This->WineD3DDevice, (const WINED3DMATERIAL *)pMaterial);
1190 wined3d_mutex_unlock();
1191
1192 return hr;
1193 }
1194
1195 static HRESULT WINAPI IDirect3DDevice8Impl_GetMaterial(LPDIRECT3DDEVICE8 iface, D3DMATERIAL8* pMaterial) {
1196 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1197 HRESULT hr;
1198
1199 TRACE("iface %p, material %p.\n", iface, pMaterial);
1200
1201 /* Note: D3DMATERIAL8 is compatible with WINED3DMATERIAL */
1202 wined3d_mutex_lock();
1203 hr = IWineD3DDevice_GetMaterial(This->WineD3DDevice, (WINED3DMATERIAL *)pMaterial);
1204 wined3d_mutex_unlock();
1205
1206 return hr;
1207 }
1208
1209 static HRESULT WINAPI IDirect3DDevice8Impl_SetLight(LPDIRECT3DDEVICE8 iface, DWORD Index, CONST D3DLIGHT8* pLight) {
1210 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1211 HRESULT hr;
1212
1213 TRACE("iface %p, index %u, light %p.\n", iface, Index, pLight);
1214
1215 /* Note: D3DLIGHT8 is compatible with WINED3DLIGHT */
1216 wined3d_mutex_lock();
1217 hr = IWineD3DDevice_SetLight(This->WineD3DDevice, Index, (const WINED3DLIGHT *)pLight);
1218 wined3d_mutex_unlock();
1219
1220 return hr;
1221 }
1222
1223 static HRESULT WINAPI IDirect3DDevice8Impl_GetLight(LPDIRECT3DDEVICE8 iface, DWORD Index,D3DLIGHT8* pLight) {
1224 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1225 HRESULT hr;
1226
1227 TRACE("iface %p, index %u, light %p.\n", iface, Index, pLight);
1228
1229 /* Note: D3DLIGHT8 is compatible with WINED3DLIGHT */
1230 wined3d_mutex_lock();
1231 hr = IWineD3DDevice_GetLight(This->WineD3DDevice, Index, (WINED3DLIGHT *)pLight);
1232 wined3d_mutex_unlock();
1233
1234 return hr;
1235 }
1236
1237 static HRESULT WINAPI IDirect3DDevice8Impl_LightEnable(LPDIRECT3DDEVICE8 iface, DWORD Index,BOOL Enable) {
1238 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1239 HRESULT hr;
1240
1241 TRACE("iface %p, index %u, enable %#x.\n", iface, Index, Enable);
1242
1243 wined3d_mutex_lock();
1244 hr = IWineD3DDevice_SetLightEnable(This->WineD3DDevice, Index, Enable);
1245 wined3d_mutex_unlock();
1246
1247 return hr;
1248 }
1249
1250 static HRESULT WINAPI IDirect3DDevice8Impl_GetLightEnable(LPDIRECT3DDEVICE8 iface, DWORD Index,BOOL* pEnable) {
1251 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1252 HRESULT hr;
1253
1254 TRACE("iface %p, index %u, enable %p.\n", iface, Index, pEnable);
1255
1256 wined3d_mutex_lock();
1257 hr = IWineD3DDevice_GetLightEnable(This->WineD3DDevice, Index, pEnable);
1258 wined3d_mutex_unlock();
1259
1260 return hr;
1261 }
1262
1263 static HRESULT WINAPI IDirect3DDevice8Impl_SetClipPlane(LPDIRECT3DDEVICE8 iface, DWORD Index,CONST float* pPlane) {
1264 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1265 HRESULT hr;
1266
1267 TRACE("iface %p, index %u, plane %p.\n", iface, Index, pPlane);
1268
1269 wined3d_mutex_lock();
1270 hr = IWineD3DDevice_SetClipPlane(This->WineD3DDevice, Index, pPlane);
1271 wined3d_mutex_unlock();
1272
1273 return hr;
1274 }
1275
1276 static HRESULT WINAPI IDirect3DDevice8Impl_GetClipPlane(LPDIRECT3DDEVICE8 iface, DWORD Index,float* pPlane) {
1277 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1278 HRESULT hr;
1279
1280 TRACE("iface %p, index %u, plane %p.\n", iface, Index, pPlane);
1281
1282 wined3d_mutex_lock();
1283 hr = IWineD3DDevice_GetClipPlane(This->WineD3DDevice, Index, pPlane);
1284 wined3d_mutex_unlock();
1285
1286 return hr;
1287 }
1288
1289 static HRESULT WINAPI IDirect3DDevice8Impl_SetRenderState(LPDIRECT3DDEVICE8 iface, D3DRENDERSTATETYPE State,DWORD Value) {
1290 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1291 HRESULT hr;
1292
1293 TRACE("iface %p, state %#x, value %#x.\n", iface, State, Value);
1294
1295 wined3d_mutex_lock();
1296 hr = IWineD3DDevice_SetRenderState(This->WineD3DDevice, State, Value);
1297 wined3d_mutex_unlock();
1298
1299 return hr;
1300 }
1301
1302 static HRESULT WINAPI IDirect3DDevice8Impl_GetRenderState(LPDIRECT3DDEVICE8 iface, D3DRENDERSTATETYPE State,DWORD* pValue) {
1303 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1304 HRESULT hr;
1305
1306 TRACE("iface %p, state %#x, value %p.\n", iface, State, pValue);
1307
1308 wined3d_mutex_lock();
1309 hr = IWineD3DDevice_GetRenderState(This->WineD3DDevice, State, pValue);
1310 wined3d_mutex_unlock();
1311
1312 return hr;
1313 }
1314
1315 static HRESULT WINAPI IDirect3DDevice8Impl_BeginStateBlock(LPDIRECT3DDEVICE8 iface) {
1316 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1317 HRESULT hr;
1318
1319 TRACE("iface %p.\n", iface);
1320
1321 wined3d_mutex_lock();
1322 hr = IWineD3DDevice_BeginStateBlock(This->WineD3DDevice);
1323 wined3d_mutex_unlock();
1324
1325 return hr;
1326 }
1327
1328 static HRESULT WINAPI IDirect3DDevice8Impl_EndStateBlock(LPDIRECT3DDEVICE8 iface, DWORD* pToken) {
1329 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1330 HRESULT hr;
1331 IWineD3DStateBlock* wineD3DStateBlock;
1332 IDirect3DStateBlock8Impl* object;
1333
1334 TRACE("iface %p, token %p.\n", iface, pToken);
1335
1336 /* Tell wineD3D to endstateblock before anything else (in case we run out
1337 * of memory later and cause locking problems)
1338 */
1339 wined3d_mutex_lock();
1340 hr = IWineD3DDevice_EndStateBlock(This->WineD3DDevice , &wineD3DStateBlock);
1341 if (hr != D3D_OK) {
1342 WARN("IWineD3DDevice_EndStateBlock returned an error\n");
1343 wined3d_mutex_unlock();
1344 return hr;
1345 }
1346
1347 /* allocate a new IDirectD3DStateBlock */
1348 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY ,sizeof(IDirect3DStateBlock8Impl));
1349 object->ref = 1;
1350 object->lpVtbl = &Direct3DStateBlock8_Vtbl;
1351
1352 object->wineD3DStateBlock = wineD3DStateBlock;
1353
1354 *pToken = d3d8_allocate_handle(&This->handle_table, object, D3D8_HANDLE_SB);
1355 wined3d_mutex_unlock();
1356
1357 if (*pToken == D3D8_INVALID_HANDLE)
1358 {
1359 ERR("Failed to create a handle\n");
1360 IDirect3DStateBlock8_Release((IDirect3DStateBlock8 *)object);
1361 return E_FAIL;
1362 }
1363 ++*pToken;
1364
1365 TRACE("Returning %#x (%p).\n", *pToken, object);
1366
1367 return hr;
1368 }
1369
1370 static HRESULT WINAPI IDirect3DDevice8Impl_ApplyStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token) {
1371 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1372 IDirect3DStateBlock8Impl *pSB;
1373 HRESULT hr;
1374
1375 TRACE("iface %p, token %#x.\n", iface, Token);
1376
1377 wined3d_mutex_lock();
1378 pSB = d3d8_get_object(&This->handle_table, Token - 1, D3D8_HANDLE_SB);
1379 if (!pSB)
1380 {
1381 WARN("Invalid handle (%#x) passed.\n", Token);
1382 wined3d_mutex_unlock();
1383 return D3DERR_INVALIDCALL;
1384 }
1385 hr = IWineD3DStateBlock_Apply(pSB->wineD3DStateBlock);
1386 wined3d_mutex_unlock();
1387
1388 return hr;
1389 }
1390
1391 static HRESULT WINAPI IDirect3DDevice8Impl_CaptureStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token) {
1392 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1393 IDirect3DStateBlock8Impl *pSB;
1394 HRESULT hr;
1395
1396 TRACE("iface %p, token %#x.\n", iface, Token);
1397
1398 wined3d_mutex_lock();
1399 pSB = d3d8_get_object(&This->handle_table, Token - 1, D3D8_HANDLE_SB);
1400 if (!pSB)
1401 {
1402 WARN("Invalid handle (%#x) passed.\n", Token);
1403 wined3d_mutex_unlock();
1404 return D3DERR_INVALIDCALL;
1405 }
1406 hr = IWineD3DStateBlock_Capture(pSB->wineD3DStateBlock);
1407 wined3d_mutex_unlock();
1408
1409 return hr;
1410 }
1411
1412 static HRESULT WINAPI IDirect3DDevice8Impl_DeleteStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token) {
1413 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1414 IDirect3DStateBlock8Impl *pSB;
1415
1416 TRACE("iface %p, token %#x.\n", iface, Token);
1417
1418 wined3d_mutex_lock();
1419 pSB = d3d8_free_handle(&This->handle_table, Token - 1, D3D8_HANDLE_SB);
1420 wined3d_mutex_unlock();
1421
1422 if (!pSB)
1423 {
1424 WARN("Invalid handle (%#x) passed.\n", Token);
1425 return D3DERR_INVALIDCALL;
1426 }
1427
1428 if (IUnknown_Release((IUnknown *)pSB))
1429 {
1430 ERR("Stateblock %p has references left, this shouldn't happen.\n", pSB);
1431 }
1432
1433 return D3D_OK;
1434 }
1435
1436 static HRESULT WINAPI IDirect3DDevice8Impl_CreateStateBlock(IDirect3DDevice8 *iface,
1437 D3DSTATEBLOCKTYPE Type, DWORD *handle)
1438 {
1439 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1440 IDirect3DStateBlock8Impl *object;
1441 HRESULT hr;
1442
1443 TRACE("iface %p, type %#x, handle %p.\n", iface, Type, handle);
1444
1445 if (Type != D3DSBT_ALL
1446 && Type != D3DSBT_PIXELSTATE
1447 && Type != D3DSBT_VERTEXSTATE)
1448 {
1449 WARN("Unexpected stateblock type, returning D3DERR_INVALIDCALL\n");
1450 return D3DERR_INVALIDCALL;
1451 }
1452
1453 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DStateBlock8Impl));
1454 if (!object)
1455 {
1456 ERR("Failed to allocate memory.\n");
1457 return E_OUTOFMEMORY;
1458 }
1459
1460 object->lpVtbl = &Direct3DStateBlock8_Vtbl;
1461 object->ref = 1;
1462
1463 wined3d_mutex_lock();
1464 hr = IWineD3DDevice_CreateStateBlock(This->WineD3DDevice, (WINED3DSTATEBLOCKTYPE)Type,
1465 &object->wineD3DStateBlock, (IUnknown *)object);
1466 if (FAILED(hr))
1467 {
1468 wined3d_mutex_unlock();
1469 ERR("IWineD3DDevice_CreateStateBlock failed, hr %#x\n", hr);
1470 HeapFree(GetProcessHeap(), 0, object);
1471 return hr;
1472 }
1473
1474 *handle = d3d8_allocate_handle(&This->handle_table, object, D3D8_HANDLE_SB);
1475 wined3d_mutex_unlock();
1476
1477 if (*handle == D3D8_INVALID_HANDLE)
1478 {
1479 ERR("Failed to allocate a handle.\n");
1480 IDirect3DStateBlock8_Release((IDirect3DStateBlock8 *)object);
1481 return E_FAIL;
1482 }
1483 ++*handle;
1484
1485 TRACE("Returning %#x (%p).\n", *handle, object);
1486
1487 return hr;
1488 }
1489
1490 static HRESULT WINAPI IDirect3DDevice8Impl_SetClipStatus(LPDIRECT3DDEVICE8 iface, CONST D3DCLIPSTATUS8* pClipStatus) {
1491 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1492 HRESULT hr;
1493
1494 TRACE("iface %p, clip_status %p.\n", iface, pClipStatus);
1495 /* FIXME: Verify that D3DCLIPSTATUS8 ~= WINED3DCLIPSTATUS */
1496
1497 wined3d_mutex_lock();
1498 hr = IWineD3DDevice_SetClipStatus(This->WineD3DDevice, (const WINED3DCLIPSTATUS *)pClipStatus);
1499 wined3d_mutex_unlock();
1500
1501 return hr;
1502 }
1503
1504 static HRESULT WINAPI IDirect3DDevice8Impl_GetClipStatus(LPDIRECT3DDEVICE8 iface, D3DCLIPSTATUS8* pClipStatus) {
1505 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1506 HRESULT hr;
1507
1508 TRACE("iface %p, clip_status %p.\n", iface, pClipStatus);
1509
1510 wined3d_mutex_lock();
1511 hr = IWineD3DDevice_GetClipStatus(This->WineD3DDevice, (WINED3DCLIPSTATUS *)pClipStatus);
1512 wined3d_mutex_unlock();
1513
1514 return hr;
1515 }
1516
1517 static HRESULT WINAPI IDirect3DDevice8Impl_GetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage,IDirect3DBaseTexture8** ppTexture) {
1518 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1519 IWineD3DBaseTexture *retTexture;
1520 HRESULT hr;
1521
1522 TRACE("iface %p, stage %u, texture %p.\n", iface, Stage, ppTexture);
1523
1524 if(ppTexture == NULL){
1525 return D3DERR_INVALIDCALL;
1526 }
1527
1528 wined3d_mutex_lock();
1529 hr = IWineD3DDevice_GetTexture(This->WineD3DDevice, Stage, &retTexture);
1530 if (FAILED(hr))
1531 {
1532 WARN("Failed to get texture for stage %u, hr %#x.\n", Stage, hr);
1533 wined3d_mutex_unlock();
1534 *ppTexture = NULL;
1535 return hr;
1536 }
1537
1538 if (retTexture)
1539 {
1540 IWineD3DBaseTexture_GetParent(retTexture, (IUnknown **)ppTexture);
1541 IWineD3DBaseTexture_Release(retTexture);
1542 }
1543 else
1544 {
1545 *ppTexture = NULL;
1546 }
1547 wined3d_mutex_unlock();
1548
1549 return D3D_OK;
1550 }
1551
1552 static HRESULT WINAPI IDirect3DDevice8Impl_SetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage, IDirect3DBaseTexture8* pTexture) {
1553 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1554 HRESULT hr;
1555
1556 TRACE("iface %p, stage %u, texture %p.\n", iface, Stage, pTexture);
1557
1558 wined3d_mutex_lock();
1559 hr = IWineD3DDevice_SetTexture(This->WineD3DDevice, Stage,
1560 pTexture==NULL ? NULL : ((IDirect3DBaseTexture8Impl *)pTexture)->wineD3DBaseTexture);
1561 wined3d_mutex_unlock();
1562
1563 return hr;
1564 }
1565
1566 static const struct tss_lookup
1567 {
1568 BOOL sampler_state;
1569 DWORD state;
1570 }
1571 tss_lookup[] =
1572 {
1573 {FALSE, WINED3DTSS_FORCE_DWORD}, /* 0, unused */
1574 {FALSE, WINED3DTSS_COLOROP}, /* 1, D3DTSS_COLOROP */
1575 {FALSE, WINED3DTSS_COLORARG1}, /* 2, D3DTSS_COLORARG1 */
1576 {FALSE, WINED3DTSS_COLORARG2}, /* 3, D3DTSS_COLORARG2 */
1577 {FALSE, WINED3DTSS_ALPHAOP}, /* 4, D3DTSS_ALPHAOP */
1578 {FALSE, WINED3DTSS_ALPHAARG1}, /* 5, D3DTSS_ALPHAARG1 */
1579 {FALSE, WINED3DTSS_ALPHAARG2}, /* 6, D3DTSS_ALPHAARG2 */
1580 {FALSE, WINED3DTSS_BUMPENVMAT00}, /* 7, D3DTSS_BUMPENVMAT00 */
1581 {FALSE, WINED3DTSS_BUMPENVMAT01}, /* 8, D3DTSS_BUMPENVMAT01 */
1582 {FALSE, WINED3DTSS_BUMPENVMAT10}, /* 9, D3DTSS_BUMPENVMAT10 */
1583 {FALSE, WINED3DTSS_BUMPENVMAT11}, /* 10, D3DTSS_BUMPENVMAT11 */
1584 {FALSE, WINED3DTSS_TEXCOORDINDEX}, /* 11, D3DTSS_TEXCOORDINDEX */
1585 {FALSE, WINED3DTSS_FORCE_DWORD}, /* 12, unused */
1586 {TRUE, WINED3DSAMP_ADDRESSU}, /* 13, D3DTSS_ADDRESSU */
1587 {TRUE, WINED3DSAMP_ADDRESSV}, /* 14, D3DTSS_ADDRESSV */
1588 {TRUE, WINED3DSAMP_BORDERCOLOR}, /* 15, D3DTSS_BORDERCOLOR */
1589 {TRUE, WINED3DSAMP_MAGFILTER}, /* 16, D3DTSS_MAGFILTER */
1590 {TRUE, WINED3DSAMP_MINFILTER}, /* 17, D3DTSS_MINFILTER */
1591 {TRUE, WINED3DSAMP_MIPFILTER}, /* 18, D3DTSS_MIPFILTER */
1592 {TRUE, WINED3DSAMP_MIPMAPLODBIAS}, /* 19, D3DTSS_MIPMAPLODBIAS */
1593 {TRUE, WINED3DSAMP_MAXMIPLEVEL}, /* 20, D3DTSS_MAXMIPLEVEL */
1594 {TRUE, WINED3DSAMP_MAXANISOTROPY}, /* 21, D3DTSS_MAXANISOTROPY */
1595 {FALSE, WINED3DTSS_BUMPENVLSCALE}, /* 22, D3DTSS_BUMPENVLSCALE */
1596 {FALSE, WINED3DTSS_BUMPENVLOFFSET}, /* 23, D3DTSS_BUMPENVLOFFSET */
1597 {FALSE, WINED3DTSS_TEXTURETRANSFORMFLAGS}, /* 24, D3DTSS_TEXTURETRANSFORMFLAGS */
1598 {TRUE, WINED3DSAMP_ADDRESSW}, /* 25, D3DTSS_ADDRESSW */
1599 {FALSE, WINED3DTSS_COLORARG0}, /* 26, D3DTSS_COLORARG0 */
1600 {FALSE, WINED3DTSS_ALPHAARG0}, /* 27, D3DTSS_ALPHAARG0 */
1601 {FALSE, WINED3DTSS_RESULTARG}, /* 28, D3DTSS_RESULTARG */
1602 };
1603
1604 static HRESULT WINAPI IDirect3DDevice8Impl_GetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue) {
1605 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1606 const struct tss_lookup *l = &tss_lookup[Type];
1607 HRESULT hr;
1608
1609 TRACE("iface %p, stage %u, state %#x, value %p.\n", iface, Stage, Type, pValue);
1610
1611 wined3d_mutex_lock();
1612 if (l->sampler_state) hr = IWineD3DDevice_GetSamplerState(This->WineD3DDevice, Stage, l->state, pValue);
1613 else hr = IWineD3DDevice_GetTextureStageState(This->WineD3DDevice, Stage, l->state, pValue);
1614 wined3d_mutex_unlock();
1615
1616 return hr;
1617 }
1618
1619 static HRESULT WINAPI IDirect3DDevice8Impl_SetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value) {
1620 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1621 const struct tss_lookup *l = &tss_lookup[Type];
1622 HRESULT hr;
1623
1624 TRACE("iface %p, stage %u, state %#x, value %#x.\n", iface, Stage, Type, Value);
1625
1626 wined3d_mutex_lock();
1627 if (l->sampler_state) hr = IWineD3DDevice_SetSamplerState(This->WineD3DDevice, Stage, l->state, Value);
1628 else hr = IWineD3DDevice_SetTextureStageState(This->WineD3DDevice, Stage, l->state, Value);
1629 wined3d_mutex_unlock();
1630
1631 return hr;
1632 }
1633
1634 static HRESULT WINAPI IDirect3DDevice8Impl_ValidateDevice(LPDIRECT3DDEVICE8 iface, DWORD* pNumPasses) {
1635 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1636 HRESULT hr;
1637
1638 TRACE("iface %p, pass_count %p.\n", iface, pNumPasses);
1639
1640 wined3d_mutex_lock();
1641 hr = IWineD3DDevice_ValidateDevice(This->WineD3DDevice, pNumPasses);
1642 wined3d_mutex_unlock();
1643
1644 return hr;
1645 }
1646
1647 static HRESULT WINAPI IDirect3DDevice8Impl_GetInfo(IDirect3DDevice8 *iface,
1648 DWORD info_id, void *info, DWORD info_size)
1649 {
1650 FIXME("iface %p, info_id %#x, info %p, info_size %u stub!\n", iface, info_id, info, info_size);
1651
1652 return D3D_OK;
1653 }
1654
1655 static HRESULT WINAPI IDirect3DDevice8Impl_SetPaletteEntries(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber, CONST PALETTEENTRY* pEntries) {
1656 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1657 HRESULT hr;
1658
1659 TRACE("iface %p, palette_idx %u, entries %p.\n", iface, PaletteNumber, pEntries);
1660
1661 wined3d_mutex_lock();
1662 hr = IWineD3DDevice_SetPaletteEntries(This->WineD3DDevice, PaletteNumber, pEntries);
1663 wined3d_mutex_unlock();
1664
1665 return hr;
1666 }
1667
1668 static HRESULT WINAPI IDirect3DDevice8Impl_GetPaletteEntries(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber, PALETTEENTRY* pEntries) {
1669 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1670 HRESULT hr;
1671
1672 TRACE("iface %p, palette_idx %u, entries %p.\n", iface, PaletteNumber, pEntries);
1673
1674 wined3d_mutex_lock();
1675 hr = IWineD3DDevice_GetPaletteEntries(This->WineD3DDevice, PaletteNumber, pEntries);
1676 wined3d_mutex_unlock();
1677
1678 return hr;
1679 }
1680
1681 static HRESULT WINAPI IDirect3DDevice8Impl_SetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber) {
1682 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1683 HRESULT hr;
1684
1685 TRACE("iface %p, palette_idx %u.\n", iface, PaletteNumber);
1686
1687 wined3d_mutex_lock();
1688 hr = IWineD3DDevice_SetCurrentTexturePalette(This->WineD3DDevice, PaletteNumber);
1689 wined3d_mutex_unlock();
1690
1691 return hr;
1692 }
1693
1694 static HRESULT WINAPI IDirect3DDevice8Impl_GetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface, UINT *PaletteNumber) {
1695 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1696 HRESULT hr;
1697
1698 TRACE("iface %p, palette_idx %p.\n", iface, PaletteNumber);
1699
1700 wined3d_mutex_lock();
1701 hr = IWineD3DDevice_GetCurrentTexturePalette(This->WineD3DDevice, PaletteNumber);
1702 wined3d_mutex_unlock();
1703
1704 return hr;
1705 }
1706
1707 static HRESULT WINAPI IDirect3DDevice8Impl_DrawPrimitive(IDirect3DDevice8 *iface, D3DPRIMITIVETYPE PrimitiveType,
1708 UINT StartVertex, UINT PrimitiveCount)
1709 {
1710 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1711 HRESULT hr;
1712
1713 TRACE("iface %p, primitive_type %#x, start_vertex %u, primitive_count %u.\n",
1714 iface, PrimitiveType, StartVertex, PrimitiveCount);
1715
1716 wined3d_mutex_lock();
1717 IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
1718 hr = IWineD3DDevice_DrawPrimitive(This->WineD3DDevice, StartVertex,
1719 vertex_count_from_primitive_count(PrimitiveType, PrimitiveCount));
1720 wined3d_mutex_unlock();
1721
1722 return hr;
1723 }
1724
1725 static HRESULT WINAPI IDirect3DDevice8Impl_DrawIndexedPrimitive(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,
1726 UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount) {
1727 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1728 HRESULT hr;
1729
1730 TRACE("iface %p, primitive_type %#x, min_vertex_idx %u, vertex_count %u, start_idx %u, primitive_count %u.\n",
1731 iface, PrimitiveType, MinVertexIndex, NumVertices, startIndex, primCount);
1732
1733 wined3d_mutex_lock();
1734 IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
1735 hr = IWineD3DDevice_DrawIndexedPrimitive(This->WineD3DDevice, startIndex,
1736 vertex_count_from_primitive_count(PrimitiveType, primCount));
1737 wined3d_mutex_unlock();
1738
1739 return hr;
1740 }
1741
1742 static HRESULT WINAPI IDirect3DDevice8Impl_DrawPrimitiveUP(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride) {
1743 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1744 HRESULT hr;
1745
1746 TRACE("iface %p, primitive_type %#x, primitive_count %u, data %p, stride %u.\n",
1747 iface, PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
1748
1749 wined3d_mutex_lock();
1750 IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
1751 hr = IWineD3DDevice_DrawPrimitiveUP(This->WineD3DDevice,
1752 vertex_count_from_primitive_count(PrimitiveType, PrimitiveCount),
1753 pVertexStreamZeroData, VertexStreamZeroStride);
1754 wined3d_mutex_unlock();
1755
1756 return hr;
1757 }
1758
1759 static HRESULT WINAPI IDirect3DDevice8Impl_DrawIndexedPrimitiveUP(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,
1760 UINT NumVertexIndices,UINT PrimitiveCount,CONST void* pIndexData,
1761 D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,
1762 UINT VertexStreamZeroStride) {
1763 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1764 HRESULT hr;
1765
1766 TRACE("iface %p, primitive_type %#x, min_vertex_idx %u, index_count %u, primitive_count %u,\n"
1767 "index_data %p, index_format %#x, vertex_data %p, vertex_stride %u.\n",
1768 iface, PrimitiveType, MinVertexIndex, NumVertexIndices, PrimitiveCount,
1769 pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride);
1770
1771 wined3d_mutex_lock();
1772 IWineD3DDevice_SetPrimitiveType(This->WineD3DDevice, PrimitiveType);
1773 hr = IWineD3DDevice_DrawIndexedPrimitiveUP(This->WineD3DDevice,
1774 vertex_count_from_primitive_count(PrimitiveType, PrimitiveCount), pIndexData,
1775 wined3dformat_from_d3dformat(IndexDataFormat), pVertexStreamZeroData, VertexStreamZeroStride);
1776 wined3d_mutex_unlock();
1777
1778 return hr;
1779 }
1780
1781 static HRESULT WINAPI IDirect3DDevice8Impl_ProcessVertices(LPDIRECT3DDEVICE8 iface, UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8* pDestBuffer,DWORD Flags) {
1782 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1783 HRESULT hr;
1784 IDirect3DVertexBuffer8Impl *dest = (IDirect3DVertexBuffer8Impl *) pDestBuffer;
1785
1786 TRACE("iface %p, src_start_idx %u, dst_idx %u, vertex_count %u, dst_buffer %p, flags %#x.\n",
1787 iface, SrcStartIndex, DestIndex, VertexCount, pDestBuffer, Flags);
1788
1789 wined3d_mutex_lock();
1790 hr = IWineD3DDevice_ProcessVertices(This->WineD3DDevice,SrcStartIndex, DestIndex, VertexCount, dest->wineD3DVertexBuffer, NULL, Flags, dest->fvf);
1791 wined3d_mutex_unlock();
1792
1793 return hr;
1794 }
1795
1796 static HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexShader(IDirect3DDevice8 *iface,
1797 const DWORD *declaration, const DWORD *byte_code, DWORD *shader, DWORD usage)
1798 {
1799 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1800 IDirect3DVertexShader8Impl *object;
1801 DWORD shader_handle;
1802 DWORD handle;
1803 HRESULT hr;
1804
1805 TRACE("iface %p, declaration %p, byte_code %p, shader %p, usage %#x.\n",
1806 iface, declaration, byte_code, shader, usage);
1807
1808 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1809 if (!object)
1810 {
1811 ERR("Failed to allocate vertex shader memory.\n");
1812 *shader = 0;
1813 return E_OUTOFMEMORY;
1814 }
1815
1816 wined3d_mutex_lock();
1817 handle = d3d8_allocate_handle(&This->handle_table, object, D3D8_HANDLE_VS);
1818 wined3d_mutex_unlock();
1819 if (handle == D3D8_INVALID_HANDLE)
1820 {
1821 ERR("Failed to allocate vertex shader handle.\n");
1822 HeapFree(GetProcessHeap(), 0, object);
1823 *shader = 0;
1824 return E_OUTOFMEMORY;
1825 }
1826
1827 shader_handle = handle + VS_HIGHESTFIXEDFXF + 1;
1828
1829 hr = vertexshader_init(object, This, declaration, byte_code, shader_handle, usage);
1830 if (FAILED(hr))
1831 {
1832 WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
1833 wined3d_mutex_lock();
1834 d3d8_free_handle(&This->handle_table, handle, D3D8_HANDLE_VS);
1835 wined3d_mutex_unlock();
1836 HeapFree(GetProcessHeap(), 0, object);
1837 *shader = 0;
1838 return hr;
1839 }
1840
1841 TRACE("Created vertex shader %p (handle %#x).\n", object, shader_handle);
1842 *shader = shader_handle;
1843
1844 return D3D_OK;
1845 }
1846
1847 static IDirect3DVertexDeclaration8Impl *IDirect3DDevice8Impl_FindDecl(IDirect3DDevice8Impl *This, DWORD fvf)
1848 {
1849 IDirect3DVertexDeclaration8Impl *d3d8_declaration;
1850 HRESULT hr;
1851 int p, low, high; /* deliberately signed */
1852 struct FvfToDecl *convertedDecls = This->decls;
1853
1854 TRACE("Searching for declaration for fvf %08x... ", fvf);
1855
1856 low = 0;
1857 high = This->numConvertedDecls - 1;
1858 while(low <= high) {
1859 p = (low + high) >> 1;
1860 TRACE("%d ", p);
1861 if(convertedDecls[p].fvf == fvf) {
1862 TRACE("found %p\n", convertedDecls[p].decl);
1863 return (IDirect3DVertexDeclaration8Impl *)convertedDecls[p].decl;
1864 } else if(convertedDecls[p].fvf < fvf) {
1865 low = p + 1;
1866 } else {
1867 high = p - 1;
1868 }
1869 }
1870 TRACE("not found. Creating and inserting at position %d.\n", low);
1871
1872 d3d8_declaration = HeapAlloc(GetProcessHeap(), 0, sizeof(*d3d8_declaration));
1873 if (!d3d8_declaration)
1874 {
1875 ERR("Memory allocation failed.\n");
1876 return NULL;
1877 }
1878
1879 hr = vertexdeclaration_init_fvf(d3d8_declaration, This, fvf);
1880 if (FAILED(hr))
1881 {
1882 WARN("Failed to initialize vertex declaration, hr %#x.\n", hr);
1883 HeapFree(GetProcessHeap(), 0, d3d8_declaration);
1884 return NULL;
1885 }
1886
1887 if(This->declArraySize == This->numConvertedDecls) {
1888 int grow = This->declArraySize / 2;
1889 convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls,
1890 sizeof(convertedDecls[0]) * (This->numConvertedDecls + grow));
1891 if(!convertedDecls) {
1892 /* This will destroy it */
1893 IDirect3DVertexDeclaration8_Release((IDirect3DVertexDeclaration8 *)d3d8_declaration);
1894 return NULL;
1895 }
1896 This->decls = convertedDecls;
1897 This->declArraySize += grow;
1898 }
1899
1900 memmove(convertedDecls + low + 1, convertedDecls + low, sizeof(convertedDecls[0]) * (This->numConvertedDecls - low));
1901 convertedDecls[low].decl = (IDirect3DVertexDeclaration8 *)d3d8_declaration;
1902 convertedDecls[low].fvf = fvf;
1903 This->numConvertedDecls++;
1904
1905 TRACE("Returning %p. %u decls in array\n", d3d8_declaration, This->numConvertedDecls);
1906 return d3d8_declaration;
1907 }
1908
1909 static HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD pShader) {
1910 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1911 IDirect3DVertexShader8Impl *shader;
1912 HRESULT hr;
1913
1914 TRACE("iface %p, shader %#x.\n", iface, pShader);
1915
1916 if (VS_HIGHESTFIXEDFXF >= pShader) {
1917 TRACE("Setting FVF, %#x\n", pShader);
1918
1919 wined3d_mutex_lock();
1920 IWineD3DDevice_SetVertexDeclaration(This->WineD3DDevice,
1921 IDirect3DDevice8Impl_FindDecl(This, pShader)->wined3d_vertex_declaration);
1922 IWineD3DDevice_SetVertexShader(This->WineD3DDevice, NULL);
1923 wined3d_mutex_unlock();
1924
1925 return D3D_OK;
1926 }
1927
1928 TRACE("Setting shader\n");
1929
1930 wined3d_mutex_lock();
1931 shader = d3d8_get_object(&This->handle_table, pShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS);
1932 if (!shader)
1933 {
1934 WARN("Invalid handle (%#x) passed.\n", pShader);
1935 wined3d_mutex_unlock();
1936
1937 return D3DERR_INVALIDCALL;
1938 }
1939
1940 hr = IWineD3DDevice_SetVertexDeclaration(This->WineD3DDevice,
1941 ((IDirect3DVertexDeclaration8Impl *)shader->vertex_declaration)->wined3d_vertex_declaration);
1942 if (SUCCEEDED(hr)) hr = IWineD3DDevice_SetVertexShader(This->WineD3DDevice, shader->wineD3DVertexShader);
1943 wined3d_mutex_unlock();
1944
1945 TRACE("Returning hr %#x\n", hr);
1946
1947 return hr;
1948 }
1949
1950 static HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD* ppShader) {
1951 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1952 IWineD3DVertexDeclaration *wined3d_declaration;
1953 IDirect3DVertexDeclaration8 *d3d8_declaration;
1954 HRESULT hrc;
1955
1956 TRACE("iface %p, shader %p.\n", iface, ppShader);
1957
1958 wined3d_mutex_lock();
1959 hrc = IWineD3DDevice_GetVertexDeclaration(This->WineD3DDevice, &wined3d_declaration);
1960 if (FAILED(hrc))
1961 {
1962 wined3d_mutex_unlock();
1963 WARN("(%p) : Call to IWineD3DDevice_GetVertexDeclaration failed %#x (device %p)\n",
1964 This, hrc, This->WineD3DDevice);
1965 return hrc;
1966 }
1967
1968 if (!wined3d_declaration)
1969 {
1970 wined3d_mutex_unlock();
1971 *ppShader = 0;
1972 return D3D_OK;
1973 }
1974
1975 hrc = IWineD3DVertexDeclaration_GetParent(wined3d_declaration, (IUnknown **)&d3d8_declaration);
1976 IWineD3DVertexDeclaration_Release(wined3d_declaration);
1977 wined3d_mutex_unlock();
1978 if (SUCCEEDED(hrc))
1979 {
1980 *ppShader = ((IDirect3DVertexDeclaration8Impl *)d3d8_declaration)->shader_handle;
1981 IDirect3DVertexDeclaration8_Release(d3d8_declaration);
1982 }
1983
1984 TRACE("(%p) : returning %#x\n", This, *ppShader);
1985
1986 return hrc;
1987 }
1988
1989 static HRESULT WINAPI IDirect3DDevice8Impl_DeleteVertexShader(LPDIRECT3DDEVICE8 iface, DWORD pShader) {
1990 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1991 IDirect3DVertexShader8Impl *shader;
1992 IWineD3DVertexShader *cur = NULL;
1993
1994 TRACE("iface %p, shader %#x.\n", iface, pShader);
1995
1996 wined3d_mutex_lock();
1997 shader = d3d8_free_handle(&This->handle_table, pShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS);
1998 if (!shader)
1999 {
2000 WARN("Invalid handle (%#x) passed.\n", pShader);
2001 wined3d_mutex_unlock();
2002
2003 return D3DERR_INVALIDCALL;
2004 }
2005
2006 IWineD3DDevice_GetVertexShader(This->WineD3DDevice, &cur);
2007
2008 if (cur)
2009 {
2010 if (cur == shader->wineD3DVertexShader) IDirect3DDevice8_SetVertexShader(iface, 0);
2011 IWineD3DVertexShader_Release(cur);
2012 }
2013
2014 wined3d_mutex_unlock();
2015
2016 if (IUnknown_Release((IUnknown *)shader))
2017 {
2018 ERR("Shader %p has references left, this shouldn't happen.\n", shader);
2019 }
2020
2021 return D3D_OK;
2022 }
2023
2024 static HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, CONST void* pConstantData, DWORD ConstantCount) {
2025 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2026 HRESULT hr;
2027
2028 TRACE("iface %p, register %u, data %p, count %u.\n",
2029 iface, Register, pConstantData, ConstantCount);
2030
2031 if(Register + ConstantCount > D3D8_MAX_VERTEX_SHADER_CONSTANTF) {
2032 WARN("Trying to access %u constants, but d3d8 only supports %u\n",
2033 Register + ConstantCount, D3D8_MAX_VERTEX_SHADER_CONSTANTF);
2034 return D3DERR_INVALIDCALL;
2035 }
2036
2037 wined3d_mutex_lock();
2038 hr = IWineD3DDevice_SetVertexShaderConstantF(This->WineD3DDevice, Register, pConstantData, ConstantCount);
2039 wined3d_mutex_unlock();
2040
2041 return hr;
2042 }
2043
2044 static HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, void* pConstantData, DWORD ConstantCount) {
2045 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2046 HRESULT hr;
2047
2048 TRACE("iface %p, register %u, data %p, count %u.\n",
2049 iface, Register, pConstantData, ConstantCount);
2050
2051 if(Register + ConstantCount > D3D8_MAX_VERTEX_SHADER_CONSTANTF) {
2052 WARN("Trying to access %u constants, but d3d8 only supports %u\n",
2053 Register + ConstantCount, D3D8_MAX_VERTEX_SHADER_CONSTANTF);
2054 return D3DERR_INVALIDCALL;
2055 }
2056
2057 wined3d_mutex_lock();
2058 hr = IWineD3DDevice_GetVertexShaderConstantF(This->WineD3DDevice, Register, pConstantData, ConstantCount);
2059 wined3d_mutex_unlock();
2060
2061 return hr;
2062 }
2063
2064 static HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderDeclaration(LPDIRECT3DDEVICE8 iface, DWORD pVertexShader, void* pData, DWORD* pSizeOfData) {
2065 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2066 IDirect3DVertexDeclaration8Impl *declaration;
2067 IDirect3DVertexShader8Impl *shader;
2068
2069 TRACE("iface %p, shader %#x, data %p, data_size %p.\n",
2070 iface, pVertexShader, pData, pSizeOfData);
2071
2072 wined3d_mutex_lock();
2073 shader = d3d8_get_object(&This->handle_table, pVertexShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS);
2074 wined3d_mutex_unlock();
2075
2076 if (!shader)
2077 {
2078 WARN("Invalid handle (%#x) passed.\n", pVertexShader);
2079 return D3DERR_INVALIDCALL;
2080 }
2081 declaration = (IDirect3DVertexDeclaration8Impl *)shader->vertex_declaration;
2082
2083 /* If pData is NULL, we just return the required size of the buffer. */
2084 if (!pData) {
2085 *pSizeOfData = declaration->elements_size;
2086 return D3D_OK;
2087 }
2088
2089 /* MSDN claims that if *pSizeOfData is smaller than the required size
2090 * we should write the required size and return D3DERR_MOREDATA.
2091 * That's not actually true. */
2092 if (*pSizeOfData < declaration->elements_size) {
2093 return D3DERR_INVALIDCALL;
2094 }
2095
2096 CopyMemory(pData, declaration->elements, declaration->elements_size);
2097
2098 return D3D_OK;
2099 }
2100
2101 static HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD pVertexShader, void* pData, DWORD* pSizeOfData) {
2102 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2103 IDirect3DVertexShader8Impl *shader = NULL;
2104 HRESULT hr;
2105
2106 TRACE("iface %p, shader %#x, data %p, data_size %p.\n",
2107 iface, pVertexShader, pData, pSizeOfData);
2108
2109 wined3d_mutex_lock();
2110 shader = d3d8_get_object(&This->handle_table, pVertexShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_VS);
2111 if (!shader)
2112 {
2113 WARN("Invalid handle (%#x) passed.\n", pVertexShader);
2114 wined3d_mutex_unlock();
2115
2116 return D3DERR_INVALIDCALL;
2117 }
2118
2119 if (!shader->wineD3DVertexShader)
2120 {
2121 wined3d_mutex_unlock();
2122 *pSizeOfData = 0;
2123 return D3D_OK;
2124 }
2125
2126 hr = IWineD3DVertexShader_GetFunction(shader->wineD3DVertexShader, pData, pSizeOfData);
2127 wined3d_mutex_unlock();
2128
2129 return hr;
2130 }
2131
2132 static HRESULT WINAPI IDirect3DDevice8Impl_SetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8* pIndexData, UINT baseVertexIndex) {
2133 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2134 HRESULT hr;
2135 IDirect3DIndexBuffer8Impl *ib = (IDirect3DIndexBuffer8Impl *)pIndexData;
2136
2137 TRACE("iface %p, buffer %p, base_vertex_idx %u.\n", iface, pIndexData, baseVertexIndex);
2138
2139 /* WineD3D takes an INT(due to d3d9), but d3d8 uses UINTs. Do I have to add a check here that
2140 * the UINT doesn't cause an overflow in the INT? It seems rather unlikely because such large
2141 * vertex buffers can't be created to address them with an index that requires the 32nd bit
2142 * (4 Byte minimum vertex size * 2^31-1 -> 8 gb buffer. The index sign would be the least
2143 * problem)
2144 */
2145 wined3d_mutex_lock();
2146 IWineD3DDevice_SetBaseVertexIndex(This->WineD3DDevice, baseVertexIndex);
2147 hr = IWineD3DDevice_SetIndexBuffer(This->WineD3DDevice,
2148 ib ? ib->wineD3DIndexBuffer : NULL,
2149 ib ? ib->format : WINED3DFMT_UNKNOWN);
2150 wined3d_mutex_unlock();
2151
2152 return hr;
2153 }
2154
2155 static HRESULT WINAPI IDirect3DDevice8Impl_GetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8** ppIndexData,UINT* pBaseVertexIndex) {
2156 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2157 IWineD3DBuffer *retIndexData = NULL;
2158 HRESULT rc = D3D_OK;
2159
2160 TRACE("iface %p, buffer %p, base_vertex_index %p.\n", iface, ppIndexData, pBaseVertexIndex);
2161
2162 if(ppIndexData == NULL){
2163 return D3DERR_INVALIDCALL;
2164 }
2165
2166 /* The case from UINT to INT is safe because d3d8 will never set negative values */
2167 wined3d_mutex_lock();
2168 IWineD3DDevice_GetBaseVertexIndex(This->WineD3DDevice, (INT *) pBaseVertexIndex);
2169 rc = IWineD3DDevice_GetIndexBuffer(This->WineD3DDevice, &retIndexData);
2170 if (SUCCEEDED(rc) && retIndexData) {
2171 IWineD3DBuffer_GetParent(retIndexData, (IUnknown **)ppIndexData);
2172 IWineD3DBuffer_Release(retIndexData);
2173 } else {
2174 if (FAILED(rc)) FIXME("Call to GetIndices failed\n");
2175 *ppIndexData = NULL;
2176 }
2177 wined3d_mutex_unlock();
2178
2179 return rc;
2180 }
2181
2182 static HRESULT WINAPI IDirect3DDevice8Impl_CreatePixelShader(IDirect3DDevice8 *iface,
2183 const DWORD *byte_code, DWORD *shader)
2184 {
2185 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2186 IDirect3DPixelShader8Impl *object;
2187 DWORD shader_handle;
2188 DWORD handle;
2189 HRESULT hr;
2190
2191 TRACE("iface %p, byte_code %p, shader %p.\n", iface, byte_code, shader);
2192
2193 if (!shader)
2194 {
2195 TRACE("(%p) Invalid call\n", This);
2196 return D3DERR_INVALIDCALL;
2197 }
2198
2199 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2200 if (!object)
2201 {
2202 ERR("Failed to allocate pixel shader memmory.\n");
2203 return E_OUTOFMEMORY;
2204 }
2205
2206 wined3d_mutex_lock();
2207 handle = d3d8_allocate_handle(&This->handle_table, object, D3D8_HANDLE_PS);
2208 wined3d_mutex_unlock();
2209 if (handle == D3D8_INVALID_HANDLE)
2210 {
2211 ERR("Failed to allocate pixel shader handle.\n");
2212 HeapFree(GetProcessHeap(), 0, object);
2213 return E_OUTOFMEMORY;
2214 }
2215
2216 shader_handle = handle + VS_HIGHESTFIXEDFXF + 1;
2217
2218 hr = pixelshader_init(object, This, byte_code, shader_handle);
2219 if (FAILED(hr))
2220 {
2221 WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
2222 wined3d_mutex_lock();
2223 d3d8_free_handle(&This->handle_table, handle, D3D8_HANDLE_PS);
2224 wined3d_mutex_unlock();
2225 HeapFree(GetProcessHeap(), 0, object);
2226 *shader = 0;
2227 return hr;
2228 }
2229
2230 TRACE("Created pixel shader %p (handle %#x).\n", object, shader_handle);
2231 *shader = shader_handle;
2232
2233 return D3D_OK;
2234 }
2235
2236 static HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD pShader) {
2237 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2238 IDirect3DPixelShader8Impl *shader;
2239 HRESULT hr;
2240
2241 TRACE("iface %p, shader %#x.\n", iface, pShader);
2242
2243 wined3d_mutex_lock();
2244
2245 if (!pShader)
2246 {
2247 hr = IWineD3DDevice_SetPixelShader(This->WineD3DDevice, NULL);
2248 wined3d_mutex_unlock();
2249 return hr;
2250 }
2251
2252 shader = d3d8_get_object(&This->handle_table, pShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS);
2253 if (!shader)
2254 {
2255 WARN("Invalid handle (%#x) passed.\n", pShader);
2256 wined3d_mutex_unlock();
2257 return D3DERR_INVALIDCALL;
2258 }
2259
2260 TRACE("(%p) : Setting shader %p\n", This, shader);
2261 hr = IWineD3DDevice_SetPixelShader(This->WineD3DDevice, shader->wineD3DPixelShader);
2262 wined3d_mutex_unlock();
2263
2264 return hr;
2265 }
2266
2267 static HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD* ppShader) {
2268 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2269 IWineD3DPixelShader *object;
2270 HRESULT hrc = D3D_OK;
2271
2272 TRACE("iface %p, shader %p.\n", iface, ppShader);
2273
2274 if (NULL == ppShader) {
2275 TRACE("(%p) Invalid call\n", This);
2276 return D3DERR_INVALIDCALL;
2277 }
2278
2279 wined3d_mutex_lock();
2280 hrc = IWineD3DDevice_GetPixelShader(This->WineD3DDevice, &object);
2281 if (D3D_OK == hrc && NULL != object) {
2282 IDirect3DPixelShader8Impl *d3d8_shader;
2283 hrc = IWineD3DPixelShader_GetParent(object, (IUnknown **)&d3d8_shader);
2284 IWineD3DPixelShader_Release(object);
2285 *ppShader = d3d8_shader->handle;
2286 IDirect3DPixelShader8_Release((IDirect3DPixelShader8 *)d3d8_shader);
2287 } else {
2288 *ppShader = 0;
2289 }
2290 wined3d_mutex_unlock();
2291
2292 TRACE("(%p) : returning %#x\n", This, *ppShader);
2293
2294 return hrc;
2295 }
2296
2297 static HRESULT WINAPI IDirect3DDevice8Impl_DeletePixelShader(LPDIRECT3DDEVICE8 iface, DWORD pShader) {
2298 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2299 IDirect3DPixelShader8Impl *shader;
2300 IWineD3DPixelShader *cur = NULL;
2301
2302 TRACE("iface %p, shader %#x.\n", iface, pShader);
2303
2304 wined3d_mutex_lock();
2305
2306 shader = d3d8_free_handle(&This->handle_table, pShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS);
2307 if (!shader)
2308 {
2309 WARN("Invalid handle (%#x) passed.\n", pShader);
2310 wined3d_mutex_unlock();
2311 return D3D_OK;
2312 }
2313
2314 IWineD3DDevice_GetPixelShader(This->WineD3DDevice, &cur);
2315
2316 if (cur)
2317 {
2318 if (cur == shader->wineD3DPixelShader) IDirect3DDevice8_SetPixelShader(iface, 0);
2319 IWineD3DPixelShader_Release(cur);
2320 }
2321
2322 wined3d_mutex_unlock();
2323
2324 if (IUnknown_Release((IUnknown *)shader))
2325 {
2326 ERR("Shader %p has references left, this shouldn't happen.\n", shader);
2327 }
2328
2329 return D3D_OK;
2330 }
2331
2332 static HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, CONST void* pConstantData, DWORD ConstantCount) {
2333 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2334 HRESULT hr;
2335
2336 TRACE("iface %p, register %u, data %p, count %u.\n",
2337 iface, Register, pConstantData, ConstantCount);
2338
2339 wined3d_mutex_lock();
2340 hr = IWineD3DDevice_SetPixelShaderConstantF(This->WineD3DDevice, Register, pConstantData, ConstantCount);
2341 wined3d_mutex_unlock();
2342
2343 return hr;
2344 }
2345
2346 static HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, void* pConstantData, DWORD ConstantCount) {
2347 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2348 HRESULT hr;
2349
2350 TRACE("iface %p, register %u, data %p, count %u.\n",
2351 iface, Register, pConstantData, ConstantCount);
2352
2353 wined3d_mutex_lock();
2354 hr = IWineD3DDevice_GetPixelShaderConstantF(This->WineD3DDevice, Register, pConstantData, ConstantCount);
2355 wined3d_mutex_unlock();
2356
2357 return hr;
2358 }
2359
2360 static HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD pPixelShader, void* pData, DWORD* pSizeOfData) {
2361 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2362 IDirect3DPixelShader8Impl *shader = NULL;
2363 HRESULT hr;
2364
2365 TRACE("iface %p, shader %#x, data %p, data_size %p.\n",
2366 iface, pPixelShader, pData, pSizeOfData);
2367
2368 wined3d_mutex_lock();
2369 shader = d3d8_get_object(&This->handle_table, pPixelShader - (VS_HIGHESTFIXEDFXF + 1), D3D8_HANDLE_PS);
2370 if (!shader)
2371 {
2372 WARN("Invalid handle (%#x) passed.\n", pPixelShader);
2373 wined3d_mutex_unlock();
2374
2375 return D3DERR_INVALIDCALL;
2376 }
2377
2378 hr = IWineD3DPixelShader_GetFunction(shader->wineD3DPixelShader, pData, pSizeOfData);
2379 wined3d_mutex_unlock();
2380
2381 return hr;
2382 }
2383
2384 static HRESULT WINAPI IDirect3DDevice8Impl_DrawRectPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo) {
2385 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2386 HRESULT hr;
2387
2388 TRACE("iface %p, handle %#x, segment_count %p, patch_info %p.\n",
2389 iface, Handle, pNumSegs, pRectPatchInfo);
2390
2391 wined3d_mutex_lock();
2392 hr = IWineD3DDevice_DrawRectPatch(This->WineD3DDevice, Handle, pNumSegs, (CONST WINED3DRECTPATCH_INFO *)pRectPatchInfo);
2393 wined3d_mutex_unlock();
2394
2395 return hr;
2396 }
2397
2398 static HRESULT WINAPI IDirect3DDevice8Impl_DrawTriPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo) {
2399 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2400 HRESULT hr;
2401
2402 TRACE("iface %p, handle %#x, segment_count %p, patch_info %p.\n",
2403 iface, Handle, pNumSegs, pTriPatchInfo);
2404
2405 wined3d_mutex_lock();
2406 hr = IWineD3DDevice_DrawTriPatch(This->WineD3DDevice, Handle, pNumSegs, (CONST WINED3DTRIPATCH_INFO *)pTriPatchInfo);
2407 wined3d_mutex_unlock();
2408
2409 return hr;
2410 }
2411
2412 static HRESULT WINAPI IDirect3DDevice8Impl_DeletePatch(LPDIRECT3DDEVICE8 iface, UINT Handle) {
2413 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2414 HRESULT hr;
2415
2416 TRACE("iface %p, handle %#x.\n", iface, Handle);
2417
2418 wined3d_mutex_lock();
2419 hr = IWineD3DDevice_DeletePatch(This->WineD3DDevice, Handle);
2420 wined3d_mutex_unlock();
2421
2422 return hr;
2423 }
2424
2425 static HRESULT WINAPI IDirect3DDevice8Impl_SetStreamSource(LPDIRECT3DDEVICE8 iface, UINT StreamNumber,IDirect3DVertexBuffer8* pStreamData,UINT Stride) {
2426 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2427 HRESULT hr;
2428
2429 TRACE("iface %p, stream_idx %u, buffer %p, stride %u.\n",
2430 iface, StreamNumber, pStreamData, Stride);
2431
2432 wined3d_mutex_lock();
2433 hr = IWineD3DDevice_SetStreamSource(This->WineD3DDevice, StreamNumber,
2434 NULL == pStreamData ? NULL : ((IDirect3DVertexBuffer8Impl *)pStreamData)->wineD3DVertexBuffer,
2435 0/* Offset in bytes */, Stride);
2436 wined3d_mutex_unlock();
2437
2438 return hr;
2439 }
2440
2441 static HRESULT WINAPI IDirect3DDevice8Impl_GetStreamSource(LPDIRECT3DDEVICE8 iface, UINT StreamNumber,IDirect3DVertexBuffer8** pStream,UINT* pStride) {
2442 IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
2443 IWineD3DBuffer *retStream = NULL;
2444 HRESULT rc = D3D_OK;
2445
2446 TRACE("iface %p, stream_idx %u, buffer %p, stride %p.\n",
2447 iface, StreamNumber, pStream, pStride);
2448
2449 if(pStream == NULL){
2450 return D3DERR_INVALIDCALL;
2451 }
2452
2453 wined3d_mutex_lock();
2454 rc = IWineD3DDevice_GetStreamSource(This->WineD3DDevice, StreamNumber, &retStream, 0 /* Offset in bytes */, pStride);
2455 if (rc == D3D_OK && NULL != retStream) {
2456 IWineD3DBuffer_GetParent(retStream, (IUnknown **)pStream);
2457 IWineD3DBuffer_Release(retStream);
2458 }else{
2459 if (rc != D3D_OK){
2460 FIXME("Call to GetStreamSource failed %p\n", pStride);
2461 }
2462 *pStream = NULL;
2463 }
2464 wined3d_mutex_unlock();
2465
2466 return rc;
2467 }
2468
2469
2470 const IDirect3DDevice8Vtbl Direct3DDevice8_Vtbl =
2471 {
2472 IDirect3DDevice8Impl_QueryInterface,
2473 IDirect3DDevice8Impl_AddRef,
2474 IDirect3DDevice8Impl_Release,
2475 IDirect3DDevice8Impl_TestCooperativeLevel,
2476 IDirect3DDevice8Impl_GetAvailableTextureMem,
2477 IDirect3DDevice8Impl_ResourceManagerDiscardBytes,
2478 IDirect3DDevice8Impl_GetDirect3D,
2479 IDirect3DDevice8Impl_GetDeviceCaps,
2480 IDirect3DDevice8Impl_GetDisplayMode,
2481 IDirect3DDevice8Impl_GetCreationParameters,
2482 IDirect3DDevice8Impl_SetCursorProperties,
2483 IDirect3DDevice8Impl_SetCursorPosition,
2484 IDirect3DDevice8Impl_ShowCursor,
2485 IDirect3DDevice8Impl_CreateAdditionalSwapChain,
2486 IDirect3DDevice8Impl_Reset,
2487 IDirect3DDevice8Impl_Present,
2488 IDirect3DDevice8Impl_GetBackBuffer,
2489 IDirect3DDevice8Impl_GetRasterStatus,
2490 IDirect3DDevice8Impl_SetGammaRamp,
2491 IDirect3DDevice8Impl_GetGammaRamp,
2492 IDirect3DDevice8Impl_CreateTexture,
2493 IDirect3DDevice8Impl_CreateVolumeTexture,
2494 IDirect3DDevice8Impl_CreateCubeTexture,
2495 IDirect3DDevice8Impl_CreateVertexBuffer,
2496 IDirect3DDevice8Impl_CreateIndexBuffer,
2497 IDirect3DDevice8Impl_CreateRenderTarget,
2498 IDirect3DDevice8Impl_CreateDepthStencilSurface,
2499 IDirect3DDevice8Impl_CreateImageSurface,
2500 IDirect3DDevice8Impl_CopyRects,
2501 IDirect3DDevice8Impl_UpdateTexture,
2502 IDirect3DDevice8Impl_GetFrontBuffer,
2503 IDirect3DDevice8Impl_SetRenderTarget,
2504 IDirect3DDevice8Impl_GetRenderTarget,
2505 IDirect3DDevice8Impl_GetDepthStencilSurface,
2506 IDirect3DDevice8Impl_BeginScene,
2507 IDirect3DDevice8Impl_EndScene,
2508 IDirect3DDevice8Impl_Clear,
2509 IDirect3DDevice8Impl_SetTransform,
2510 IDirect3DDevice8Impl_GetTransform,
2511 IDirect3DDevice8Impl_MultiplyTransform,
2512 IDirect3DDevice8Impl_SetViewport,
2513 IDirect3DDevice8Impl_GetViewport,
2514 IDirect3DDevice8Impl_SetMaterial,
2515 IDirect3DDevice8Impl_GetMaterial,
2516 IDirect3DDevice8Impl_SetLight,
2517 IDirect3DDevice8Impl_GetLight,
2518 IDirect3DDevice8Impl_LightEnable,
2519 IDirect3DDevice8Impl_GetLightEnable,
2520 IDirect3DDevice8Impl_SetClipPlane,
2521 IDirect3DDevice8Impl_GetClipPlane,
2522 IDirect3DDevice8Impl_SetRenderState,
2523 IDirect3DDevice8Impl_GetRenderState,
2524 IDirect3DDevice8Impl_BeginStateBlock,
2525 IDirect3DDevice8Impl_EndStateBlock,
2526 IDirect3DDevice8Impl_ApplyStateBlock,
2527 IDirect3DDevice8Impl_CaptureStateBlock,
2528 IDirect3DDevice8Impl_DeleteStateBlock,
2529 IDirect3DDevice8Impl_CreateStateBlock,
2530 IDirect3DDevice8Impl_SetClipStatus,
2531 IDirect3DDevice8Impl_GetClipStatus,
2532 IDirect3DDevice8Impl_GetTexture,
2533 IDirect3DDevice8Impl_SetTexture,
2534 IDirect3DDevice8Impl_GetTextureStageState,
2535 IDirect3DDevice8Impl_SetTextureStageState,
2536 IDirect3DDevice8Impl_ValidateDevice,
2537 IDirect3DDevice8Impl_GetInfo,
2538 IDirect3DDevice8Impl_SetPaletteEntries,
2539 IDirect3DDevice8Impl_GetPaletteEntries,
2540 IDirect3DDevice8Impl_SetCurrentTexturePalette,
2541 IDirect3DDevice8Impl_GetCurrentTexturePalette,
2542 IDirect3DDevice8Impl_DrawPrimitive,
2543 IDirect3DDevice8Impl_DrawIndexedPrimitive,
2544 IDirect3DDevice8Impl_DrawPrimitiveUP,
2545 IDirect3DDevice8Impl_DrawIndexedPrimitiveUP,
2546 IDirect3DDevice8Impl_ProcessVertices,
2547 IDirect3DDevice8Impl_CreateVertexShader,
2548 IDirect3DDevice8Impl_SetVertexShader,
2549 IDirect3DDevice8Impl_GetVertexShader,
2550 IDirect3DDevice8Impl_DeleteVertexShader,
2551 IDirect3DDevice8Impl_SetVertexShaderConstant,
2552 IDirect3DDevice8Impl_GetVertexShaderConstant,
2553 IDirect3DDevice8Impl_GetVertexShaderDeclaration,
2554 IDirect3DDevice8Impl_GetVertexShaderFunction,
2555 IDirect3DDevice8Impl_SetStreamSource,
2556 IDirect3DDevice8Impl_GetStreamSource,
2557 IDirect3DDevice8Impl_SetIndices,
2558 IDirect3DDevice8Impl_GetIndices,
2559 IDirect3DDevice8Impl_CreatePixelShader,
2560 IDirect3DDevice8Impl_SetPixelShader,
2561 IDirect3DDevice8Impl_GetPixelShader,
2562 IDirect3DDevice8Impl_DeletePixelShader,
2563 IDirect3DDevice8Impl_SetPixelShaderConstant,
2564 IDirect3DDevice8Impl_GetPixelShaderConstant,
2565 IDirect3DDevice8Impl_GetPixelShaderFunction,
2566 IDirect3DDevice8Impl_DrawRectPatch,
2567 IDirect3DDevice8Impl_DrawTriPatch,
2568 IDirect3DDevice8Impl_DeletePatch
2569 };
2570
2571 /* IWineD3DDeviceParent IUnknown methods */
2572
2573 static inline struct IDirect3DDevice8Impl *device_from_device_parent(IWineD3DDeviceParent *iface)
2574 {
2575 return (struct IDirect3DDevice8Impl *)((char*)iface
2576 - FIELD_OFFSET(struct IDirect3DDevice8Impl, device_parent_vtbl));
2577 }
2578
2579 static HRESULT STDMETHODCALLTYPE device_parent_QueryInterface(IWineD3DDeviceParent *iface, REFIID riid, void **object)
2580 {
2581 struct IDirect3DDevice8Impl *This = device_from_device_parent(iface);
2582 return IDirect3DDevice8Impl_QueryInterface((IDirect3DDevice8 *)This, riid, object);
2583 }
2584
2585 static ULONG STDMETHODCALLTYPE device_parent_AddRef(IWineD3DDeviceParent *iface)
2586 {
2587 struct IDirect3DDevice8Impl *This = device_from_device_parent(iface);
2588 return IDirect3DDevice8Impl_AddRef((IDirect3DDevice8 *)This);
2589 }
2590
2591 static ULONG STDMETHODCALLTYPE device_parent_Release(IWineD3DDeviceParent *iface)
2592 {
2593 struct IDirect3DDevice8Impl *This = device_from_device_parent(iface);
2594 return IDirect3DDevice8Impl_Release((IDirect3DDevice8 *)This);
2595 }
2596
2597 /* IWineD3DDeviceParent methods */
2598
2599 static void STDMETHODCALLTYPE device_parent_WineD3DDeviceCreated(IWineD3DDeviceParent *iface, IWineD3DDevice *device)
2600 {
2601 TRACE("iface %p, device %p\n", iface, device);
2602 }
2603
2604 static HRESULT STDMETHODCALLTYPE device_parent_CreateSurface(IWineD3DDeviceParent *iface,
2605 IUnknown *superior, UINT width, UINT height, WINED3DFORMAT format, DWORD usage,
2606 WINED3DPOOL pool, UINT level, WINED3DCUBEMAP_FACES face, IWineD3DSurface **surface)
2607 {
2608 struct IDirect3DDevice8Impl *This = device_from_device_parent(iface);
2609 IDirect3DSurface8Impl *d3d_surface;
2610 BOOL lockable = TRUE;
2611 HRESULT hr;
2612
2613 TRACE("iface %p, superior %p, width %u, height %u, format %#x, usage %#x,\n"
2614 "\tpool %#x, level %u, face %u, surface %p\n",
2615 iface, superior, width, height, format, usage, pool, level, face, surface);
2616
2617
2618 if (pool == WINED3DPOOL_DEFAULT && !(usage & WINED3DUSAGE_DYNAMIC)) lockable = FALSE;
2619
2620 hr = IDirect3DDevice8Impl_CreateSurface((IDirect3DDevice8 *)This, width, height,
2621 d3dformat_from_wined3dformat(format), lockable, FALSE /* Discard */, level,
2622 (IDirect3DSurface8 **)&d3d_surface, usage, pool, D3DMULTISAMPLE_NONE, 0 /* MultisampleQuality */);
2623 if (FAILED(hr))
2624 {
2625 ERR("(%p) CreateSurface failed, returning %#x\n", iface, hr);
2626 return hr;
2627 }
2628
2629 *surface = d3d_surface->wineD3DSurface;
2630 IWineD3DSurface_AddRef(*surface);
2631
2632 d3d_surface->container = superior;
2633 IUnknown_Release(d3d_surface->parentDevice);
2634 d3d_surface->parentDevice = NULL;
2635
2636 IDirect3DSurface8_Release((IDirect3DSurface8 *)d3d_surface);
2637 d3d_surface->forwardReference = superior;
2638
2639 return hr;
2640 }
2641
2642 static HRESULT STDMETHODCALLTYPE device_parent_CreateRenderTarget(IWineD3DDeviceParent *iface,
2643 IUnknown *superior, UINT width, UINT height, WINED3DFORMAT format, WINED3DMULTISAMPLE_TYPE multisample_type,
2644 DWORD multisample_quality, BOOL lockable, IWineD3DSurface **surface)
2645 {
2646 struct IDirect3DDevice8Impl *This = device_from_device_parent(iface);
2647 IDirect3DSurface8Impl *d3d_surface;
2648 HRESULT hr;
2649
2650 TRACE("iface %p, superior %p, width %u, height %u, format %#x, multisample_type %#x,\n"
2651 "\tmultisample_quality %u, lockable %u, surface %p\n",
2652 iface, superior, width, height, format, multisample_type, multisample_quality, lockable, surface);
2653
2654 hr = IDirect3DDevice8_CreateRenderTarget((IDirect3DDevice8 *)This, width, height,
2655 d3dformat_from_wined3dformat(format), multisample_type, lockable, (IDirect3DSurface8 **)&d3d_surface);
2656 if (FAILED(hr))
2657 {
2658 ERR("(%p) CreateRenderTarget failed, returning %#x\n", iface, hr);
2659 return hr;
2660 }
2661
2662 *surface = d3d_surface->wineD3DSurface;
2663 IWineD3DSurface_AddRef(*surface);
2664
2665 d3d_surface->container = (IUnknown *)This;
2666 /* Implicit surfaces are created with an refcount of 0 */
2667 IUnknown_Release((IUnknown *)d3d_surface);
2668
2669 return hr;
2670 }
2671
2672 static HRESULT STDMETHODCALLTYPE device_parent_CreateDepthStencilSurface(IWineD3DDeviceParent *iface,
2673 IUnknown *superior, UINT width, UINT height, WINED3DFORMAT format, WINED3DMULTISAMPLE_TYPE multisample_type,
2674 DWORD multisample_quality, BOOL discard, IWineD3DSurface **surface)
2675 {
2676 struct IDirect3DDevice8Impl *This = device_from_device_parent(iface);
2677 IDirect3DSurface8Impl *d3d_surface;
2678 HRESULT hr;
2679
2680 TRACE("iface %p, superior %p, width %u, height %u, format %#x, multisample_type %#x,\n"
2681 "\tmultisample_quality %u, discard %u, surface %p\n",
2682 iface, superior, width, height, format, multisample_type, multisample_quality, discard, surface);
2683
2684 hr = IDirect3DDevice8_CreateDepthStencilSurface((IDirect3DDevice8 *)This, width, height,
2685 d3dformat_from_wined3dformat(format), multisample_type, (IDirect3DSurface8 **)&d3d_surface);
2686 if (FAILED(hr))
2687 {
2688 ERR("(%p) CreateDepthStencilSurface failed, returning %#x\n", iface, hr);
2689 return hr;
2690 }
2691
2692 *surface = d3d_surface->wineD3DSurface;
2693 IWineD3DSurface_AddRef(*surface);
2694
2695 d3d_surface->container = (IUnknown *)This;
2696 /* Implicit surfaces are created with an refcount of 0 */
2697 IUnknown_Release((IUnknown *)d3d_surface);
2698
2699 return hr;
2700 }
2701
2702 static HRESULT STDMETHODCALLTYPE device_parent_CreateVolume(IWineD3DDeviceParent *iface,
2703 IUnknown *superior, UINT width, UINT height, UINT depth, WINED3DFORMAT format,
2704 WINED3DPOOL pool, DWORD usage, IWineD3DVolume **volume)
2705 {
2706 struct IDirect3DDevice8Impl *This = device_from_device_parent(iface);
2707 IDirect3DVolume8Impl *object;
2708 HRESULT hr;
2709
2710 TRACE("iface %p, superior %p, width %u, height %u, depth %u, format %#x, pool %#x, usage %#x, volume %p\n",
2711 iface, superior, width, height, depth, format, pool, usage, volume);
2712
2713 /* Allocate the storage for the device */
2714 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2715 if (!object)
2716 {
2717 FIXME("Allocation of memory failed\n");
2718 *volume = NULL;
2719 return D3DERR_OUTOFVIDEOMEMORY;
2720 }
2721
2722 hr = volume_init(object, This, width, height, depth, usage, format, pool);
2723 if (FAILED(hr))
2724 {
2725 WARN("Failed to initialize volume, hr %#x.\n", hr);
2726 HeapFree(GetProcessHeap(), 0, object);
2727 return hr;
2728 }
2729
2730 *volume = object->wineD3DVolume;
2731 IWineD3DVolume_AddRef(*volume);
2732 IDirect3DVolume8_Release((IDirect3DVolume8 *)object);
2733
2734 object->container = superior;
2735 object->forwardReference = superior;
2736
2737 TRACE("(%p) Created volume %p\n", iface, object);
2738
2739 return hr;
2740 }
2741
2742 static HRESULT STDMETHODCALLTYPE device_parent_CreateSwapChain(IWineD3DDeviceParent *iface,
2743 WINED3DPRESENT_PARAMETERS *present_parameters, IWineD3DSwapChain **swapchain)
2744 {
2745 struct IDirect3DDevice8Impl *This = device_from_device_parent(iface);
2746 IDirect3DSwapChain8Impl *d3d_swapchain;
2747 D3DPRESENT_PARAMETERS local_parameters;
2748 HRESULT hr;
2749
2750 TRACE("iface %p, present_parameters %p, swapchain %p\n", iface, present_parameters, swapchain);
2751
2752 /* Copy the presentation parameters */
2753 local_parameters.BackBufferWidth = present_parameters->BackBufferWidth;
2754 local_parameters.BackBufferHeight = present_parameters->BackBufferHeight;
2755 local_parameters.BackBufferFormat = d3dformat_from_wined3dformat(present_parameters->BackBufferFormat);
2756 local_parameters.BackBufferCount = present_parameters->BackBufferCount;
2757 local_parameters.MultiSampleType = present_parameters->MultiSampleType;
2758 local_parameters.SwapEffect = present_parameters->SwapEffect;
2759 local_parameters.hDeviceWindow = present_parameters->hDeviceWindow;
2760 local_parameters.Windowed = present_parameters->Windowed;
2761 local_parameters.EnableAutoDepthStencil = present_parameters->EnableAutoDepthStencil;
2762 local_parameters.AutoDepthStencilFormat = d3dformat_from_wined3dformat(present_parameters->AutoDepthStencilFormat);
2763 local_parameters.Flags = present_parameters->Flags;
2764 local_parameters.FullScreen_RefreshRateInHz = present_parameters->FullScreen_RefreshRateInHz;
2765 local_parameters.FullScreen_PresentationInterval = present_parameters->PresentationInterval;
2766
2767 hr = IDirect3DDevice8_CreateAdditionalSwapChain((IDirect3DDevice8 *)This,
2768 &local_parameters, (IDirect3DSwapChain8 **)&d3d_swapchain);
2769 if (FAILED(hr))
2770 {
2771 ERR("(%p) CreateAdditionalSwapChain failed, returning %#x\n", iface, hr);
2772 *swapchain = NULL;
2773 return hr;
2774 }
2775
2776 *swapchain = d3d_swapchain->wineD3DSwapChain;
2777 IUnknown_Release(d3d_swapchain->parentDevice);
2778 d3d_swapchain->parentDevice = NULL;
2779
2780 /* Copy back the presentation parameters */
2781 present_parameters->BackBufferWidth = local_parameters.BackBufferWidth;
2782 present_parameters->BackBufferHeight = local_parameters.BackBufferHeight;
2783 present_parameters->BackBufferFormat = wined3dformat_from_d3dformat(local_parameters.BackBufferFormat);
2784 present_parameters->BackBufferCount = local_parameters.BackBufferCount;
2785 present_parameters->MultiSampleType = local_parameters.MultiSampleType;
2786 present_parameters->SwapEffect = local_parameters.SwapEffect;
2787 present_parameters->hDeviceWindow = local_parameters.hDeviceWindow;
2788 present_parameters->Windowed = local_parameters.Windowed;
2789 present_parameters->EnableAutoDepthStencil = local_parameters.EnableAutoDepthStencil;
2790 present_parameters->AutoDepthStencilFormat = wined3dformat_from_d3dformat(local_parameters.AutoDepthStencilFormat);
2791 present_parameters->Flags = local_parameters.Flags;
2792 present_parameters->FullScreen_RefreshRateInHz = local_parameters.FullScreen_RefreshRateInHz;
2793 present_parameters->PresentationInterval = local_parameters.FullScreen_PresentationInterval;
2794
2795 return hr;
2796 }
2797
2798 const IWineD3DDeviceParentVtbl d3d8_wined3d_device_parent_vtbl =
2799 {
2800 /* IUnknown methods */
2801 device_parent_QueryInterface,
2802 device_parent_AddRef,
2803 device_parent_Release,
2804 /* IWineD3DDeviceParent methods */
2805 device_parent_WineD3DDeviceCreated,
2806 device_parent_CreateSurface,
2807 device_parent_CreateRenderTarget,
2808 device_parent_CreateDepthStencilSurface,
2809 device_parent_CreateVolume,
2810 device_parent_CreateSwapChain,
2811 };
useful hacks and other patches not (yet) suitable for mainline