?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
netapi32: Convert the Unix library to the __wine_unix_call interface.
[wine.git] / dlls / ddraw / device.c
blob8afbab0e58d5c4165f625d008c77182a5a8d415e
1 /*
2 * Copyright (c) 1998-2004 Lionel Ulmer
3 * Copyright (c) 2002-2005 Christian Costa
4 * Copyright (c) 2006-2009, 2011-2013 Stefan Dösinger
5 * Copyright (c) 2008 Alexander Dorofeyev
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 * IDirect3DDevice implementation, version 1, 2, 3 and 7. Rendering is relayed
22 * to WineD3D, some minimal DirectDraw specific management is handled here.
23 * The Direct3DDevice is NOT the parent of the WineD3DDevice, because d3d
24 * is initialized when DirectDraw creates the primary surface.
25 * Some type management is necessary, because some D3D types changed between
26 * D3D7 and D3D9.
27 *
28 */
29
30 #include "ddraw_private.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
33 WINE_DECLARE_DEBUG_CHANNEL(winediag);
34
35 /* The device ID */
36 const GUID IID_D3DDEVICE_WineD3D = {
37 0xaef72d43,
38 0xb09a,
39 0x4b7b,
40 { 0xb7,0x98,0xc6,0x8a,0x77,0x2d,0x72,0x2a }
41 };
42
43 static inline void set_fpu_control_word(WORD fpucw)
44 {
45 #if defined(__i386__) && defined(__GNUC__)
46 __asm__ volatile ("fldcw %0" : : "m" (fpucw));
47 #elif defined(__i386__) && defined(_MSC_VER)
48 __asm fldcw fpucw;
49 #endif
50 }
51
52 static inline WORD d3d_fpu_setup(void)
53 {
54 WORD oldcw;
55
56 #if defined(__i386__) && defined(__GNUC__)
57 __asm__ volatile ("fnstcw %0" : "=m" (oldcw));
58 #elif defined(__i386__) && defined(_MSC_VER)
59 __asm fnstcw oldcw;
60 #else
61 static BOOL warned = FALSE;
62 if(!warned)
63 {
64 FIXME("FPUPRESERVE not implemented for this platform / compiler\n");
65 warned = TRUE;
66 }
67 return 0;
68 #endif
69
70 set_fpu_control_word(0x37f);
71
72 return oldcw;
73 }
74
75 static enum wined3d_render_state wined3d_render_state_from_ddraw(D3DRENDERSTATETYPE state)
76 {
77 switch (state)
78 {
79 case D3DRENDERSTATE_ZBIAS:
80 return WINED3D_RS_DEPTHBIAS;
81 case D3DRENDERSTATE_EDGEANTIALIAS:
82 return WINED3D_RS_ANTIALIASEDLINEENABLE;
83 default:
84 return (enum wined3d_render_state)state;
85 }
86 }
87
88 static enum wined3d_transform_state wined3d_transform_state_from_ddraw(D3DTRANSFORMSTATETYPE state)
89 {
90 switch (state)
91 {
92 case D3DTRANSFORMSTATE_WORLD:
93 return WINED3D_TS_WORLD_MATRIX(0);
94 case D3DTRANSFORMSTATE_WORLD1:
95 return WINED3D_TS_WORLD_MATRIX(1);
96 case D3DTRANSFORMSTATE_WORLD2:
97 return WINED3D_TS_WORLD_MATRIX(2);
98 case D3DTRANSFORMSTATE_WORLD3:
99 return WINED3D_TS_WORLD_MATRIX(3);
100 default:
101 return (enum wined3d_transform_state)state;
102 }
103 }
104
105 static enum wined3d_primitive_type wined3d_primitive_type_from_ddraw(D3DPRIMITIVETYPE type)
106 {
107 return (enum wined3d_primitive_type)type;
108 }
109
110 static enum wined3d_stateblock_type wined3d_stateblock_type_from_ddraw(D3DSTATEBLOCKTYPE type)
111 {
112 return (enum wined3d_stateblock_type)type;
113 }
114
115 static inline struct d3d_device *impl_from_IUnknown(IUnknown *iface)
116 {
117 return CONTAINING_RECORD(iface, struct d3d_device, IUnknown_inner);
118 }
119
120 static HRESULT WINAPI d3d_device_inner_QueryInterface(IUnknown *iface, REFIID riid, void **out)
121 {
122 struct d3d_device *device = impl_from_IUnknown(iface);
123
124 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
125
126 if (!riid)
127 {
128 *out = NULL;
129 return DDERR_INVALIDPARAMS;
130 }
131
132 if (IsEqualGUID(&IID_IUnknown, riid))
133 {
134 IDirect3DDevice7_AddRef(&device->IDirect3DDevice7_iface);
135 *out = &device->IDirect3DDevice7_iface;
136 return S_OK;
137 }
138
139 if (device->version == 7)
140 {
141 if (IsEqualGUID(&IID_IDirect3DDevice7, riid))
142 {
143 IDirect3DDevice7_AddRef(&device->IDirect3DDevice7_iface);
144 *out = &device->IDirect3DDevice7_iface;
145 return S_OK;
146 }
147 }
148 else
149 {
150 if (IsEqualGUID(&IID_IDirect3DDevice3, riid) && device->version == 3)
151 {
152 IDirect3DDevice3_AddRef(&device->IDirect3DDevice3_iface);
153 *out = &device->IDirect3DDevice3_iface;
154 return S_OK;
155 }
156
157 if (IsEqualGUID(&IID_IDirect3DDevice2, riid) && device->version >= 2)
158 {
159 IDirect3DDevice2_AddRef(&device->IDirect3DDevice2_iface);
160 *out = &device->IDirect3DDevice2_iface;
161 return S_OK;
162 }
163
164 if (IsEqualGUID(&IID_IDirect3DDevice, riid))
165 {
166 IDirect3DDevice_AddRef(&device->IDirect3DDevice_iface);
167 *out = &device->IDirect3DDevice_iface;
168 return S_OK;
169 }
170 }
171
172 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
173
174 *out = NULL;
175 return E_NOINTERFACE;
176 }
177
178 static HRESULT WINAPI d3d_device7_QueryInterface(IDirect3DDevice7 *iface, REFIID riid, void **out)
179 {
180 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
181
182 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
183
184 return IUnknown_QueryInterface(device->outer_unknown, riid, out);
185 }
186
187 static HRESULT WINAPI d3d_device3_QueryInterface(IDirect3DDevice3 *iface, REFIID riid, void **out)
188 {
189 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
190
191 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
192
193 return IUnknown_QueryInterface(device->outer_unknown, riid, out);
194 }
195
196 static HRESULT WINAPI d3d_device2_QueryInterface(IDirect3DDevice2 *iface, REFIID riid, void **out)
197 {
198 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
199
200 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
201
202 return IUnknown_QueryInterface(device->outer_unknown, riid, out);
203 }
204
205 static HRESULT WINAPI d3d_device1_QueryInterface(IDirect3DDevice *iface, REFIID riid, void **out)
206 {
207 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
208
209 TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
210
211 return IUnknown_QueryInterface(device->outer_unknown, riid, out);
212 }
213
214 static ULONG WINAPI d3d_device_inner_AddRef(IUnknown *iface)
215 {
216 struct d3d_device *device = impl_from_IUnknown(iface);
217 ULONG ref = InterlockedIncrement(&device->ref);
218
219 TRACE("%p increasing refcount to %u.\n", device, ref);
220
221 return ref;
222 }
223
224 static ULONG WINAPI d3d_device7_AddRef(IDirect3DDevice7 *iface)
225 {
226 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
227
228 TRACE("iface %p.\n", iface);
229
230 return IUnknown_AddRef(device->outer_unknown);
231 }
232
233 static ULONG WINAPI d3d_device3_AddRef(IDirect3DDevice3 *iface)
234 {
235 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
236
237 TRACE("iface %p.\n", iface);
238
239 return IUnknown_AddRef(device->outer_unknown);
240 }
241
242 static ULONG WINAPI d3d_device2_AddRef(IDirect3DDevice2 *iface)
243 {
244 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
245
246 TRACE("iface %p.\n", iface);
247
248 return IUnknown_AddRef(device->outer_unknown);
249 }
250
251 static ULONG WINAPI d3d_device1_AddRef(IDirect3DDevice *iface)
252 {
253 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
254
255 TRACE("iface %p.\n", iface);
256
257 return IUnknown_AddRef(device->outer_unknown);
258 }
259
260 static ULONG WINAPI d3d_device_inner_Release(IUnknown *iface)
261 {
262 struct d3d_device *This = impl_from_IUnknown(iface);
263 ULONG ref = InterlockedDecrement(&This->ref);
264 IUnknown *rt_iface;
265
266 TRACE("%p decreasing refcount to %u.\n", This, ref);
267
268 /* This method doesn't destroy the wined3d device, because it's still in
269 * use for 2D rendering. IDirectDrawSurface7::Release will destroy the
270 * wined3d device when the render target is released. */
271 if (!ref)
272 {
273 static struct wined3d_rendertarget_view *const null_rtv;
274 DWORD i;
275 struct list *vp_entry, *vp_entry2;
276
277 wined3d_mutex_lock();
278
279 /* There is no need to unset any resources here, wined3d will take
280 * care of that on uninit_3d(). */
281
282 if (This->index_buffer)
283 wined3d_buffer_decref(This->index_buffer);
284 if (This->vertex_buffer)
285 wined3d_buffer_decref(This->vertex_buffer);
286
287 wined3d_device_context_set_rendertarget_views(This->immediate_context, 0, 1, &null_rtv, FALSE);
288
289 wined3d_stateblock_decref(This->state);
290 if (This->recording)
291 wined3d_stateblock_decref(This->recording);
292
293 /* Release the wined3d device. This won't destroy it. */
294 if (!wined3d_device_decref(This->wined3d_device))
295 ERR("The wined3d device (%p) was destroyed unexpectedly.\n", This->wined3d_device);
296
297 /* The texture handles should be unset by now, but there might be some bits
298 * missing in our reference counting(needs test). Do a sanity check. */
299 for (i = 0; i < This->handle_table.entry_count; ++i)
300 {
301 struct ddraw_handle_entry *entry = &This->handle_table.entries[i];
302
303 switch (entry->type)
304 {
305 case DDRAW_HANDLE_FREE:
306 break;
307
308 case DDRAW_HANDLE_MATERIAL:
309 {
310 struct d3d_material *m = entry->object;
311 FIXME("Material handle %#x (%p) not unset properly.\n", i + 1, m);
312 m->Handle = 0;
313 break;
314 }
315
316 case DDRAW_HANDLE_MATRIX:
317 {
318 /* No FIXME here because this might happen because of sloppy applications. */
319 WARN("Leftover matrix handle %#x (%p), deleting.\n", i + 1, entry->object);
320 IDirect3DDevice_DeleteMatrix(&This->IDirect3DDevice_iface, i + 1);
321 break;
322 }
323
324 case DDRAW_HANDLE_STATEBLOCK:
325 {
326 /* No FIXME here because this might happen because of sloppy applications. */
327 WARN("Leftover stateblock handle %#x (%p), deleting.\n", i + 1, entry->object);
328 IDirect3DDevice7_DeleteStateBlock(&This->IDirect3DDevice7_iface, i + 1);
329 break;
330 }
331
332 case DDRAW_HANDLE_SURFACE:
333 {
334 struct ddraw_surface *surf = entry->object;
335 FIXME("Texture handle %#x (%p) not unset properly.\n", i + 1, surf);
336 surf->Handle = 0;
337 break;
338 }
339
340 default:
341 FIXME("Handle %#x (%p) has unknown type %#x.\n", i + 1, entry->object, entry->type);
342 break;
343 }
344 }
345
346 ddraw_handle_table_destroy(&This->handle_table);
347
348 LIST_FOR_EACH_SAFE(vp_entry, vp_entry2, &This->viewport_list)
349 {
350 struct d3d_viewport *vp = LIST_ENTRY(vp_entry, struct d3d_viewport, entry);
351 IDirect3DDevice3_DeleteViewport(&This->IDirect3DDevice3_iface, &vp->IDirect3DViewport3_iface);
352 }
353
354 TRACE("Releasing render target %p.\n", This->rt_iface);
355 rt_iface = This->rt_iface;
356 This->rt_iface = NULL;
357 if (This->version != 1)
358 IUnknown_Release(rt_iface);
359 TRACE("Render target release done.\n");
360
361 /* Releasing the render target above may have released the last
362 * reference to the ddraw object. */
363 if (This->ddraw)
364 This->ddraw->d3ddevice = NULL;
365
366 /* Now free the structure */
367 heap_free(This);
368 wined3d_mutex_unlock();
369 }
370
371 TRACE("Done\n");
372 return ref;
373 }
374
375 static ULONG WINAPI d3d_device7_Release(IDirect3DDevice7 *iface)
376 {
377 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
378
379 TRACE("iface %p.\n", iface);
380
381 return IUnknown_Release(device->outer_unknown);
382 }
383
384 static ULONG WINAPI d3d_device3_Release(IDirect3DDevice3 *iface)
385 {
386 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
387
388 TRACE("iface %p.\n", iface);
389
390 return IUnknown_Release(device->outer_unknown);
391 }
392
393 static ULONG WINAPI d3d_device2_Release(IDirect3DDevice2 *iface)
394 {
395 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
396
397 TRACE("iface %p.\n", iface);
398
399 return IUnknown_Release(device->outer_unknown);
400 }
401
402 static ULONG WINAPI d3d_device1_Release(IDirect3DDevice *iface)
403 {
404 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
405
406 TRACE("iface %p.\n", iface);
407
408 return IUnknown_Release(device->outer_unknown);
409 }
410
411 /*****************************************************************************
412 * IDirect3DDevice Methods
413 *****************************************************************************/
414
415 /*****************************************************************************
416 * IDirect3DDevice::Initialize
417 *
418 * Initializes a Direct3DDevice. This implementation is a no-op, as all
419 * initialization is done at create time.
420 *
421 * Exists in Version 1
422 *
423 * Parameters:
424 * No idea what they mean, as the MSDN page is gone
425 *
426 * Returns: DD_OK
427 *
428 *****************************************************************************/
429 static HRESULT WINAPI d3d_device1_Initialize(IDirect3DDevice *iface,
430 IDirect3D *d3d, GUID *guid, D3DDEVICEDESC *device_desc)
431 {
432 /* It shouldn't be crucial, but print a FIXME, I'm interested if
433 * any game calls it and when. */
434 FIXME("iface %p, d3d %p, guid %s, device_desc %p nop!\n",
435 iface, d3d, debugstr_guid(guid), device_desc);
436
437 return D3D_OK;
438 }
439
440 static HRESULT d3d_device7_GetCaps(IDirect3DDevice7 *iface, D3DDEVICEDESC7 *device_desc)
441 {
442 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
443
444 TRACE("iface %p, device_desc %p.\n", iface, device_desc);
445
446 if (!device_desc)
447 {
448 WARN("device_desc is NULL, returning DDERR_INVALIDPARAMS.\n");
449 return DDERR_INVALIDPARAMS;
450 }
451
452 /* Call the same function used by IDirect3D, this saves code */
453 return ddraw_get_d3dcaps(device->ddraw, device_desc);
454 }
455
456 static HRESULT WINAPI d3d_device7_GetCaps_FPUSetup(IDirect3DDevice7 *iface, D3DDEVICEDESC7 *desc)
457 {
458 return d3d_device7_GetCaps(iface, desc);
459 }
460
461 static HRESULT WINAPI d3d_device7_GetCaps_FPUPreserve(IDirect3DDevice7 *iface, D3DDEVICEDESC7 *desc)
462 {
463 HRESULT hr;
464 WORD old_fpucw;
465
466 old_fpucw = d3d_fpu_setup();
467 hr = d3d_device7_GetCaps(iface, desc);
468 set_fpu_control_word(old_fpucw);
469
470 return hr;
471 }
472 /*****************************************************************************
473 * IDirect3DDevice3::GetCaps
474 *
475 * Retrieves the capabilities of the hardware device and the emulation
476 * device. For Wine, hardware and emulation are the same (it's all HW).
477 *
478 * This implementation is used for Version 1, 2, and 3. Version 7 has its own
479 *
480 * Parameters:
481 * HWDesc: Structure to fill with the HW caps
482 * HelDesc: Structure to fill with the hardware emulation caps
483 *
484 * Returns:
485 * D3D_OK on success
486 * D3DERR_* if a problem occurs. See WineD3D
487 *
488 *****************************************************************************/
489
490 /* There are 3 versions of D3DDEVICEDESC. All 3 share the same name because
491 * Microsoft just expanded the existing structure without naming them
492 * D3DDEVICEDESC2 and D3DDEVICEDESC3. Which version is used have depends
493 * on the version of the DirectX SDK. DirectX 6+ and Wine use the latest
494 * one with 252 bytes.
495 *
496 * All 3 versions are allowed as parameters and only the specified amount of
497 * bytes is written.
498 *
499 * Note that Direct3D7 and earlier are not available in native Win64
500 * ddraw.dll builds, so possible size differences between 32 bit and
501 * 64 bit are a non-issue.
502 */
503 static inline BOOL check_d3ddevicedesc_size(DWORD size)
504 {
505 if (size == FIELD_OFFSET(D3DDEVICEDESC, dwMinTextureWidth) /* 172 */
506 || size == FIELD_OFFSET(D3DDEVICEDESC, dwMaxTextureRepeat) /* 204 */
507 || size == sizeof(D3DDEVICEDESC) /* 252 */) return TRUE;
508 return FALSE;
509 }
510
511 static HRESULT WINAPI d3d_device3_GetCaps(IDirect3DDevice3 *iface,
512 D3DDEVICEDESC *HWDesc, D3DDEVICEDESC *HelDesc)
513 {
514 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
515 D3DDEVICEDESC7 desc7;
516 D3DDEVICEDESC desc1;
517 HRESULT hr;
518
519 TRACE("iface %p, hw_desc %p, hel_desc %p.\n", iface, HWDesc, HelDesc);
520
521 if (!HWDesc)
522 {
523 WARN("HWDesc is NULL, returning DDERR_INVALIDPARAMS.\n");
524 return DDERR_INVALIDPARAMS;
525 }
526 if (!check_d3ddevicedesc_size(HWDesc->dwSize))
527 {
528 WARN("HWDesc->dwSize is %u, returning DDERR_INVALIDPARAMS.\n", HWDesc->dwSize);
529 return DDERR_INVALIDPARAMS;
530 }
531 if (!HelDesc)
532 {
533 WARN("HelDesc is NULL, returning DDERR_INVALIDPARAMS.\n");
534 return DDERR_INVALIDPARAMS;
535 }
536 if (!check_d3ddevicedesc_size(HelDesc->dwSize))
537 {
538 WARN("HelDesc->dwSize is %u, returning DDERR_INVALIDPARAMS.\n", HelDesc->dwSize);
539 return DDERR_INVALIDPARAMS;
540 }
541
542 if (FAILED(hr = ddraw_get_d3dcaps(device->ddraw, &desc7)))
543 return hr;
544
545 ddraw_d3dcaps1_from_7(&desc1, &desc7);
546 DD_STRUCT_COPY_BYSIZE(HWDesc, &desc1);
547 DD_STRUCT_COPY_BYSIZE(HelDesc, &desc1);
548 return D3D_OK;
549 }
550
551 static HRESULT WINAPI d3d_device2_GetCaps(IDirect3DDevice2 *iface,
552 D3DDEVICEDESC *hw_desc, D3DDEVICEDESC *hel_desc)
553 {
554 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
555
556 TRACE("iface %p, hw_desc %p, hel_desc %p.\n", iface, hw_desc, hel_desc);
557
558 return d3d_device3_GetCaps(&device->IDirect3DDevice3_iface, hw_desc, hel_desc);
559 }
560
561 static HRESULT WINAPI d3d_device1_GetCaps(IDirect3DDevice *iface,
562 D3DDEVICEDESC *hw_desc, D3DDEVICEDESC *hel_desc)
563 {
564 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
565
566 TRACE("iface %p, hw_desc %p, hel_desc %p.\n", iface, hw_desc, hel_desc);
567
568 return d3d_device3_GetCaps(&device->IDirect3DDevice3_iface, hw_desc, hel_desc);
569 }
570
571 /*****************************************************************************
572 * IDirect3DDevice2::SwapTextureHandles
573 *
574 * Swaps the texture handles of 2 Texture interfaces. Version 1 and 2
575 *
576 * Parameters:
577 * Tex1, Tex2: The 2 Textures to swap
578 *
579 * Returns:
580 * D3D_OK
581 *
582 *****************************************************************************/
583 static HRESULT WINAPI d3d_device2_SwapTextureHandles(IDirect3DDevice2 *iface,
584 IDirect3DTexture2 *tex1, IDirect3DTexture2 *tex2)
585 {
586 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
587 struct ddraw_surface *surf1 = unsafe_impl_from_IDirect3DTexture2(tex1);
588 struct ddraw_surface *surf2 = unsafe_impl_from_IDirect3DTexture2(tex2);
589 DWORD h1, h2;
590
591 TRACE("iface %p, tex1 %p, tex2 %p.\n", iface, tex1, tex2);
592
593 wined3d_mutex_lock();
594
595 h1 = surf1->Handle - 1;
596 h2 = surf2->Handle - 1;
597 device->handle_table.entries[h1].object = surf2;
598 device->handle_table.entries[h2].object = surf1;
599 surf2->Handle = h1 + 1;
600 surf1->Handle = h2 + 1;
601
602 wined3d_mutex_unlock();
603
604 return D3D_OK;
605 }
606
607 static HRESULT WINAPI d3d_device1_SwapTextureHandles(IDirect3DDevice *iface,
608 IDirect3DTexture *tex1, IDirect3DTexture *tex2)
609 {
610 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
611 struct ddraw_surface *surf1 = unsafe_impl_from_IDirect3DTexture(tex1);
612 struct ddraw_surface *surf2 = unsafe_impl_from_IDirect3DTexture(tex2);
613 IDirect3DTexture2 *t1 = surf1 ? &surf1->IDirect3DTexture2_iface : NULL;
614 IDirect3DTexture2 *t2 = surf2 ? &surf2->IDirect3DTexture2_iface : NULL;
615
616 TRACE("iface %p, tex1 %p, tex2 %p.\n", iface, tex1, tex2);
617
618 return d3d_device2_SwapTextureHandles(&device->IDirect3DDevice2_iface, t1, t2);
619 }
620
621 /*****************************************************************************
622 * IDirect3DDevice3::GetStats
623 *
624 * This method seems to retrieve some stats from the device.
625 * The MSDN documentation doesn't exist any more, but the D3DSTATS
626 * structure suggests that the amount of drawn primitives and processed
627 * vertices is returned.
628 *
629 * Exists in Version 1, 2 and 3
630 *
631 * Parameters:
632 * Stats: Pointer to a D3DSTATS structure to be filled
633 *
634 * Returns:
635 * D3D_OK on success
636 * DDERR_INVALIDPARAMS if Stats == NULL
637 *
638 *****************************************************************************/
639 static HRESULT WINAPI d3d_device3_GetStats(IDirect3DDevice3 *iface, D3DSTATS *Stats)
640 {
641 FIXME("iface %p, stats %p stub!\n", iface, Stats);
642
643 if(!Stats)
644 return DDERR_INVALIDPARAMS;
645
646 /* Fill the Stats with 0 */
647 Stats->dwTrianglesDrawn = 0;
648 Stats->dwLinesDrawn = 0;
649 Stats->dwPointsDrawn = 0;
650 Stats->dwSpansDrawn = 0;
651 Stats->dwVerticesProcessed = 0;
652
653 return D3D_OK;
654 }
655
656 static HRESULT WINAPI d3d_device2_GetStats(IDirect3DDevice2 *iface, D3DSTATS *stats)
657 {
658 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
659
660 TRACE("iface %p, stats %p.\n", iface, stats);
661
662 return d3d_device3_GetStats(&device->IDirect3DDevice3_iface, stats);
663 }
664
665 static HRESULT WINAPI d3d_device1_GetStats(IDirect3DDevice *iface, D3DSTATS *stats)
666 {
667 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
668
669 TRACE("iface %p, stats %p.\n", iface, stats);
670
671 return d3d_device3_GetStats(&device->IDirect3DDevice3_iface, stats);
672 }
673
674 /*****************************************************************************
675 * IDirect3DDevice::CreateExecuteBuffer
676 *
677 * Creates an IDirect3DExecuteBuffer, used for rendering with a
678 * Direct3DDevice.
679 *
680 * Version 1 only.
681 *
682 * Params:
683 * Desc: Buffer description
684 * ExecuteBuffer: Address to return the Interface pointer at
685 * UnkOuter: Must be NULL. Basically for aggregation, which ddraw doesn't
686 * support
687 *
688 * Returns:
689 * CLASS_E_NOAGGREGATION if UnkOuter != NULL
690 * DDERR_OUTOFMEMORY if we ran out of memory
691 * D3D_OK on success
692 *
693 *****************************************************************************/
694 static HRESULT WINAPI d3d_device1_CreateExecuteBuffer(IDirect3DDevice *iface,
695 D3DEXECUTEBUFFERDESC *buffer_desc, IDirect3DExecuteBuffer **ExecuteBuffer, IUnknown *outer_unknown)
696 {
697 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
698 struct d3d_execute_buffer *object;
699 HRESULT hr;
700
701 TRACE("iface %p, buffer_desc %p, buffer %p, outer_unknown %p.\n",
702 iface, buffer_desc, ExecuteBuffer, outer_unknown);
703
704 if (outer_unknown)
705 return CLASS_E_NOAGGREGATION;
706
707 /* Allocate the new Execute Buffer */
708 if (!(object = heap_alloc_zero(sizeof(*object))))
709 {
710 ERR("Failed to allocate execute buffer memory.\n");
711 return DDERR_OUTOFMEMORY;
712 }
713
714 hr = d3d_execute_buffer_init(object, device, buffer_desc);
715 if (FAILED(hr))
716 {
717 WARN("Failed to initialize execute buffer, hr %#x.\n", hr);
718 heap_free(object);
719 return hr;
720 }
721
722 *ExecuteBuffer = &object->IDirect3DExecuteBuffer_iface;
723
724 TRACE(" Returning IDirect3DExecuteBuffer at %p, implementation is at %p\n", *ExecuteBuffer, object);
725
726 return D3D_OK;
727 }
728
729 /*****************************************************************************
730 * IDirect3DDevice::Execute
731 *
732 * Executes all the stuff in an execute buffer.
733 *
734 * Params:
735 * ExecuteBuffer: The buffer to execute
736 * Viewport: The viewport used for rendering
737 * Flags: Some flags
738 *
739 * Returns:
740 * DDERR_INVALIDPARAMS if ExecuteBuffer == NULL
741 * D3D_OK on success
742 *
743 *****************************************************************************/
744 static HRESULT WINAPI d3d_device1_Execute(IDirect3DDevice *iface,
745 IDirect3DExecuteBuffer *ExecuteBuffer, IDirect3DViewport *viewport, DWORD flags)
746 {
747 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
748 struct d3d_execute_buffer *buffer = unsafe_impl_from_IDirect3DExecuteBuffer(ExecuteBuffer);
749 struct d3d_viewport *viewport_impl = unsafe_impl_from_IDirect3DViewport(viewport);
750 HRESULT hr;
751
752 TRACE("iface %p, buffer %p, viewport %p, flags %#x.\n", iface, ExecuteBuffer, viewport, flags);
753
754 if(!buffer)
755 return DDERR_INVALIDPARAMS;
756
757 if (FAILED(hr = IDirect3DDevice3_SetCurrentViewport
758 (&device->IDirect3DDevice3_iface, &viewport_impl->IDirect3DViewport3_iface)))
759 return hr;
760
761 /* Execute... */
762 wined3d_mutex_lock();
763 hr = d3d_execute_buffer_execute(buffer, device);
764 wined3d_mutex_unlock();
765
766 return hr;
767 }
768
769 /*****************************************************************************
770 * IDirect3DDevice3::AddViewport
771 *
772 * Add a Direct3DViewport to the device's viewport list. These viewports
773 * are wrapped to IDirect3DDevice7 viewports in viewport.c
774 *
775 * Exists in Version 1, 2 and 3. Note that IDirect3DViewport 1, 2 and 3
776 * are the same interfaces.
777 *
778 * Params:
779 * Viewport: The viewport to add
780 *
781 * Returns:
782 * DDERR_INVALIDPARAMS if Viewport == NULL
783 * D3D_OK on success
784 *
785 *****************************************************************************/
786 static HRESULT WINAPI d3d_device3_AddViewport(IDirect3DDevice3 *iface, IDirect3DViewport3 *viewport)
787 {
788 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
789 struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport3(viewport);
790
791 TRACE("iface %p, viewport %p.\n", iface, viewport);
792
793 /* Sanity check */
794 if(!vp)
795 return DDERR_INVALIDPARAMS;
796
797 wined3d_mutex_lock();
798 IDirect3DViewport3_AddRef(viewport);
799 list_add_head(&device->viewport_list, &vp->entry);
800 /* Viewport must be usable for Clear() after AddViewport, so set active_device here. */
801 vp->active_device = device;
802 wined3d_mutex_unlock();
803
804 return D3D_OK;
805 }
806
807 static HRESULT WINAPI d3d_device2_AddViewport(IDirect3DDevice2 *iface,
808 IDirect3DViewport2 *viewport)
809 {
810 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
811 struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport2(viewport);
812
813 TRACE("iface %p, viewport %p.\n", iface, viewport);
814
815 return d3d_device3_AddViewport(&device->IDirect3DDevice3_iface, &vp->IDirect3DViewport3_iface);
816 }
817
818 static HRESULT WINAPI d3d_device1_AddViewport(IDirect3DDevice *iface, IDirect3DViewport *viewport)
819 {
820 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
821 struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport(viewport);
822
823 TRACE("iface %p, viewport %p.\n", iface, viewport);
824
825 return d3d_device3_AddViewport(&device->IDirect3DDevice3_iface, &vp->IDirect3DViewport3_iface);
826 }
827
828 /*****************************************************************************
829 * IDirect3DDevice3::DeleteViewport
830 *
831 * Deletes a Direct3DViewport from the device's viewport list.
832 *
833 * Exists in Version 1, 2 and 3. Note that all Viewport interface versions
834 * are equal.
835 *
836 * Params:
837 * Viewport: The viewport to delete
838 *
839 * Returns:
840 * D3D_OK on success
841 * DDERR_INVALIDPARAMS if the viewport wasn't found in the list
842 *
843 *****************************************************************************/
844 static HRESULT WINAPI d3d_device3_DeleteViewport(IDirect3DDevice3 *iface, IDirect3DViewport3 *viewport)
845 {
846 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
847 struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport3(viewport);
848
849 TRACE("iface %p, viewport %p.\n", iface, viewport);
850
851 if (!vp)
852 {
853 WARN("NULL viewport, returning DDERR_INVALIDPARAMS\n");
854 return DDERR_INVALIDPARAMS;
855 }
856
857 wined3d_mutex_lock();
858
859 if (vp->active_device != device)
860 {
861 WARN("Viewport %p active device is %p.\n", vp, vp->active_device);
862 wined3d_mutex_unlock();
863 return DDERR_INVALIDPARAMS;
864 }
865
866 if (device->current_viewport == vp)
867 {
868 TRACE("Deleting current viewport, unsetting and releasing.\n");
869
870 viewport_deactivate(vp);
871 IDirect3DViewport3_Release(viewport);
872 device->current_viewport = NULL;
873 }
874
875 vp->active_device = NULL;
876 list_remove(&vp->entry);
877
878 IDirect3DViewport3_Release(viewport);
879
880 wined3d_mutex_unlock();
881
882 return D3D_OK;
883 }
884
885 static HRESULT WINAPI d3d_device2_DeleteViewport(IDirect3DDevice2 *iface, IDirect3DViewport2 *viewport)
886 {
887 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
888 struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport2(viewport);
889
890 TRACE("iface %p, viewport %p.\n", iface, viewport);
891
892 return d3d_device3_DeleteViewport(&device->IDirect3DDevice3_iface,
893 vp ? &vp->IDirect3DViewport3_iface : NULL);
894 }
895
896 static HRESULT WINAPI d3d_device1_DeleteViewport(IDirect3DDevice *iface, IDirect3DViewport *viewport)
897 {
898 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
899 struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport(viewport);
900
901 TRACE("iface %p, viewport %p.\n", iface, viewport);
902
903 return d3d_device3_DeleteViewport(&device->IDirect3DDevice3_iface,
904 vp ? &vp->IDirect3DViewport3_iface : NULL);
905 }
906
907 /*****************************************************************************
908 * IDirect3DDevice3::NextViewport
909 *
910 * Returns a viewport from the viewport list, depending on the
911 * passed viewport and the flags.
912 *
913 * Exists in Version 1, 2 and 3. Note that all Viewport interface versions
914 * are equal.
915 *
916 * Params:
917 * Viewport: Viewport to use for beginning the search
918 * Flags: D3DNEXT_NEXT, D3DNEXT_HEAD or D3DNEXT_TAIL
919 *
920 * Returns:
921 * D3D_OK on success
922 * DDERR_INVALIDPARAMS if the flags were wrong, or Viewport was NULL
923 *
924 *****************************************************************************/
925 static HRESULT WINAPI d3d_device3_NextViewport(IDirect3DDevice3 *iface,
926 IDirect3DViewport3 *Viewport3, IDirect3DViewport3 **lplpDirect3DViewport3, DWORD flags)
927 {
928 struct d3d_device *This = impl_from_IDirect3DDevice3(iface);
929 struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport3(Viewport3);
930 struct d3d_viewport *next;
931 struct list *entry;
932
933 TRACE("iface %p, viewport %p, next %p, flags %#x.\n",
934 iface, Viewport3, lplpDirect3DViewport3, flags);
935
936 if(!vp)
937 {
938 *lplpDirect3DViewport3 = NULL;
939 return DDERR_INVALIDPARAMS;
940 }
941
942
943 wined3d_mutex_lock();
944 switch (flags)
945 {
946 case D3DNEXT_NEXT:
947 entry = list_next(&This->viewport_list, &vp->entry);
948 break;
949
950 case D3DNEXT_HEAD:
951 entry = list_head(&This->viewport_list);
952 break;
953
954 case D3DNEXT_TAIL:
955 entry = list_tail(&This->viewport_list);
956 break;
957
958 default:
959 WARN("Invalid flags %#x.\n", flags);
960 *lplpDirect3DViewport3 = NULL;
961 wined3d_mutex_unlock();
962 return DDERR_INVALIDPARAMS;
963 }
964
965 if (entry)
966 {
967 next = LIST_ENTRY(entry, struct d3d_viewport, entry);
968 *lplpDirect3DViewport3 = &next->IDirect3DViewport3_iface;
969 }
970 else
971 *lplpDirect3DViewport3 = NULL;
972
973 wined3d_mutex_unlock();
974
975 return D3D_OK;
976 }
977
978 static HRESULT WINAPI d3d_device2_NextViewport(IDirect3DDevice2 *iface,
979 IDirect3DViewport2 *viewport, IDirect3DViewport2 **next, DWORD flags)
980 {
981 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
982 struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport2(viewport);
983 IDirect3DViewport3 *res;
984 HRESULT hr;
985
986 TRACE("iface %p, viewport %p, next %p, flags %#x.\n",
987 iface, viewport, next, flags);
988
989 hr = d3d_device3_NextViewport(&device->IDirect3DDevice3_iface,
990 &vp->IDirect3DViewport3_iface, &res, flags);
991 *next = (IDirect3DViewport2 *)res;
992 return hr;
993 }
994
995 static HRESULT WINAPI d3d_device1_NextViewport(IDirect3DDevice *iface,
996 IDirect3DViewport *viewport, IDirect3DViewport **next, DWORD flags)
997 {
998 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
999 struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport(viewport);
1000 IDirect3DViewport3 *res;
1001 HRESULT hr;
1002
1003 TRACE("iface %p, viewport %p, next %p, flags %#x.\n",
1004 iface, viewport, next, flags);
1005
1006 hr = d3d_device3_NextViewport(&device->IDirect3DDevice3_iface,
1007 &vp->IDirect3DViewport3_iface, &res, flags);
1008 *next = (IDirect3DViewport *)res;
1009 return hr;
1010 }
1011
1012 /*****************************************************************************
1013 * IDirect3DDevice::Pick
1014 *
1015 * Executes an execute buffer without performing rendering. Instead, a
1016 * list of primitives that intersect with (x1,y1) of the passed rectangle
1017 * is created. IDirect3DDevice::GetPickRecords can be used to retrieve
1018 * this list.
1019 *
1020 * Version 1 only
1021 *
1022 * Params:
1023 * ExecuteBuffer: Buffer to execute
1024 * Viewport: Viewport to use for execution
1025 * Flags: None are defined, according to the SDK
1026 * Rect: Specifies the coordinates to be picked. Only x1 and y2 are used,
1027 * x2 and y2 are ignored.
1028 *
1029 * Returns:
1030 * D3D_OK because it's a stub
1031 *
1032 *****************************************************************************/
1033 static HRESULT WINAPI d3d_device1_Pick(IDirect3DDevice *iface, IDirect3DExecuteBuffer *buffer,
1034 IDirect3DViewport *viewport, DWORD flags, D3DRECT *rect)
1035 {
1036 FIXME("iface %p, buffer %p, viewport %p, flags %#x, rect %s stub!\n",
1037 iface, buffer, viewport, flags, wine_dbgstr_rect((RECT *)rect));
1038
1039 return D3D_OK;
1040 }
1041
1042 /*****************************************************************************
1043 * IDirect3DDevice::GetPickRecords
1044 *
1045 * Retrieves the pick records generated by IDirect3DDevice::GetPickRecords
1046 *
1047 * Version 1 only
1048 *
1049 * Params:
1050 * Count: Pointer to a DWORD containing the numbers of pick records to
1051 * retrieve
1052 * D3DPickRec: Address to store the resulting D3DPICKRECORD array.
1053 *
1054 * Returns:
1055 * D3D_OK, because it's a stub
1056 *
1057 *****************************************************************************/
1058 static HRESULT WINAPI d3d_device1_GetPickRecords(IDirect3DDevice *iface,
1059 DWORD *count, D3DPICKRECORD *records)
1060 {
1061 FIXME("iface %p, count %p, records %p stub!\n", iface, count, records);
1062
1063 return D3D_OK;
1064 }
1065
1066 /*****************************************************************************
1067 * IDirect3DDevice7::EnumTextureformats
1068 *
1069 * Enumerates the supported texture formats. It checks against a list of all possible
1070 * formats to see if WineD3D supports it. If so, then it is passed to the app.
1071 *
1072 * This is for Version 7 and 3, older versions have a different
1073 * callback function and their own implementation
1074 *
1075 * Params:
1076 * Callback: Callback to call for each enumerated format
1077 * Arg: Argument to pass to the callback
1078 *
1079 * Returns:
1080 * D3D_OK on success
1081 * DDERR_INVALIDPARAMS if Callback == NULL
1082 *
1083 *****************************************************************************/
1084 static HRESULT d3d_device7_EnumTextureFormats(IDirect3DDevice7 *iface,
1085 LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
1086 {
1087 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
1088 struct wined3d_display_mode mode;
1089 HRESULT hr;
1090 unsigned int i;
1091
1092 static const enum wined3d_format_id FormatList[] =
1093 {
1094 /* 16 bit */
1095 WINED3DFMT_B5G5R5X1_UNORM,
1096 WINED3DFMT_B5G5R5A1_UNORM,
1097 WINED3DFMT_B4G4R4A4_UNORM,
1098 WINED3DFMT_B5G6R5_UNORM,
1099 /* 32 bit */
1100 WINED3DFMT_B8G8R8X8_UNORM,
1101 WINED3DFMT_B8G8R8A8_UNORM,
1102 /* 8 bit */
1103 WINED3DFMT_B2G3R3_UNORM,
1104 WINED3DFMT_P8_UINT,
1105 /* FOURCC codes */
1106 WINED3DFMT_DXT1,
1107 WINED3DFMT_DXT2,
1108 WINED3DFMT_DXT3,
1109 WINED3DFMT_DXT4,
1110 WINED3DFMT_DXT5,
1111 };
1112
1113 static const enum wined3d_format_id BumpFormatList[] =
1114 {
1115 WINED3DFMT_R8G8_SNORM,
1116 WINED3DFMT_R5G5_SNORM_L6_UNORM,
1117 WINED3DFMT_R8G8_SNORM_L8X8_UNORM,
1118 WINED3DFMT_R10G11B11_SNORM,
1119 WINED3DFMT_R10G10B10_SNORM_A2_UNORM
1120 };
1121
1122 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
1123
1124 if (!callback)
1125 return DDERR_INVALIDPARAMS;
1126
1127 wined3d_mutex_lock();
1128
1129 memset(&mode, 0, sizeof(mode));
1130 if (FAILED(hr = wined3d_output_get_display_mode(device->ddraw->wined3d_output, &mode, NULL)))
1131 {
1132 wined3d_mutex_unlock();
1133 WARN("Failed to get output display mode, hr %#x.\n", hr);
1134 return hr;
1135 }
1136
1137 for (i = 0; i < ARRAY_SIZE(FormatList); ++i)
1138 {
1139 if (wined3d_check_device_format(device->ddraw->wined3d, device->ddraw->wined3d_adapter,
1140 WINED3D_DEVICE_TYPE_HAL, mode.format_id, 0, WINED3D_BIND_SHADER_RESOURCE,
1141 WINED3D_RTYPE_TEXTURE_2D, FormatList[i]) == D3D_OK)
1142 {
1143 DDPIXELFORMAT pformat;
1144
1145 memset(&pformat, 0, sizeof(pformat));
1146 pformat.dwSize = sizeof(pformat);
1147 ddrawformat_from_wined3dformat(&pformat, FormatList[i]);
1148
1149 TRACE("Enumerating WineD3DFormat %d\n", FormatList[i]);
1150 hr = callback(&pformat, context);
1151 if(hr != DDENUMRET_OK)
1152 {
1153 TRACE("Format enumeration cancelled by application\n");
1154 wined3d_mutex_unlock();
1155 return D3D_OK;
1156 }
1157 }
1158 }
1159
1160 for (i = 0; i < ARRAY_SIZE(BumpFormatList); ++i)
1161 {
1162 if (wined3d_check_device_format(device->ddraw->wined3d, device->ddraw->wined3d_adapter,
1163 WINED3D_DEVICE_TYPE_HAL, mode.format_id, WINED3DUSAGE_QUERY_LEGACYBUMPMAP,
1164 WINED3D_BIND_SHADER_RESOURCE, WINED3D_RTYPE_TEXTURE_2D, BumpFormatList[i]) == D3D_OK)
1165 {
1166 DDPIXELFORMAT pformat;
1167
1168 memset(&pformat, 0, sizeof(pformat));
1169 pformat.dwSize = sizeof(pformat);
1170 ddrawformat_from_wined3dformat(&pformat, BumpFormatList[i]);
1171
1172 TRACE("Enumerating WineD3DFormat %d\n", BumpFormatList[i]);
1173 hr = callback(&pformat, context);
1174 if(hr != DDENUMRET_OK)
1175 {
1176 TRACE("Format enumeration cancelled by application\n");
1177 wined3d_mutex_unlock();
1178 return D3D_OK;
1179 }
1180 }
1181 }
1182 TRACE("End of enumeration\n");
1183 wined3d_mutex_unlock();
1184
1185 return D3D_OK;
1186 }
1187
1188 static HRESULT WINAPI d3d_device7_EnumTextureFormats_FPUSetup(IDirect3DDevice7 *iface,
1189 LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
1190 {
1191 return d3d_device7_EnumTextureFormats(iface, callback, context);
1192 }
1193
1194 static HRESULT WINAPI d3d_device7_EnumTextureFormats_FPUPreserve(IDirect3DDevice7 *iface,
1195 LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
1196 {
1197 HRESULT hr;
1198 WORD old_fpucw;
1199
1200 old_fpucw = d3d_fpu_setup();
1201 hr = d3d_device7_EnumTextureFormats(iface, callback, context);
1202 set_fpu_control_word(old_fpucw);
1203
1204 return hr;
1205 }
1206
1207 static HRESULT WINAPI d3d_device3_EnumTextureFormats(IDirect3DDevice3 *iface,
1208 LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
1209 {
1210 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
1211
1212 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
1213
1214 return IDirect3DDevice7_EnumTextureFormats(&device->IDirect3DDevice7_iface, callback, context);
1215 }
1216
1217 /*****************************************************************************
1218 * IDirect3DDevice2::EnumTextureformats
1219 *
1220 * EnumTextureFormats for Version 1 and 2, see
1221 * IDirect3DDevice7::EnumTextureFormats for a more detailed description.
1222 *
1223 * This version has a different callback and does not enumerate FourCC
1224 * formats
1225 *
1226 *****************************************************************************/
1227 static HRESULT WINAPI d3d_device2_EnumTextureFormats(IDirect3DDevice2 *iface,
1228 LPD3DENUMTEXTUREFORMATSCALLBACK callback, void *context)
1229 {
1230 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
1231 struct wined3d_display_mode mode;
1232 HRESULT hr;
1233 unsigned int i;
1234
1235 static const enum wined3d_format_id FormatList[] =
1236 {
1237 /* 16 bit */
1238 WINED3DFMT_B5G5R5X1_UNORM,
1239 WINED3DFMT_B5G5R5A1_UNORM,
1240 WINED3DFMT_B4G4R4A4_UNORM,
1241 WINED3DFMT_B5G6R5_UNORM,
1242 /* 32 bit */
1243 WINED3DFMT_B8G8R8X8_UNORM,
1244 WINED3DFMT_B8G8R8A8_UNORM,
1245 /* 8 bit */
1246 WINED3DFMT_B2G3R3_UNORM,
1247 WINED3DFMT_P8_UINT,
1248 /* FOURCC codes - Not in this version*/
1249 };
1250
1251 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
1252
1253 if (!callback)
1254 return DDERR_INVALIDPARAMS;
1255
1256 wined3d_mutex_lock();
1257
1258 memset(&mode, 0, sizeof(mode));
1259 if (FAILED(hr = wined3d_output_get_display_mode(device->ddraw->wined3d_output, &mode, NULL)))
1260 {
1261 wined3d_mutex_unlock();
1262 WARN("Failed to get output display mode, hr %#x.\n", hr);
1263 return hr;
1264 }
1265
1266 for (i = 0; i < ARRAY_SIZE(FormatList); ++i)
1267 {
1268 if (wined3d_check_device_format(device->ddraw->wined3d, device->ddraw->wined3d_adapter,
1269 WINED3D_DEVICE_TYPE_HAL, mode.format_id, 0, WINED3D_BIND_SHADER_RESOURCE,
1270 WINED3D_RTYPE_TEXTURE_2D, FormatList[i]) == D3D_OK)
1271 {
1272 DDSURFACEDESC sdesc;
1273
1274 memset(&sdesc, 0, sizeof(sdesc));
1275 sdesc.dwSize = sizeof(sdesc);
1276 sdesc.dwFlags = DDSD_PIXELFORMAT | DDSD_CAPS;
1277 sdesc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1278 sdesc.ddpfPixelFormat.dwSize = sizeof(sdesc.ddpfPixelFormat);
1279 ddrawformat_from_wined3dformat(&sdesc.ddpfPixelFormat, FormatList[i]);
1280
1281 TRACE("Enumerating WineD3DFormat %d\n", FormatList[i]);
1282 hr = callback(&sdesc, context);
1283 if(hr != DDENUMRET_OK)
1284 {
1285 TRACE("Format enumeration cancelled by application\n");
1286 wined3d_mutex_unlock();
1287 return D3D_OK;
1288 }
1289 }
1290 }
1291 TRACE("End of enumeration\n");
1292 wined3d_mutex_unlock();
1293
1294 return D3D_OK;
1295 }
1296
1297 static HRESULT WINAPI d3d_device1_EnumTextureFormats(IDirect3DDevice *iface,
1298 LPD3DENUMTEXTUREFORMATSCALLBACK callback, void *context)
1299 {
1300 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
1301
1302 TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
1303
1304 return d3d_device2_EnumTextureFormats(&device->IDirect3DDevice2_iface, callback, context);
1305 }
1306
1307 /*****************************************************************************
1308 * IDirect3DDevice::CreateMatrix
1309 *
1310 * Creates a matrix handle. A handle is created and memory for a D3DMATRIX is
1311 * allocated for the handle.
1312 *
1313 * Version 1 only
1314 *
1315 * Params
1316 * D3DMatHandle: Address to return the handle at
1317 *
1318 * Returns:
1319 * D3D_OK on success
1320 * DDERR_INVALIDPARAMS if D3DMatHandle = NULL
1321 *
1322 *****************************************************************************/
1323 static HRESULT WINAPI d3d_device1_CreateMatrix(IDirect3DDevice *iface, D3DMATRIXHANDLE *D3DMatHandle)
1324 {
1325 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
1326 D3DMATRIX *matrix;
1327 DWORD h;
1328
1329 TRACE("iface %p, matrix_handle %p.\n", iface, D3DMatHandle);
1330
1331 if(!D3DMatHandle)
1332 return DDERR_INVALIDPARAMS;
1333
1334 if (!(matrix = heap_alloc_zero(sizeof(*matrix))))
1335 {
1336 ERR("Out of memory when allocating a D3DMATRIX\n");
1337 return DDERR_OUTOFMEMORY;
1338 }
1339
1340 wined3d_mutex_lock();
1341
1342 h = ddraw_allocate_handle(&device->handle_table, matrix, DDRAW_HANDLE_MATRIX);
1343 if (h == DDRAW_INVALID_HANDLE)
1344 {
1345 ERR("Failed to allocate a matrix handle.\n");
1346 heap_free(matrix);
1347 wined3d_mutex_unlock();
1348 return DDERR_OUTOFMEMORY;
1349 }
1350
1351 *D3DMatHandle = h + 1;
1352
1353 TRACE(" returning matrix handle %d\n", *D3DMatHandle);
1354
1355 wined3d_mutex_unlock();
1356
1357 return D3D_OK;
1358 }
1359
1360 /*****************************************************************************
1361 * IDirect3DDevice::SetMatrix
1362 *
1363 * Sets a matrix for a matrix handle. The matrix is copied into the memory
1364 * allocated for the handle
1365 *
1366 * Version 1 only
1367 *
1368 * Params:
1369 * D3DMatHandle: Handle to set the matrix to
1370 * D3DMatrix: Matrix to set
1371 *
1372 * Returns:
1373 * D3D_OK on success
1374 * DDERR_INVALIDPARAMS if the handle of the matrix is invalid or the matrix
1375 * to set is NULL
1376 *
1377 *****************************************************************************/
1378 static HRESULT WINAPI d3d_device1_SetMatrix(IDirect3DDevice *iface,
1379 D3DMATRIXHANDLE matrix_handle, D3DMATRIX *matrix)
1380 {
1381 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
1382 D3DMATRIX *m;
1383
1384 TRACE("iface %p, matrix_handle %#x, matrix %p.\n", iface, matrix_handle, matrix);
1385
1386 if (!matrix)
1387 return DDERR_INVALIDPARAMS;
1388
1389 wined3d_mutex_lock();
1390
1391 m = ddraw_get_object(&device->handle_table, matrix_handle - 1, DDRAW_HANDLE_MATRIX);
1392 if (!m)
1393 {
1394 WARN("Invalid matrix handle.\n");
1395 wined3d_mutex_unlock();
1396 return DDERR_INVALIDPARAMS;
1397 }
1398
1399 if (TRACE_ON(ddraw))
1400 dump_D3DMATRIX(matrix);
1401
1402 *m = *matrix;
1403
1404 if (matrix_handle == device->world)
1405 wined3d_stateblock_set_transform(device->state,
1406 WINED3D_TS_WORLD_MATRIX(0), (struct wined3d_matrix *)matrix);
1407
1408 if (matrix_handle == device->view)
1409 wined3d_stateblock_set_transform(device->state,
1410 WINED3D_TS_VIEW, (struct wined3d_matrix *)matrix);
1411
1412 if (matrix_handle == device->proj)
1413 wined3d_stateblock_set_transform(device->state,
1414 WINED3D_TS_PROJECTION, (struct wined3d_matrix *)matrix);
1415
1416 wined3d_mutex_unlock();
1417
1418 return D3D_OK;
1419 }
1420
1421 /*****************************************************************************
1422 * IDirect3DDevice::GetMatrix
1423 *
1424 * Returns the content of a D3DMATRIX handle
1425 *
1426 * Version 1 only
1427 *
1428 * Params:
1429 * D3DMatHandle: Matrix handle to read the content from
1430 * D3DMatrix: Address to store the content at
1431 *
1432 * Returns:
1433 * D3D_OK on success
1434 * DDERR_INVALIDPARAMS if D3DMatHandle is invalid or D3DMatrix is NULL
1435 *
1436 *****************************************************************************/
1437 static HRESULT WINAPI d3d_device1_GetMatrix(IDirect3DDevice *iface,
1438 D3DMATRIXHANDLE D3DMatHandle, D3DMATRIX *D3DMatrix)
1439 {
1440 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
1441 D3DMATRIX *m;
1442
1443 TRACE("iface %p, matrix_handle %#x, matrix %p.\n", iface, D3DMatHandle, D3DMatrix);
1444
1445 if (!D3DMatrix) return DDERR_INVALIDPARAMS;
1446
1447 wined3d_mutex_lock();
1448
1449 m = ddraw_get_object(&device->handle_table, D3DMatHandle - 1, DDRAW_HANDLE_MATRIX);
1450 if (!m)
1451 {
1452 WARN("Invalid matrix handle.\n");
1453 wined3d_mutex_unlock();
1454 return DDERR_INVALIDPARAMS;
1455 }
1456
1457 *D3DMatrix = *m;
1458
1459 wined3d_mutex_unlock();
1460
1461 return D3D_OK;
1462 }
1463
1464 /*****************************************************************************
1465 * IDirect3DDevice::DeleteMatrix
1466 *
1467 * Destroys a Matrix handle. Frees the memory and unsets the handle data
1468 *
1469 * Version 1 only
1470 *
1471 * Params:
1472 * D3DMatHandle: Handle to destroy
1473 *
1474 * Returns:
1475 * D3D_OK on success
1476 * DDERR_INVALIDPARAMS if D3DMatHandle is invalid
1477 *
1478 *****************************************************************************/
1479 static HRESULT WINAPI d3d_device1_DeleteMatrix(IDirect3DDevice *iface, D3DMATRIXHANDLE D3DMatHandle)
1480 {
1481 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
1482 D3DMATRIX *m;
1483
1484 TRACE("iface %p, matrix_handle %#x.\n", iface, D3DMatHandle);
1485
1486 wined3d_mutex_lock();
1487
1488 m = ddraw_free_handle(&device->handle_table, D3DMatHandle - 1, DDRAW_HANDLE_MATRIX);
1489 if (!m)
1490 {
1491 WARN("Invalid matrix handle.\n");
1492 wined3d_mutex_unlock();
1493 return DDERR_INVALIDPARAMS;
1494 }
1495
1496 wined3d_mutex_unlock();
1497
1498 heap_free(m);
1499
1500 return D3D_OK;
1501 }
1502
1503 /*****************************************************************************
1504 * IDirect3DDevice7::BeginScene
1505 *
1506 * This method must be called before any rendering is performed.
1507 * IDirect3DDevice::EndScene has to be called after the scene is complete
1508 *
1509 * Version 1, 2, 3 and 7
1510 *
1511 * Returns:
1512 * D3D_OK on success,
1513 * D3DERR_SCENE_IN_SCENE if WineD3D returns an error(Only in case of an already
1514 * started scene).
1515 *
1516 *****************************************************************************/
1517 static HRESULT d3d_device7_BeginScene(IDirect3DDevice7 *iface)
1518 {
1519 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
1520 HRESULT hr;
1521
1522 TRACE("iface %p.\n", iface);
1523
1524 wined3d_mutex_lock();
1525 hr = wined3d_device_begin_scene(device->wined3d_device);
1526 wined3d_mutex_unlock();
1527
1528 if(hr == WINED3D_OK) return D3D_OK;
1529 else return D3DERR_SCENE_IN_SCENE; /* TODO: Other possible causes of failure */
1530 }
1531
1532 static HRESULT WINAPI d3d_device7_BeginScene_FPUSetup(IDirect3DDevice7 *iface)
1533 {
1534 return d3d_device7_BeginScene(iface);
1535 }
1536
1537 static HRESULT WINAPI d3d_device7_BeginScene_FPUPreserve(IDirect3DDevice7 *iface)
1538 {
1539 HRESULT hr;
1540 WORD old_fpucw;
1541
1542 old_fpucw = d3d_fpu_setup();
1543 hr = d3d_device7_BeginScene(iface);
1544 set_fpu_control_word(old_fpucw);
1545
1546 return hr;
1547 }
1548
1549 static HRESULT WINAPI d3d_device3_BeginScene(IDirect3DDevice3 *iface)
1550 {
1551 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
1552
1553 TRACE("iface %p.\n", iface);
1554
1555 return IDirect3DDevice7_BeginScene(&device->IDirect3DDevice7_iface);
1556 }
1557
1558 static HRESULT WINAPI d3d_device2_BeginScene(IDirect3DDevice2 *iface)
1559 {
1560 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
1561
1562 TRACE("iface %p.\n", iface);
1563
1564 return IDirect3DDevice7_BeginScene(&device->IDirect3DDevice7_iface);
1565 }
1566
1567 static HRESULT WINAPI d3d_device1_BeginScene(IDirect3DDevice *iface)
1568 {
1569 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
1570
1571 TRACE("iface %p.\n", iface);
1572
1573 return IDirect3DDevice7_BeginScene(&device->IDirect3DDevice7_iface);
1574 }
1575
1576 /*****************************************************************************
1577 * IDirect3DDevice7::EndScene
1578 *
1579 * Ends a scene that has been begun with IDirect3DDevice7::BeginScene.
1580 * This method must be called after rendering is finished.
1581 *
1582 * Version 1, 2, 3 and 7
1583 *
1584 * Returns:
1585 * D3D_OK on success,
1586 * D3DERR_SCENE_NOT_IN_SCENE is returned if WineD3D returns an error. It does
1587 * that only if the scene was already ended.
1588 *
1589 *****************************************************************************/
1590 static HRESULT d3d_device7_EndScene(IDirect3DDevice7 *iface)
1591 {
1592 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
1593 HRESULT hr;
1594
1595 TRACE("iface %p.\n", iface);
1596
1597 wined3d_mutex_lock();
1598 hr = wined3d_device_end_scene(device->wined3d_device);
1599 wined3d_mutex_unlock();
1600
1601 if(hr == WINED3D_OK) return D3D_OK;
1602 else return D3DERR_SCENE_NOT_IN_SCENE;
1603 }
1604
1605 static HRESULT WINAPI DECLSPEC_HOTPATCH d3d_device7_EndScene_FPUSetup(IDirect3DDevice7 *iface)
1606 {
1607 return d3d_device7_EndScene(iface);
1608 }
1609
1610 static HRESULT WINAPI DECLSPEC_HOTPATCH d3d_device7_EndScene_FPUPreserve(IDirect3DDevice7 *iface)
1611 {
1612 HRESULT hr;
1613 WORD old_fpucw;
1614
1615 old_fpucw = d3d_fpu_setup();
1616 hr = d3d_device7_EndScene(iface);
1617 set_fpu_control_word(old_fpucw);
1618
1619 return hr;
1620 }
1621
1622 static HRESULT WINAPI DECLSPEC_HOTPATCH d3d_device3_EndScene(IDirect3DDevice3 *iface)
1623 {
1624 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
1625
1626 TRACE("iface %p.\n", iface);
1627
1628 return IDirect3DDevice7_EndScene(&device->IDirect3DDevice7_iface);
1629 }
1630
1631 static HRESULT WINAPI DECLSPEC_HOTPATCH d3d_device2_EndScene(IDirect3DDevice2 *iface)
1632 {
1633 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
1634
1635 TRACE("iface %p.\n", iface);
1636
1637 return IDirect3DDevice7_EndScene(&device->IDirect3DDevice7_iface);
1638 }
1639
1640 static HRESULT WINAPI DECLSPEC_HOTPATCH d3d_device1_EndScene(IDirect3DDevice *iface)
1641 {
1642 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
1643
1644 TRACE("iface %p.\n", iface);
1645
1646 return IDirect3DDevice7_EndScene(&device->IDirect3DDevice7_iface);
1647 }
1648
1649 /*****************************************************************************
1650 * IDirect3DDevice7::GetDirect3D
1651 *
1652 * Returns the IDirect3D(= interface to the DirectDraw object) used to create
1653 * this device.
1654 *
1655 * Params:
1656 * Direct3D7: Address to store the interface pointer at
1657 *
1658 * Returns:
1659 * D3D_OK on success
1660 * DDERR_INVALIDPARAMS if Direct3D7 == NULL
1661 *
1662 *****************************************************************************/
1663 static HRESULT WINAPI d3d_device7_GetDirect3D(IDirect3DDevice7 *iface, IDirect3D7 **d3d)
1664 {
1665 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
1666
1667 TRACE("iface %p, d3d %p.\n", iface, d3d);
1668
1669 if (!d3d)
1670 return DDERR_INVALIDPARAMS;
1671
1672 *d3d = &device->ddraw->IDirect3D7_iface;
1673 IDirect3D7_AddRef(*d3d);
1674
1675 TRACE("Returning interface %p.\n", *d3d);
1676 return D3D_OK;
1677 }
1678
1679 static HRESULT WINAPI d3d_device3_GetDirect3D(IDirect3DDevice3 *iface, IDirect3D3 **d3d)
1680 {
1681 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
1682
1683 TRACE("iface %p, d3d %p.\n", iface, d3d);
1684
1685 if (!d3d)
1686 return DDERR_INVALIDPARAMS;
1687
1688 *d3d = &device->ddraw->IDirect3D3_iface;
1689 IDirect3D3_AddRef(*d3d);
1690
1691 TRACE("Returning interface %p.\n", *d3d);
1692 return D3D_OK;
1693 }
1694
1695 static HRESULT WINAPI d3d_device2_GetDirect3D(IDirect3DDevice2 *iface, IDirect3D2 **d3d)
1696 {
1697 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
1698
1699 TRACE("iface %p, d3d %p.\n", iface, d3d);
1700
1701 if (!d3d)
1702 return DDERR_INVALIDPARAMS;
1703
1704 *d3d = &device->ddraw->IDirect3D2_iface;
1705 IDirect3D2_AddRef(*d3d);
1706
1707 TRACE("Returning interface %p.\n", *d3d);
1708 return D3D_OK;
1709 }
1710
1711 static HRESULT WINAPI d3d_device1_GetDirect3D(IDirect3DDevice *iface, IDirect3D **d3d)
1712 {
1713 struct d3d_device *device = impl_from_IDirect3DDevice(iface);
1714
1715 TRACE("iface %p, d3d %p.\n", iface, d3d);
1716
1717 if (!d3d)
1718 return DDERR_INVALIDPARAMS;
1719
1720 *d3d = &device->ddraw->IDirect3D_iface;
1721 IDirect3D_AddRef(*d3d);
1722
1723 TRACE("Returning interface %p.\n", *d3d);
1724 return D3D_OK;
1725 }
1726
1727 /*****************************************************************************
1728 * IDirect3DDevice3::SetCurrentViewport
1729 *
1730 * Sets a Direct3DViewport as the current viewport.
1731 * For the thunks note that all viewport interface versions are equal
1732 *
1733 * Params:
1734 * Direct3DViewport3: The viewport to set
1735 *
1736 * Version 2 and 3
1737 *
1738 * Returns:
1739 * D3D_OK on success
1740 * (Is a NULL viewport valid?)
1741 *
1742 *****************************************************************************/
1743 static HRESULT WINAPI d3d_device3_SetCurrentViewport(IDirect3DDevice3 *iface, IDirect3DViewport3 *viewport)
1744 {
1745 struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport3(viewport);
1746 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
1747
1748 TRACE("iface %p, viewport %p, current_viewport %p.\n", iface, viewport, device->current_viewport);
1749
1750 if (!vp)
1751 {
1752 WARN("Direct3DViewport3 is NULL.\n");
1753 return DDERR_INVALIDPARAMS;
1754 }
1755
1756 wined3d_mutex_lock();
1757 /* Do nothing if the specified viewport is the same as the current one */
1758 if (device->current_viewport == vp)
1759 {
1760 wined3d_mutex_unlock();
1761 return D3D_OK;
1762 }
1763
1764 if (vp->active_device != device)
1765 {
1766 WARN("Viewport %p, active device %p.\n", vp, vp->active_device);
1767 wined3d_mutex_unlock();
1768 return DDERR_INVALIDPARAMS;
1769 }
1770
1771 IDirect3DViewport3_AddRef(viewport);
1772 if (device->current_viewport)
1773 {
1774 viewport_deactivate(device->current_viewport);
1775 IDirect3DViewport3_Release(&device->current_viewport->IDirect3DViewport3_iface);
1776 }
1777 device->current_viewport = vp;
1778 viewport_activate(device->current_viewport, FALSE);
1779
1780 wined3d_mutex_unlock();
1781
1782 return D3D_OK;
1783 }
1784
1785 static HRESULT WINAPI d3d_device2_SetCurrentViewport(IDirect3DDevice2 *iface, IDirect3DViewport2 *viewport)
1786 {
1787 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
1788 struct d3d_viewport *vp = unsafe_impl_from_IDirect3DViewport2(viewport);
1789
1790 TRACE("iface %p, viewport %p.\n", iface, viewport);
1791
1792 return d3d_device3_SetCurrentViewport(&device->IDirect3DDevice3_iface,
1793 vp ? &vp->IDirect3DViewport3_iface : NULL);
1794 }
1795
1796 /*****************************************************************************
1797 * IDirect3DDevice3::GetCurrentViewport
1798 *
1799 * Returns the currently active viewport.
1800 *
1801 * Version 2 and 3
1802 *
1803 * Params:
1804 * Direct3DViewport3: Address to return the interface pointer at
1805 *
1806 * Returns:
1807 * D3D_OK on success
1808 * DDERR_INVALIDPARAMS if Direct3DViewport == NULL
1809 *
1810 *****************************************************************************/
1811 static HRESULT WINAPI d3d_device3_GetCurrentViewport(IDirect3DDevice3 *iface, IDirect3DViewport3 **viewport)
1812 {
1813 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
1814
1815 TRACE("iface %p, viewport %p.\n", iface, viewport);
1816
1817 wined3d_mutex_lock();
1818 if (!device->current_viewport)
1819 {
1820 wined3d_mutex_unlock();
1821 WARN("No current viewport, returning D3DERR_NOCURRENTVIEWPORT\n");
1822 return D3DERR_NOCURRENTVIEWPORT;
1823 }
1824
1825 *viewport = &device->current_viewport->IDirect3DViewport3_iface;
1826 IDirect3DViewport3_AddRef(*viewport);
1827
1828 TRACE("Returning interface %p.\n", *viewport);
1829 wined3d_mutex_unlock();
1830 return D3D_OK;
1831 }
1832
1833 static HRESULT WINAPI d3d_device2_GetCurrentViewport(IDirect3DDevice2 *iface, IDirect3DViewport2 **viewport)
1834 {
1835 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
1836
1837 TRACE("iface %p, viewport %p.\n", iface, viewport);
1838
1839 return d3d_device3_GetCurrentViewport(&device->IDirect3DDevice3_iface,
1840 (IDirect3DViewport3 **)viewport);
1841 }
1842
1843 static BOOL validate_surface_palette(struct ddraw_surface *surface)
1844 {
1845 return !format_is_paletteindexed(&surface->surface_desc.u4.ddpfPixelFormat)
1846 || surface->palette;
1847 }
1848
1849 static HRESULT d3d_device_set_render_target(struct d3d_device *device,
1850 struct ddraw_surface *target, IUnknown *rt_iface)
1851 {
1852 struct wined3d_rendertarget_view *rtv;
1853 HRESULT hr;
1854
1855 if (device->rt_iface == rt_iface)
1856 {
1857 TRACE("No-op SetRenderTarget operation, not doing anything\n");
1858 return D3D_OK;
1859 }
1860 if (!target)
1861 {
1862 WARN("Trying to set render target to NULL.\n");
1863 return DDERR_INVALIDPARAMS;
1864 }
1865
1866 rtv = ddraw_surface_get_rendertarget_view(target);
1867 if (FAILED(hr = wined3d_device_context_set_rendertarget_views(device->immediate_context, 0, 1, &rtv, FALSE)))
1868 return hr;
1869
1870 IUnknown_AddRef(rt_iface);
1871 IUnknown_Release(device->rt_iface);
1872 device->rt_iface = rt_iface;
1873 d3d_device_update_depth_stencil(device);
1874
1875 return D3D_OK;
1876 }
1877
1878 static HRESULT d3d_device7_SetRenderTarget(IDirect3DDevice7 *iface,
1879 IDirectDrawSurface7 *target, DWORD flags)
1880 {
1881 struct ddraw_surface *target_impl = unsafe_impl_from_IDirectDrawSurface7(target);
1882 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
1883 HRESULT hr;
1884
1885 TRACE("iface %p, target %p, flags %#x.\n", iface, target, flags);
1886
1887 wined3d_mutex_lock();
1888
1889 if (!validate_surface_palette(target_impl))
1890 {
1891 WARN("Surface %p has an indexed pixel format, but no palette.\n", target_impl);
1892 wined3d_mutex_unlock();
1893 return DDERR_INVALIDCAPS;
1894 }
1895
1896 if (!(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE))
1897 {
1898 WARN("Surface %p is not a render target.\n", target_impl);
1899 wined3d_mutex_unlock();
1900 return DDERR_INVALIDCAPS;
1901 }
1902
1903 if (device->hardware_device && !(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
1904 {
1905 WARN("Surface %p is not in video memory.\n", target_impl);
1906 wined3d_mutex_unlock();
1907 return DDERR_INVALIDPARAMS;
1908 }
1909
1910 if (target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
1911 {
1912 WARN("Surface %p is a depth buffer.\n", target_impl);
1913 IDirectDrawSurface7_AddRef(target);
1914 IUnknown_Release(device->rt_iface);
1915 device->rt_iface = (IUnknown *)target;
1916 wined3d_mutex_unlock();
1917 return DDERR_INVALIDPIXELFORMAT;
1918 }
1919
1920 hr = d3d_device_set_render_target(device, target_impl, (IUnknown *)target);
1921 wined3d_mutex_unlock();
1922 return hr;
1923 }
1924
1925 static HRESULT WINAPI d3d_device7_SetRenderTarget_FPUSetup(IDirect3DDevice7 *iface,
1926 IDirectDrawSurface7 *NewTarget, DWORD flags)
1927 {
1928 return d3d_device7_SetRenderTarget(iface, NewTarget, flags);
1929 }
1930
1931 static HRESULT WINAPI d3d_device7_SetRenderTarget_FPUPreserve(IDirect3DDevice7 *iface,
1932 IDirectDrawSurface7 *NewTarget, DWORD flags)
1933 {
1934 HRESULT hr;
1935 WORD old_fpucw;
1936
1937 old_fpucw = d3d_fpu_setup();
1938 hr = d3d_device7_SetRenderTarget(iface, NewTarget, flags);
1939 set_fpu_control_word(old_fpucw);
1940
1941 return hr;
1942 }
1943
1944 static HRESULT WINAPI d3d_device3_SetRenderTarget(IDirect3DDevice3 *iface,
1945 IDirectDrawSurface4 *target, DWORD flags)
1946 {
1947 struct ddraw_surface *target_impl = unsafe_impl_from_IDirectDrawSurface4(target);
1948 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
1949 HRESULT hr;
1950
1951 TRACE("iface %p, target %p, flags %#x.\n", iface, target, flags);
1952
1953 wined3d_mutex_lock();
1954
1955 if (!validate_surface_palette(target_impl))
1956 {
1957 WARN("Surface %p has an indexed pixel format, but no palette.\n", target_impl);
1958 wined3d_mutex_unlock();
1959 return DDERR_INVALIDCAPS;
1960 }
1961
1962 if (!(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE))
1963 {
1964 WARN("Surface %p is not a render target.\n", target_impl);
1965 wined3d_mutex_unlock();
1966 return DDERR_INVALIDCAPS;
1967 }
1968
1969 if (target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
1970 {
1971 WARN("Surface %p is a depth buffer.\n", target_impl);
1972 IDirectDrawSurface4_AddRef(target);
1973 IUnknown_Release(device->rt_iface);
1974 device->rt_iface = (IUnknown *)target;
1975 wined3d_mutex_unlock();
1976 return DDERR_INVALIDPIXELFORMAT;
1977 }
1978
1979 if (device->hardware_device && !(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
1980 {
1981 WARN("Surface %p is not in video memory.\n", target_impl);
1982 IDirectDrawSurface4_AddRef(target);
1983 IUnknown_Release(device->rt_iface);
1984 device->rt_iface = (IUnknown *)target;
1985 wined3d_mutex_unlock();
1986 return D3D_OK;
1987 }
1988
1989 hr = d3d_device_set_render_target(device, target_impl, (IUnknown *)target);
1990 wined3d_mutex_unlock();
1991 return hr;
1992 }
1993
1994 static HRESULT WINAPI d3d_device2_SetRenderTarget(IDirect3DDevice2 *iface,
1995 IDirectDrawSurface *target, DWORD flags)
1996 {
1997 struct ddraw_surface *target_impl = unsafe_impl_from_IDirectDrawSurface(target);
1998 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
1999 HRESULT hr;
2000
2001 TRACE("iface %p, target %p, flags %#x.\n", iface, target, flags);
2002
2003 wined3d_mutex_lock();
2004
2005 if (!validate_surface_palette(target_impl))
2006 {
2007 WARN("Surface %p has an indexed pixel format, but no palette.\n", target_impl);
2008 wined3d_mutex_unlock();
2009 return DDERR_INVALIDCAPS;
2010 }
2011
2012 if (!(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE))
2013 {
2014 WARN("Surface %p is not a render target.\n", target_impl);
2015 wined3d_mutex_unlock();
2016 return DDERR_INVALIDCAPS;
2017 }
2018
2019 if (target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
2020 {
2021 WARN("Surface %p is a depth buffer.\n", target_impl);
2022 IUnknown_Release(device->rt_iface);
2023 device->rt_iface = (IUnknown *)target;
2024 wined3d_mutex_unlock();
2025 return DDERR_INVALIDPIXELFORMAT;
2026 }
2027
2028 if (device->hardware_device && !(target_impl->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
2029 {
2030 WARN("Surface %p is not in video memory.\n", target_impl);
2031 IDirectDrawSurface_AddRef(target);
2032 IUnknown_Release(device->rt_iface);
2033 device->rt_iface = (IUnknown *)target;
2034 wined3d_mutex_unlock();
2035 return D3D_OK;
2036 }
2037
2038 hr = d3d_device_set_render_target(device, target_impl, (IUnknown *)target);
2039 wined3d_mutex_unlock();
2040 return hr;
2041 }
2042
2043 /*****************************************************************************
2044 * IDirect3DDevice7::GetRenderTarget
2045 *
2046 * Returns the current render target.
2047 * This is handled locally, because the WineD3D render target's parent
2048 * is an IParent
2049 *
2050 * Version 2, 3 and 7
2051 *
2052 * Params:
2053 * RenderTarget: Address to store the surface interface pointer
2054 *
2055 * Returns:
2056 * D3D_OK on success
2057 * DDERR_INVALIDPARAMS if RenderTarget == NULL
2058 *
2059 *****************************************************************************/
2060 static HRESULT WINAPI d3d_device7_GetRenderTarget(IDirect3DDevice7 *iface, IDirectDrawSurface7 **RenderTarget)
2061 {
2062 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
2063 HRESULT hr;
2064
2065 TRACE("iface %p, target %p.\n", iface, RenderTarget);
2066
2067 if(!RenderTarget)
2068 return DDERR_INVALIDPARAMS;
2069
2070 wined3d_mutex_lock();
2071 hr = IUnknown_QueryInterface(device->rt_iface, &IID_IDirectDrawSurface7, (void **)RenderTarget);
2072 wined3d_mutex_unlock();
2073
2074 return hr;
2075 }
2076
2077 static HRESULT WINAPI d3d_device3_GetRenderTarget(IDirect3DDevice3 *iface, IDirectDrawSurface4 **RenderTarget)
2078 {
2079 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
2080 IDirectDrawSurface7 *RenderTarget7;
2081 struct ddraw_surface *RenderTargetImpl;
2082 HRESULT hr;
2083
2084 TRACE("iface %p, target %p.\n", iface, RenderTarget);
2085
2086 if(!RenderTarget)
2087 return DDERR_INVALIDPARAMS;
2088
2089 hr = d3d_device7_GetRenderTarget(&device->IDirect3DDevice7_iface, &RenderTarget7);
2090 if(hr != D3D_OK) return hr;
2091 RenderTargetImpl = impl_from_IDirectDrawSurface7(RenderTarget7);
2092 *RenderTarget = &RenderTargetImpl->IDirectDrawSurface4_iface;
2093 IDirectDrawSurface4_AddRef(*RenderTarget);
2094 IDirectDrawSurface7_Release(RenderTarget7);
2095 return D3D_OK;
2096 }
2097
2098 static HRESULT WINAPI d3d_device2_GetRenderTarget(IDirect3DDevice2 *iface, IDirectDrawSurface **RenderTarget)
2099 {
2100 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
2101 IDirectDrawSurface7 *RenderTarget7;
2102 struct ddraw_surface *RenderTargetImpl;
2103 HRESULT hr;
2104
2105 TRACE("iface %p, target %p.\n", iface, RenderTarget);
2106
2107 if(!RenderTarget)
2108 return DDERR_INVALIDPARAMS;
2109
2110 hr = d3d_device7_GetRenderTarget(&device->IDirect3DDevice7_iface, &RenderTarget7);
2111 if(hr != D3D_OK) return hr;
2112 RenderTargetImpl = impl_from_IDirectDrawSurface7(RenderTarget7);
2113 *RenderTarget = &RenderTargetImpl->IDirectDrawSurface_iface;
2114 IDirectDrawSurface_AddRef(*RenderTarget);
2115 IDirectDrawSurface7_Release(RenderTarget7);
2116 return D3D_OK;
2117 }
2118
2119 /*****************************************************************************
2120 * IDirect3DDevice3::Begin
2121 *
2122 * Begins a description block of vertices. This is similar to glBegin()
2123 * and glEnd(). After a call to IDirect3DDevice3::End, the vertices
2124 * described with IDirect3DDevice::Vertex are drawn.
2125 *
2126 * Version 2 and 3
2127 *
2128 * Params:
2129 * PrimitiveType: The type of primitives to draw
2130 * VertexTypeDesc: A flexible vertex format description of the vertices
2131 * Flags: Some flags..
2132 *
2133 * Returns:
2134 * D3D_OK on success
2135 *
2136 *****************************************************************************/
2137 static HRESULT WINAPI d3d_device3_Begin(IDirect3DDevice3 *iface,
2138 D3DPRIMITIVETYPE primitive_type, DWORD fvf, DWORD flags)
2139 {
2140 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
2141
2142 TRACE("iface %p, primitive_type %#x, fvf %#x, flags %#x.\n",
2143 iface, primitive_type, fvf, flags);
2144
2145 wined3d_mutex_lock();
2146 device->primitive_type = primitive_type;
2147 device->vertex_type = fvf;
2148 device->render_flags = flags;
2149 device->vertex_size = get_flexible_vertex_size(device->vertex_type);
2150 device->nb_vertices = 0;
2151 wined3d_mutex_unlock();
2152
2153 return D3D_OK;
2154 }
2155
2156 static HRESULT WINAPI d3d_device2_Begin(IDirect3DDevice2 *iface,
2157 D3DPRIMITIVETYPE primitive_type, D3DVERTEXTYPE vertex_type, DWORD flags)
2158 {
2159 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
2160 DWORD fvf;
2161
2162 TRACE("iface %p, primitive_type %#x, vertex_type %#x, flags %#x.\n",
2163 iface, primitive_type, vertex_type, flags);
2164
2165 switch (vertex_type)
2166 {
2167 case D3DVT_VERTEX: fvf = D3DFVF_VERTEX; break;
2168 case D3DVT_LVERTEX: fvf = D3DFVF_LVERTEX; break;
2169 case D3DVT_TLVERTEX: fvf = D3DFVF_TLVERTEX; break;
2170 default:
2171 ERR("Unexpected vertex type %#x.\n", vertex_type);
2172 return DDERR_INVALIDPARAMS; /* Should never happen */
2173 };
2174
2175 return d3d_device3_Begin(&device->IDirect3DDevice3_iface, primitive_type, fvf, flags);
2176 }
2177
2178 /*****************************************************************************
2179 * IDirect3DDevice3::BeginIndexed
2180 *
2181 * Draws primitives based on vertices in a vertex array which are specified
2182 * by indices.
2183 *
2184 * Version 2 and 3
2185 *
2186 * Params:
2187 * PrimitiveType: Primitive type to draw
2188 * VertexType: A FVF description of the vertex format
2189 * Vertices: pointer to an array containing the vertices
2190 * NumVertices: The number of vertices in the vertex array
2191 * Flags: Some flags ...
2192 *
2193 * Returns:
2194 * D3D_OK, because it's a stub
2195 *
2196 *****************************************************************************/
2197 static HRESULT WINAPI d3d_device3_BeginIndexed(IDirect3DDevice3 *iface,
2198 D3DPRIMITIVETYPE primitive_type, DWORD fvf,
2199 void *vertices, DWORD vertex_count, DWORD flags)
2200 {
2201 FIXME("iface %p, primitive_type %#x, fvf %#x, vertices %p, vertex_count %u, flags %#x stub!\n",
2202 iface, primitive_type, fvf, vertices, vertex_count, flags);
2203
2204 return D3D_OK;
2205 }
2206
2207
2208 static HRESULT WINAPI d3d_device2_BeginIndexed(IDirect3DDevice2 *iface,
2209 D3DPRIMITIVETYPE primitive_type, D3DVERTEXTYPE vertex_type,
2210 void *vertices, DWORD vertex_count, DWORD flags)
2211 {
2212 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
2213 DWORD fvf;
2214
2215 TRACE("iface %p, primitive_type %#x, vertex_type %#x, vertices %p, vertex_count %u, flags %#x stub!\n",
2216 iface, primitive_type, vertex_type, vertices, vertex_count, flags);
2217
2218 switch (vertex_type)
2219 {
2220 case D3DVT_VERTEX: fvf = D3DFVF_VERTEX; break;
2221 case D3DVT_LVERTEX: fvf = D3DFVF_LVERTEX; break;
2222 case D3DVT_TLVERTEX: fvf = D3DFVF_TLVERTEX; break;
2223 default:
2224 ERR("Unexpected vertex type %#x.\n", vertex_type);
2225 return DDERR_INVALIDPARAMS; /* Should never happen */
2226 };
2227
2228 return d3d_device3_BeginIndexed(&device->IDirect3DDevice3_iface,
2229 primitive_type, fvf, vertices, vertex_count, flags);
2230 }
2231
2232 /*****************************************************************************
2233 * IDirect3DDevice3::Vertex
2234 *
2235 * Draws a vertex as described by IDirect3DDevice3::Begin. It places all
2236 * drawn vertices in a vertex buffer. If the buffer is too small, its
2237 * size is increased.
2238 *
2239 * Version 2 and 3
2240 *
2241 * Params:
2242 * Vertex: Pointer to the vertex
2243 *
2244 * Returns:
2245 * D3D_OK, on success
2246 * DDERR_INVALIDPARAMS if Vertex is NULL
2247 *
2248 *****************************************************************************/
2249 static HRESULT WINAPI d3d_device3_Vertex(IDirect3DDevice3 *iface, void *vertex)
2250 {
2251 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
2252
2253 TRACE("iface %p, vertex %p.\n", iface, vertex);
2254
2255 if (!vertex)
2256 return DDERR_INVALIDPARAMS;
2257
2258 wined3d_mutex_lock();
2259 if ((device->nb_vertices + 1) * device->vertex_size > device->buffer_size)
2260 {
2261 BYTE *old_buffer;
2262
2263 device->buffer_size = device->buffer_size ? device->buffer_size * 2 : device->vertex_size * 3;
2264 old_buffer = device->sysmem_vertex_buffer;
2265 device->sysmem_vertex_buffer = heap_alloc(device->buffer_size);
2266 if (old_buffer)
2267 {
2268 memcpy(device->sysmem_vertex_buffer, old_buffer, device->nb_vertices * device->vertex_size);
2269 heap_free(old_buffer);
2270 }
2271 }
2272
2273 memcpy(device->sysmem_vertex_buffer + device->nb_vertices++ * device->vertex_size, vertex, device->vertex_size);
2274 wined3d_mutex_unlock();
2275
2276 return D3D_OK;
2277 }
2278
2279 static HRESULT WINAPI d3d_device2_Vertex(IDirect3DDevice2 *iface, void *vertex)
2280 {
2281 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
2282
2283 TRACE("iface %p, vertex %p.\n", iface, vertex);
2284
2285 return d3d_device3_Vertex(&device->IDirect3DDevice3_iface, vertex);
2286 }
2287
2288 /*****************************************************************************
2289 * IDirect3DDevice3::Index
2290 *
2291 * Specifies an index to a vertex to be drawn. The vertex array has to
2292 * be specified with BeginIndexed first.
2293 *
2294 * Parameters:
2295 * VertexIndex: The index of the vertex to draw
2296 *
2297 * Returns:
2298 * D3D_OK because it's a stub
2299 *
2300 *****************************************************************************/
2301 static HRESULT WINAPI d3d_device3_Index(IDirect3DDevice3 *iface, WORD index)
2302 {
2303 FIXME("iface %p, index %#x stub!\n", iface, index);
2304
2305 return D3D_OK;
2306 }
2307
2308 static HRESULT WINAPI d3d_device2_Index(IDirect3DDevice2 *iface, WORD index)
2309 {
2310 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
2311
2312 TRACE("iface %p, index %#x.\n", iface, index);
2313
2314 return d3d_device3_Index(&device->IDirect3DDevice3_iface, index);
2315 }
2316
2317 /*****************************************************************************
2318 * IDirect3DDevice7::GetRenderState
2319 *
2320 * Returns the value of a render state. The possible render states are
2321 * defined in include/d3dtypes.h
2322 *
2323 * Version 2, 3 and 7
2324 *
2325 * Params:
2326 * RenderStateType: Render state to return the current setting of
2327 * Value: Address to store the value at
2328 *
2329 * Returns:
2330 * D3D_OK on success,
2331 * DDERR_INVALIDPARAMS if Value == NULL
2332 *
2333 *****************************************************************************/
2334 static HRESULT d3d_device7_GetRenderState(IDirect3DDevice7 *iface,
2335 D3DRENDERSTATETYPE state, DWORD *value)
2336 {
2337 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
2338 const struct wined3d_stateblock_state *device_state;
2339 HRESULT hr = D3D_OK;
2340
2341 TRACE("iface %p, state %#x, value %p.\n", iface, state, value);
2342
2343 if (!value)
2344 return DDERR_INVALIDPARAMS;
2345
2346 wined3d_mutex_lock();
2347 device_state = device->stateblock_state;
2348 switch (state)
2349 {
2350 case D3DRENDERSTATE_TEXTUREMAG:
2351 {
2352 enum wined3d_texture_filter_type tex_mag = device_state->sampler_states[0][WINED3D_SAMP_MAG_FILTER];
2353
2354 switch (tex_mag)
2355 {
2356 case WINED3D_TEXF_POINT:
2357 *value = D3DFILTER_NEAREST;
2358 break;
2359 case WINED3D_TEXF_LINEAR:
2360 *value = D3DFILTER_LINEAR;
2361 break;
2362 default:
2363 ERR("Unhandled texture mag %d !\n",tex_mag);
2364 *value = 0;
2365 }
2366 break;
2367 }
2368
2369 case D3DRENDERSTATE_TEXTUREMIN:
2370 {
2371 enum wined3d_texture_filter_type tex_min;
2372 enum wined3d_texture_filter_type tex_mip;
2373
2374 tex_min = device_state->sampler_states[0][WINED3D_SAMP_MIN_FILTER];
2375 tex_mip = device_state->sampler_states[0][WINED3D_SAMP_MIP_FILTER];
2376 switch (tex_min)
2377 {
2378 case WINED3D_TEXF_POINT:
2379 switch (tex_mip)
2380 {
2381 case WINED3D_TEXF_NONE:
2382 *value = D3DFILTER_NEAREST;
2383 break;
2384 case WINED3D_TEXF_POINT:
2385 *value = D3DFILTER_MIPNEAREST;
2386 break;
2387 case WINED3D_TEXF_LINEAR:
2388 *value = D3DFILTER_LINEARMIPNEAREST;
2389 break;
2390 default:
2391 ERR("Unhandled mip filter %#x.\n", tex_mip);
2392 *value = D3DFILTER_NEAREST;
2393 break;
2394 }
2395 break;
2396 case WINED3D_TEXF_LINEAR:
2397 switch (tex_mip)
2398 {
2399 case WINED3D_TEXF_NONE:
2400 *value = D3DFILTER_LINEAR;
2401 break;
2402 case WINED3D_TEXF_POINT:
2403 *value = D3DFILTER_MIPLINEAR;
2404 break;
2405 case WINED3D_TEXF_LINEAR:
2406 *value = D3DFILTER_LINEARMIPLINEAR;
2407 break;
2408 default:
2409 ERR("Unhandled mip filter %#x.\n", tex_mip);
2410 *value = D3DFILTER_LINEAR;
2411 break;
2412 }
2413 break;
2414 default:
2415 ERR("Unhandled texture min filter %#x.\n",tex_min);
2416 *value = D3DFILTER_NEAREST;
2417 break;
2418 }
2419 break;
2420 }
2421
2422 case D3DRENDERSTATE_TEXTUREADDRESS:
2423 case D3DRENDERSTATE_TEXTUREADDRESSU:
2424 *value = device_state->sampler_states[0][WINED3D_SAMP_ADDRESS_U];
2425 break;
2426 case D3DRENDERSTATE_TEXTUREADDRESSV:
2427 *value = device_state->sampler_states[0][WINED3D_SAMP_ADDRESS_V];
2428 break;
2429
2430 case D3DRENDERSTATE_BORDERCOLOR:
2431 FIXME("Unhandled render state D3DRENDERSTATE_BORDERCOLOR.\n");
2432 hr = E_NOTIMPL;
2433 break;
2434
2435 case D3DRENDERSTATE_TEXTUREHANDLE:
2436 case D3DRENDERSTATE_TEXTUREMAPBLEND:
2437 WARN("Render state %#x is invalid in d3d7.\n", state);
2438 hr = DDERR_INVALIDPARAMS;
2439 break;
2440
2441 default:
2442 if (state >= D3DRENDERSTATE_STIPPLEPATTERN00
2443 && state <= D3DRENDERSTATE_STIPPLEPATTERN31)
2444 {
2445 FIXME("Unhandled stipple pattern render state (%#x).\n", state);
2446 hr = E_NOTIMPL;
2447 break;
2448 }
2449 *value = device_state->rs[wined3d_render_state_from_ddraw(state)];
2450 }
2451 wined3d_mutex_unlock();
2452
2453 return hr;
2454 }
2455
2456 static HRESULT WINAPI d3d_device7_GetRenderState_FPUSetup(IDirect3DDevice7 *iface,
2457 D3DRENDERSTATETYPE state, DWORD *value)
2458 {
2459 return d3d_device7_GetRenderState(iface, state, value);
2460 }
2461
2462 static HRESULT WINAPI d3d_device7_GetRenderState_FPUPreserve(IDirect3DDevice7 *iface,
2463 D3DRENDERSTATETYPE state, DWORD *value)
2464 {
2465 HRESULT hr;
2466 WORD old_fpucw;
2467
2468 old_fpucw = d3d_fpu_setup();
2469 hr = d3d_device7_GetRenderState(iface, state, value);
2470 set_fpu_control_word(old_fpucw);
2471
2472 return hr;
2473 }
2474
2475 static HRESULT WINAPI d3d_device3_GetRenderState(IDirect3DDevice3 *iface,
2476 D3DRENDERSTATETYPE state, DWORD *value)
2477 {
2478 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
2479
2480 TRACE("iface %p, state %#x, value %p.\n", iface, state, value);
2481
2482 switch (state)
2483 {
2484 case D3DRENDERSTATE_TEXTUREHANDLE:
2485 {
2486 /* This state is wrapped to SetTexture in SetRenderState, so
2487 * it has to be wrapped to GetTexture here. */
2488 struct wined3d_texture *tex = NULL;
2489 *value = 0;
2490
2491 wined3d_mutex_lock();
2492 if ((tex = device->stateblock_state->textures[0]))
2493 {
2494 /* The parent of the texture is the IDirectDrawSurface7
2495 * interface of the ddraw surface. */
2496 struct ddraw_texture *parent = wined3d_texture_get_parent(tex);
2497 if (parent)
2498 *value = parent->root->Handle;
2499 }
2500 wined3d_mutex_unlock();
2501
2502 return D3D_OK;
2503 }
2504
2505 case D3DRENDERSTATE_TEXTUREMAPBLEND:
2506 {
2507 *value = device->texture_map_blend;
2508 return D3D_OK;
2509 }
2510
2511 case D3DRENDERSTATE_LIGHTING:
2512 case D3DRENDERSTATE_NORMALIZENORMALS:
2513 case D3DRENDERSTATE_LOCALVIEWER:
2514 *value = 0xffffffff;
2515 return D3D_OK;
2516
2517 default:
2518 return IDirect3DDevice7_GetRenderState(&device->IDirect3DDevice7_iface, state, value);
2519 }
2520 }
2521
2522 static HRESULT WINAPI d3d_device2_GetRenderState(IDirect3DDevice2 *iface,
2523 D3DRENDERSTATETYPE state, DWORD *value)
2524 {
2525 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
2526
2527 TRACE("iface %p, state %#x, value %p.\n", iface, state, value);
2528
2529 return IDirect3DDevice3_GetRenderState(&device->IDirect3DDevice3_iface, state, value);
2530 }
2531
2532 /*****************************************************************************
2533 * IDirect3DDevice7::SetRenderState
2534 *
2535 * Sets a render state. The possible render states are defined in
2536 * include/d3dtypes.h
2537 *
2538 * Version 2, 3 and 7
2539 *
2540 * Params:
2541 * RenderStateType: State to set
2542 * Value: Value to assign to that state
2543 *
2544 *****************************************************************************/
2545 static HRESULT d3d_device7_SetRenderState(IDirect3DDevice7 *iface,
2546 D3DRENDERSTATETYPE state, DWORD value)
2547 {
2548 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
2549 HRESULT hr = D3D_OK;
2550
2551 TRACE("iface %p, state %#x, value %#x.\n", iface, state, value);
2552
2553 wined3d_mutex_lock();
2554 /* Some render states need special care */
2555 switch (state)
2556 {
2557 /*
2558 * The ddraw texture filter mapping works like this:
2559 * D3DFILTER_NEAREST Point min/mag, no mip
2560 * D3DFILTER_MIPNEAREST Point min/mag, point mip
2561 * D3DFILTER_LINEARMIPNEAREST: Point min/mag, linear mip
2562 *
2563 * D3DFILTER_LINEAR Linear min/mag, no mip
2564 * D3DFILTER_MIPLINEAR Linear min/mag, point mip
2565 * D3DFILTER_LINEARMIPLINEAR Linear min/mag, linear mip
2566 *
2567 * This is the opposite of the GL naming convention,
2568 * D3DFILTER_LINEARMIPNEAREST corresponds to GL_NEAREST_MIPMAP_LINEAR.
2569 */
2570 case D3DRENDERSTATE_TEXTUREMAG:
2571 {
2572 enum wined3d_texture_filter_type tex_mag;
2573
2574 switch (value)
2575 {
2576 case D3DFILTER_NEAREST:
2577 case D3DFILTER_MIPNEAREST:
2578 case D3DFILTER_LINEARMIPNEAREST:
2579 tex_mag = WINED3D_TEXF_POINT;
2580 break;
2581 case D3DFILTER_LINEAR:
2582 case D3DFILTER_MIPLINEAR:
2583 case D3DFILTER_LINEARMIPLINEAR:
2584 tex_mag = WINED3D_TEXF_LINEAR;
2585 break;
2586 default:
2587 tex_mag = WINED3D_TEXF_POINT;
2588 FIXME("Unhandled texture mag %#x.\n", value);
2589 break;
2590 }
2591
2592 wined3d_stateblock_set_sampler_state(device->state, 0, WINED3D_SAMP_MAG_FILTER, tex_mag);
2593 break;
2594 }
2595
2596 case D3DRENDERSTATE_TEXTUREMIN:
2597 {
2598 enum wined3d_texture_filter_type tex_min;
2599 enum wined3d_texture_filter_type tex_mip;
2600
2601 switch (value)
2602 {
2603 case D3DFILTER_NEAREST:
2604 tex_min = WINED3D_TEXF_POINT;
2605 tex_mip = WINED3D_TEXF_NONE;
2606 break;
2607 case D3DFILTER_LINEAR:
2608 tex_min = WINED3D_TEXF_LINEAR;
2609 tex_mip = WINED3D_TEXF_NONE;
2610 break;
2611 case D3DFILTER_MIPNEAREST:
2612 tex_min = WINED3D_TEXF_POINT;
2613 tex_mip = WINED3D_TEXF_POINT;
2614 break;
2615 case D3DFILTER_MIPLINEAR:
2616 tex_min = WINED3D_TEXF_LINEAR;
2617 tex_mip = WINED3D_TEXF_POINT;
2618 break;
2619 case D3DFILTER_LINEARMIPNEAREST:
2620 tex_min = WINED3D_TEXF_POINT;
2621 tex_mip = WINED3D_TEXF_LINEAR;
2622 break;
2623 case D3DFILTER_LINEARMIPLINEAR:
2624 tex_min = WINED3D_TEXF_LINEAR;
2625 tex_mip = WINED3D_TEXF_LINEAR;
2626 break;
2627
2628 default:
2629 FIXME("Unhandled texture min %#x.\n",value);
2630 tex_min = WINED3D_TEXF_POINT;
2631 tex_mip = WINED3D_TEXF_NONE;
2632 break;
2633 }
2634
2635 wined3d_stateblock_set_sampler_state(device->state, 0, WINED3D_SAMP_MIP_FILTER, tex_mip);
2636 wined3d_stateblock_set_sampler_state(device->state, 0, WINED3D_SAMP_MIN_FILTER, tex_min);
2637 break;
2638 }
2639
2640 case D3DRENDERSTATE_TEXTUREADDRESS:
2641 wined3d_stateblock_set_sampler_state(device->state, 0, WINED3D_SAMP_ADDRESS_V, value);
2642 /* Drop through */
2643 case D3DRENDERSTATE_TEXTUREADDRESSU:
2644 wined3d_stateblock_set_sampler_state(device->state, 0, WINED3D_SAMP_ADDRESS_U, value);
2645 break;
2646 case D3DRENDERSTATE_TEXTUREADDRESSV:
2647 wined3d_stateblock_set_sampler_state(device->state, 0, WINED3D_SAMP_ADDRESS_V, value);
2648 break;
2649
2650 case D3DRENDERSTATE_BORDERCOLOR:
2651 /* This should probably just forward to the corresponding sampler
2652 * state. Needs tests. */
2653 FIXME("Unhandled render state D3DRENDERSTATE_BORDERCOLOR.\n");
2654 hr = E_NOTIMPL;
2655 break;
2656
2657 case D3DRENDERSTATE_TEXTUREHANDLE:
2658 case D3DRENDERSTATE_TEXTUREMAPBLEND:
2659 WARN("Render state %#x is invalid in d3d7.\n", state);
2660 hr = DDERR_INVALIDPARAMS;
2661 break;
2662
2663 default:
2664 if (state >= D3DRENDERSTATE_STIPPLEPATTERN00
2665 && state <= D3DRENDERSTATE_STIPPLEPATTERN31)
2666 {
2667 FIXME("Unhandled stipple pattern render state (%#x).\n", state);
2668 hr = E_NOTIMPL;
2669 break;
2670 }
2671
2672 wined3d_stateblock_set_render_state(device->update_state, wined3d_render_state_from_ddraw(state), value);
2673 break;
2674 }
2675 wined3d_mutex_unlock();
2676
2677 return hr;
2678 }
2679
2680 static HRESULT WINAPI d3d_device7_SetRenderState_FPUSetup(IDirect3DDevice7 *iface,
2681 D3DRENDERSTATETYPE state, DWORD value)
2682 {
2683 return d3d_device7_SetRenderState(iface, state, value);
2684 }
2685
2686 static HRESULT WINAPI d3d_device7_SetRenderState_FPUPreserve(IDirect3DDevice7 *iface,
2687 D3DRENDERSTATETYPE state, DWORD value)
2688 {
2689 HRESULT hr;
2690 WORD old_fpucw;
2691
2692 old_fpucw = d3d_fpu_setup();
2693 hr = d3d_device7_SetRenderState(iface, state, value);
2694 set_fpu_control_word(old_fpucw);
2695
2696 return hr;
2697 }
2698
2699 static void fixup_texture_alpha_op(struct d3d_device *device)
2700 {
2701 /* This fixup is required by the way D3DTBLEND_MODULATE maps to texture stage states.
2702 See d3d_device3_SetRenderState() for details. */
2703 struct wined3d_texture *tex;
2704 BOOL tex_alpha = TRUE;
2705 DDPIXELFORMAT ddfmt;
2706
2707 if (!(device->legacyTextureBlending && device->texture_map_blend == D3DTBLEND_MODULATE))
2708 return;
2709
2710 if ((tex = device->stateblock_state->textures[0]))
2711 {
2712 struct wined3d_resource_desc desc;
2713
2714 wined3d_resource_get_desc(wined3d_texture_get_resource(tex), &desc);
2715 ddfmt.dwSize = sizeof(ddfmt);
2716 ddrawformat_from_wined3dformat(&ddfmt, desc.format);
2717 if (!ddfmt.u5.dwRGBAlphaBitMask)
2718 tex_alpha = FALSE;
2719 }
2720
2721 /* Args 1 and 2 are already set to WINED3DTA_TEXTURE/WINED3DTA_CURRENT in case of D3DTBLEND_MODULATE */
2722 wined3d_stateblock_set_texture_stage_state(device->state,
2723 0, WINED3D_TSS_ALPHA_OP, tex_alpha ? WINED3D_TOP_SELECT_ARG1 : WINED3D_TOP_SELECT_ARG2);
2724 }
2725
2726 static HRESULT WINAPI d3d_device3_SetRenderState(IDirect3DDevice3 *iface,
2727 D3DRENDERSTATETYPE state, DWORD value)
2728 {
2729 /* Note about D3DRENDERSTATE_TEXTUREMAPBLEND implementation: most of values
2730 for this state can be directly mapped to texture stage colorop and alphaop, but
2731 D3DTBLEND_MODULATE is tricky: it uses alpha from texture when available and alpha
2732 from diffuse otherwise. So changing the texture must be monitored in SetTexture to modify
2733 alphaarg when needed.
2734
2735 Aliens vs Predator 1 depends on accurate D3DTBLEND_MODULATE emulation
2736
2737 Legacy texture blending (TEXTUREMAPBLEND) and texture stage states: directx6 docs state that
2738 TEXTUREMAPBLEND is deprecated, yet can still be used. Games must not use both or results
2739 are undefined. D3DTBLEND_MODULATE mode in particular is dependent on texture pixel format and
2740 requires fixup of stage 0 texture states when texture changes, but this fixup can interfere
2741 with games not using this deprecated state. So a flag 'legacyTextureBlending' has to be kept
2742 in device - TRUE if the app is using TEXTUREMAPBLEND.
2743
2744 Tests show that setting TEXTUREMAPBLEND on native doesn't seem to change values returned by
2745 GetTextureStageState and vice versa. */
2746
2747 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
2748 HRESULT hr;
2749
2750 TRACE("iface %p, state %#x, value %#x.\n", iface, state, value);
2751
2752 if (state >= D3DSTATE_OVERRIDE_BIAS)
2753 {
2754 WARN("Unhandled state %#x.\n", state);
2755 return DDERR_INVALIDPARAMS;
2756 }
2757
2758 wined3d_mutex_lock();
2759
2760 switch (state)
2761 {
2762 case D3DRENDERSTATE_TEXTUREHANDLE:
2763 {
2764 struct ddraw_surface *surf;
2765
2766 if (value == 0)
2767 {
2768 wined3d_stateblock_set_texture(device->state, 0, NULL);
2769 hr = D3D_OK;
2770 break;
2771 }
2772
2773 surf = ddraw_get_object(&device->handle_table, value - 1, DDRAW_HANDLE_SURFACE);
2774 if (!surf)
2775 {
2776 WARN("Invalid texture handle.\n");
2777 hr = DDERR_INVALIDPARAMS;
2778 break;
2779 }
2780
2781 hr = IDirect3DDevice3_SetTexture(iface, 0, &surf->IDirect3DTexture2_iface);
2782 break;
2783 }
2784
2785 case D3DRENDERSTATE_TEXTUREMAPBLEND:
2786 {
2787 if (value == device->texture_map_blend)
2788 {
2789 TRACE("Application is setting the same value over, nothing to do.\n");
2790
2791 hr = D3D_OK;
2792 break;
2793 }
2794
2795 device->legacyTextureBlending = TRUE;
2796 device->texture_map_blend = value;
2797
2798 switch (value)
2799 {
2800 case D3DTBLEND_MODULATE:
2801 {
2802 fixup_texture_alpha_op(device);
2803
2804 wined3d_stateblock_set_texture_stage_state(device->state,
2805 0, WINED3D_TSS_ALPHA_ARG1, WINED3DTA_TEXTURE);
2806 wined3d_stateblock_set_texture_stage_state(device->state,
2807 0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
2808 wined3d_stateblock_set_texture_stage_state(device->state,
2809 0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
2810 wined3d_stateblock_set_texture_stage_state(device->state,
2811 0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
2812 wined3d_stateblock_set_texture_stage_state(device->state,
2813 0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_MODULATE);
2814 break;
2815 }
2816
2817 case D3DTBLEND_ADD:
2818 wined3d_stateblock_set_texture_stage_state(device->state,
2819 0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_ADD);
2820 wined3d_stateblock_set_texture_stage_state(device->state,
2821 0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
2822 wined3d_stateblock_set_texture_stage_state(device->state,
2823 0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
2824 wined3d_stateblock_set_texture_stage_state(device->state,
2825 0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG2);
2826 wined3d_stateblock_set_texture_stage_state(device->state,
2827 0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
2828 break;
2829
2830 case D3DTBLEND_MODULATEALPHA:
2831 wined3d_stateblock_set_texture_stage_state(device->state,
2832 0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
2833 wined3d_stateblock_set_texture_stage_state(device->state,
2834 0, WINED3D_TSS_ALPHA_ARG1, WINED3DTA_TEXTURE);
2835 wined3d_stateblock_set_texture_stage_state(device->state,
2836 0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
2837 wined3d_stateblock_set_texture_stage_state(device->state,
2838 0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
2839 wined3d_stateblock_set_texture_stage_state(device->state,
2840 0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_MODULATE);
2841 wined3d_stateblock_set_texture_stage_state(device->state,
2842 0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_MODULATE);
2843 break;
2844
2845 case D3DTBLEND_COPY:
2846 case D3DTBLEND_DECAL:
2847 wined3d_stateblock_set_texture_stage_state(device->state,
2848 0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
2849 wined3d_stateblock_set_texture_stage_state(device->state,
2850 0, WINED3D_TSS_ALPHA_ARG1, WINED3DTA_TEXTURE);
2851 wined3d_stateblock_set_texture_stage_state(device->state,
2852 0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_SELECT_ARG1);
2853 wined3d_stateblock_set_texture_stage_state(device->state,
2854 0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG1);
2855 break;
2856
2857 case D3DTBLEND_DECALALPHA:
2858 wined3d_stateblock_set_texture_stage_state(device->state,
2859 0, WINED3D_TSS_COLOR_OP, WINED3D_TOP_BLEND_TEXTURE_ALPHA);
2860 wined3d_stateblock_set_texture_stage_state(device->state,
2861 0, WINED3D_TSS_COLOR_ARG1, WINED3DTA_TEXTURE);
2862 wined3d_stateblock_set_texture_stage_state(device->state,
2863 0, WINED3D_TSS_COLOR_ARG2, WINED3DTA_CURRENT);
2864 wined3d_stateblock_set_texture_stage_state(device->state,
2865 0, WINED3D_TSS_ALPHA_OP, WINED3D_TOP_SELECT_ARG2);
2866 wined3d_stateblock_set_texture_stage_state(device->state,
2867 0, WINED3D_TSS_ALPHA_ARG2, WINED3DTA_CURRENT);
2868 break;
2869
2870 default:
2871 FIXME("Unhandled texture environment %#x.\n", value);
2872 }
2873 hr = D3D_OK;
2874 break;
2875 }
2876
2877 case D3DRENDERSTATE_LIGHTING:
2878 case D3DRENDERSTATE_NORMALIZENORMALS:
2879 case D3DRENDERSTATE_LOCALVIEWER:
2880 hr = D3D_OK;
2881 break;
2882
2883 default:
2884 hr = IDirect3DDevice7_SetRenderState(&device->IDirect3DDevice7_iface, state, value);
2885 break;
2886 }
2887 wined3d_mutex_unlock();
2888
2889 return hr;
2890 }
2891
2892 static HRESULT WINAPI d3d_device2_SetRenderState(IDirect3DDevice2 *iface,
2893 D3DRENDERSTATETYPE state, DWORD value)
2894 {
2895 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
2896
2897 TRACE("iface %p, state %#x, value %#x.\n", iface, state, value);
2898
2899 return IDirect3DDevice3_SetRenderState(&device->IDirect3DDevice3_iface, state, value);
2900 }
2901
2902 /*****************************************************************************
2903 * Direct3DDevice3::SetLightState
2904 *
2905 * Sets a light state for Direct3DDevice3 and Direct3DDevice2. The
2906 * light states are forwarded to Direct3DDevice7 render states
2907 *
2908 * Version 2 and 3
2909 *
2910 * Params:
2911 * LightStateType: The light state to change
2912 * Value: The value to assign to that light state
2913 *
2914 * Returns:
2915 * D3D_OK on success
2916 * DDERR_INVALIDPARAMS if the parameters were incorrect
2917 * Also check IDirect3DDevice7::SetRenderState
2918 *
2919 *****************************************************************************/
2920 static HRESULT WINAPI d3d_device3_SetLightState(IDirect3DDevice3 *iface,
2921 D3DLIGHTSTATETYPE state, DWORD value)
2922 {
2923 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
2924 HRESULT hr;
2925
2926 TRACE("iface %p, state %#x, value %#x.\n", iface, state, value);
2927
2928 if (!state || (state > D3DLIGHTSTATE_COLORVERTEX))
2929 {
2930 TRACE("Unexpected Light State Type\n");
2931 return DDERR_INVALIDPARAMS;
2932 }
2933
2934 wined3d_mutex_lock();
2935 if (state == D3DLIGHTSTATE_MATERIAL)
2936 {
2937 if (value)
2938 {
2939 struct d3d_material *m;
2940
2941 if (!(m = ddraw_get_object(&device->handle_table, value - 1, DDRAW_HANDLE_MATERIAL)))
2942 {
2943 WARN("Invalid material handle.\n");
2944 wined3d_mutex_unlock();
2945 return DDERR_INVALIDPARAMS;
2946 }
2947
2948 material_activate(m);
2949 }
2950
2951 device->material = value;
2952 }
2953 else if (state == D3DLIGHTSTATE_COLORMODEL)
2954 {
2955 switch (value)
2956 {
2957 case D3DCOLOR_MONO:
2958 ERR("DDCOLOR_MONO should not happen!\n");
2959 break;
2960 case D3DCOLOR_RGB:
2961 /* We are already in this mode */
2962 TRACE("Setting color model to RGB (no-op).\n");
2963 break;
2964 default:
2965 ERR("Unknown color model!\n");
2966 wined3d_mutex_unlock();
2967 return DDERR_INVALIDPARAMS;
2968 }
2969 }
2970 else
2971 {
2972 D3DRENDERSTATETYPE rs;
2973 switch (state)
2974 {
2975 case D3DLIGHTSTATE_AMBIENT: /* 2 */
2976 rs = D3DRENDERSTATE_AMBIENT;
2977 break;
2978 case D3DLIGHTSTATE_FOGMODE: /* 4 */
2979 rs = D3DRENDERSTATE_FOGVERTEXMODE;
2980 break;
2981 case D3DLIGHTSTATE_FOGSTART: /* 5 */
2982 rs = D3DRENDERSTATE_FOGSTART;
2983 break;
2984 case D3DLIGHTSTATE_FOGEND: /* 6 */
2985 rs = D3DRENDERSTATE_FOGEND;
2986 break;
2987 case D3DLIGHTSTATE_FOGDENSITY: /* 7 */
2988 rs = D3DRENDERSTATE_FOGDENSITY;
2989 break;
2990 case D3DLIGHTSTATE_COLORVERTEX: /* 8 */
2991 rs = D3DRENDERSTATE_COLORVERTEX;
2992 break;
2993 default:
2994 FIXME("Unhandled D3DLIGHTSTATETYPE %#x.\n", state);
2995 wined3d_mutex_unlock();
2996 return DDERR_INVALIDPARAMS;
2997 }
2998
2999 hr = IDirect3DDevice7_SetRenderState(&device->IDirect3DDevice7_iface, rs, value);
3000 wined3d_mutex_unlock();
3001 return hr;
3002 }
3003 wined3d_mutex_unlock();
3004
3005 return D3D_OK;
3006 }
3007
3008 static HRESULT WINAPI d3d_device2_SetLightState(IDirect3DDevice2 *iface,
3009 D3DLIGHTSTATETYPE state, DWORD value)
3010 {
3011 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
3012
3013 TRACE("iface %p, state %#x, value %#x.\n", iface, state, value);
3014
3015 return d3d_device3_SetLightState(&device->IDirect3DDevice3_iface, state, value);
3016 }
3017
3018 /*****************************************************************************
3019 * IDirect3DDevice3::GetLightState
3020 *
3021 * Returns the current setting of a light state. The state is read from
3022 * the Direct3DDevice7 render state.
3023 *
3024 * Version 2 and 3
3025 *
3026 * Params:
3027 * LightStateType: The light state to return
3028 * Value: The address to store the light state setting at
3029 *
3030 * Returns:
3031 * D3D_OK on success
3032 * DDDERR_INVALIDPARAMS if the parameters were incorrect
3033 * Also see IDirect3DDevice7::GetRenderState
3034 *
3035 *****************************************************************************/
3036 static HRESULT WINAPI d3d_device3_GetLightState(IDirect3DDevice3 *iface,
3037 D3DLIGHTSTATETYPE state, DWORD *value)
3038 {
3039 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
3040 HRESULT hr;
3041
3042 TRACE("iface %p, state %#x, value %p.\n", iface, state, value);
3043
3044 if (!state || (state > D3DLIGHTSTATE_COLORVERTEX))
3045 {
3046 TRACE("Unexpected Light State Type\n");
3047 return DDERR_INVALIDPARAMS;
3048 }
3049
3050 if (!value)
3051 return DDERR_INVALIDPARAMS;
3052
3053 wined3d_mutex_lock();
3054 if (state == D3DLIGHTSTATE_MATERIAL)
3055 {
3056 *value = device->material;
3057 }
3058 else if (state == D3DLIGHTSTATE_COLORMODEL)
3059 {
3060 *value = D3DCOLOR_RGB;
3061 }
3062 else
3063 {
3064 D3DRENDERSTATETYPE rs;
3065 switch (state)
3066 {
3067 case D3DLIGHTSTATE_AMBIENT: /* 2 */
3068 rs = D3DRENDERSTATE_AMBIENT;
3069 break;
3070 case D3DLIGHTSTATE_FOGMODE: /* 4 */
3071 rs = D3DRENDERSTATE_FOGVERTEXMODE;
3072 break;
3073 case D3DLIGHTSTATE_FOGSTART: /* 5 */
3074 rs = D3DRENDERSTATE_FOGSTART;
3075 break;
3076 case D3DLIGHTSTATE_FOGEND: /* 6 */
3077 rs = D3DRENDERSTATE_FOGEND;
3078 break;
3079 case D3DLIGHTSTATE_FOGDENSITY: /* 7 */
3080 rs = D3DRENDERSTATE_FOGDENSITY;
3081 break;
3082 case D3DLIGHTSTATE_COLORVERTEX: /* 8 */
3083 rs = D3DRENDERSTATE_COLORVERTEX;
3084 break;
3085 default:
3086 FIXME("Unhandled D3DLIGHTSTATETYPE %#x.\n", state);
3087 wined3d_mutex_unlock();
3088 return DDERR_INVALIDPARAMS;
3089 }
3090
3091 hr = IDirect3DDevice7_GetRenderState(&device->IDirect3DDevice7_iface, rs, value);
3092 wined3d_mutex_unlock();
3093 return hr;
3094 }
3095 wined3d_mutex_unlock();
3096
3097 return D3D_OK;
3098 }
3099
3100 static HRESULT WINAPI d3d_device2_GetLightState(IDirect3DDevice2 *iface,
3101 D3DLIGHTSTATETYPE state, DWORD *value)
3102 {
3103 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
3104
3105 TRACE("iface %p, state %#x, value %p.\n", iface, state, value);
3106
3107 return d3d_device3_GetLightState(&device->IDirect3DDevice3_iface, state, value);
3108 }
3109
3110 /*****************************************************************************
3111 * IDirect3DDevice7::SetTransform
3112 *
3113 * Assigns a D3DMATRIX to a transform type. The transform types are defined
3114 * in include/d3dtypes.h.
3115 * The D3DTRANSFORMSTATE_WORLD (=1) is translated to D3DTS_WORLDMATRIX(0)
3116 * (=255) for wined3d, because the 1 transform state was removed in d3d8
3117 * and WineD3D already understands the replacement D3DTS_WORLDMATRIX(0)
3118 *
3119 * Version 2, 3 and 7
3120 *
3121 * Params:
3122 * TransformStateType: transform state to set
3123 * Matrix: Matrix to assign to the state
3124 *
3125 * Returns:
3126 * D3D_OK on success
3127 * DDERR_INVALIDPARAMS if Matrix == NULL
3128 *
3129 *****************************************************************************/
3130 static HRESULT d3d_device7_SetTransform(IDirect3DDevice7 *iface,
3131 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3132 {
3133 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
3134
3135 TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
3136
3137 if (!matrix)
3138 return DDERR_INVALIDPARAMS;
3139
3140 /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
3141 wined3d_mutex_lock();
3142 wined3d_stateblock_set_transform(device->update_state,
3143 wined3d_transform_state_from_ddraw(state), (const struct wined3d_matrix *)matrix);
3144 wined3d_mutex_unlock();
3145
3146 return D3D_OK;
3147 }
3148
3149 static HRESULT WINAPI d3d_device7_SetTransform_FPUSetup(IDirect3DDevice7 *iface,
3150 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3151 {
3152 return d3d_device7_SetTransform(iface, state, matrix);
3153 }
3154
3155 static HRESULT WINAPI d3d_device7_SetTransform_FPUPreserve(IDirect3DDevice7 *iface,
3156 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3157 {
3158 HRESULT hr;
3159 WORD old_fpucw;
3160
3161 old_fpucw = d3d_fpu_setup();
3162 hr = d3d_device7_SetTransform(iface, state, matrix);
3163 set_fpu_control_word(old_fpucw);
3164
3165 return hr;
3166 }
3167
3168 static HRESULT WINAPI d3d_device3_SetTransform(IDirect3DDevice3 *iface,
3169 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3170 {
3171 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
3172
3173 TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
3174
3175 if (!matrix)
3176 return DDERR_INVALIDPARAMS;
3177
3178 if (state == D3DTRANSFORMSTATE_PROJECTION)
3179 {
3180 struct wined3d_matrix projection;
3181
3182 wined3d_mutex_lock();
3183 multiply_matrix(&projection, &device->legacy_clipspace, (struct wined3d_matrix *)matrix);
3184 wined3d_stateblock_set_transform(device->state, WINED3D_TS_PROJECTION, &projection);
3185 memcpy(&device->legacy_projection, matrix, sizeof(*matrix));
3186 wined3d_mutex_unlock();
3187
3188 return D3D_OK;
3189 }
3190
3191 return IDirect3DDevice7_SetTransform(&device->IDirect3DDevice7_iface, state, matrix);
3192 }
3193
3194 static HRESULT WINAPI d3d_device2_SetTransform(IDirect3DDevice2 *iface,
3195 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3196 {
3197 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
3198
3199 TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
3200
3201 return IDirect3DDevice3_SetTransform(&device->IDirect3DDevice3_iface, state, matrix);
3202 }
3203
3204 /*****************************************************************************
3205 * IDirect3DDevice7::GetTransform
3206 *
3207 * Returns the matrix assigned to a transform state
3208 * D3DTRANSFORMSTATE_WORLD is translated to D3DTS_WORLDMATRIX(0), see
3209 * SetTransform
3210 *
3211 * Params:
3212 * TransformStateType: State to read the matrix from
3213 * Matrix: Address to store the matrix at
3214 *
3215 * Returns:
3216 * D3D_OK on success
3217 * DDERR_INVALIDPARAMS if Matrix == NULL
3218 *
3219 *****************************************************************************/
3220 static HRESULT d3d_device7_GetTransform(IDirect3DDevice7 *iface,
3221 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3222 {
3223 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
3224
3225 TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
3226
3227 if (!matrix)
3228 return DDERR_INVALIDPARAMS;
3229
3230 /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
3231 wined3d_mutex_lock();
3232 memcpy(matrix, &device->stateblock_state->transforms[wined3d_transform_state_from_ddraw(state)], sizeof(*matrix));
3233 wined3d_mutex_unlock();
3234
3235 return D3D_OK;
3236 }
3237
3238 static HRESULT WINAPI d3d_device7_GetTransform_FPUSetup(IDirect3DDevice7 *iface,
3239 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3240 {
3241 return d3d_device7_GetTransform(iface, state, matrix);
3242 }
3243
3244 static HRESULT WINAPI d3d_device7_GetTransform_FPUPreserve(IDirect3DDevice7 *iface,
3245 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3246 {
3247 HRESULT hr;
3248 WORD old_fpucw;
3249
3250 old_fpucw = d3d_fpu_setup();
3251 hr = d3d_device7_GetTransform(iface, state, matrix);
3252 set_fpu_control_word(old_fpucw);
3253
3254 return hr;
3255 }
3256
3257 static HRESULT WINAPI d3d_device3_GetTransform(IDirect3DDevice3 *iface,
3258 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3259 {
3260 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
3261
3262 TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
3263
3264 if (!matrix)
3265 return DDERR_INVALIDPARAMS;
3266
3267 if (state == D3DTRANSFORMSTATE_PROJECTION)
3268 {
3269 wined3d_mutex_lock();
3270 memcpy(matrix, &device->legacy_projection, sizeof(*matrix));
3271 wined3d_mutex_unlock();
3272 return DD_OK;
3273 }
3274
3275 return IDirect3DDevice7_GetTransform(&device->IDirect3DDevice7_iface, state, matrix);
3276 }
3277
3278 static HRESULT WINAPI d3d_device2_GetTransform(IDirect3DDevice2 *iface,
3279 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3280 {
3281 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
3282
3283 TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
3284
3285 return IDirect3DDevice3_GetTransform(&device->IDirect3DDevice3_iface, state, matrix);
3286 }
3287
3288 /*****************************************************************************
3289 * IDirect3DDevice7::MultiplyTransform
3290 *
3291 * Multiplies the already-set transform matrix of a transform state
3292 * with another matrix. For the world matrix, see SetTransform
3293 *
3294 * Version 2, 3 and 7
3295 *
3296 * Params:
3297 * TransformStateType: Transform state to multiply
3298 * D3DMatrix Matrix to multiply with.
3299 *
3300 * Returns
3301 * D3D_OK on success
3302 * DDERR_INVALIDPARAMS if D3DMatrix is NULL
3303 *
3304 *****************************************************************************/
3305 static HRESULT d3d_device7_MultiplyTransform(IDirect3DDevice7 *iface,
3306 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3307 {
3308 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
3309
3310 TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
3311
3312 /* Note: D3DMATRIX is compatible with struct wined3d_matrix. */
3313 wined3d_mutex_lock();
3314 wined3d_stateblock_multiply_transform(device->state,
3315 wined3d_transform_state_from_ddraw(state), (struct wined3d_matrix *)matrix);
3316 wined3d_mutex_unlock();
3317
3318 return D3D_OK;
3319 }
3320
3321 static HRESULT WINAPI d3d_device7_MultiplyTransform_FPUSetup(IDirect3DDevice7 *iface,
3322 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3323 {
3324 return d3d_device7_MultiplyTransform(iface, state, matrix);
3325 }
3326
3327 static HRESULT WINAPI d3d_device7_MultiplyTransform_FPUPreserve(IDirect3DDevice7 *iface,
3328 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3329 {
3330 HRESULT hr;
3331 WORD old_fpucw;
3332
3333 old_fpucw = d3d_fpu_setup();
3334 hr = d3d_device7_MultiplyTransform(iface, state, matrix);
3335 set_fpu_control_word(old_fpucw);
3336
3337 return hr;
3338 }
3339
3340 static HRESULT WINAPI d3d_device3_MultiplyTransform(IDirect3DDevice3 *iface,
3341 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3342 {
3343 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
3344
3345 TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
3346
3347 if (state == D3DTRANSFORMSTATE_PROJECTION)
3348 {
3349 struct wined3d_matrix projection, tmp;
3350
3351 wined3d_mutex_lock();
3352 multiply_matrix(&tmp, &device->legacy_projection, (struct wined3d_matrix *)matrix);
3353 multiply_matrix(&projection, &device->legacy_clipspace, &tmp);
3354 wined3d_stateblock_set_transform(device->state, WINED3D_TS_PROJECTION, &projection);
3355 device->legacy_projection = tmp;
3356 wined3d_mutex_unlock();
3357
3358 return D3D_OK;
3359 }
3360
3361 return IDirect3DDevice7_MultiplyTransform(&device->IDirect3DDevice7_iface, state, matrix);
3362 }
3363
3364 static HRESULT WINAPI d3d_device2_MultiplyTransform(IDirect3DDevice2 *iface,
3365 D3DTRANSFORMSTATETYPE state, D3DMATRIX *matrix)
3366 {
3367 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
3368
3369 TRACE("iface %p, state %#x, matrix %p.\n", iface, state, matrix);
3370
3371 return IDirect3DDevice3_MultiplyTransform(&device->IDirect3DDevice3_iface, state, matrix);
3372 }
3373
3374 /*****************************************************************************
3375 * IDirect3DDevice7::DrawPrimitive
3376 *
3377 * Draws primitives based on vertices in an application-provided pointer
3378 *
3379 * Version 2, 3 and 7. The IDirect3DDevice2 thunk converts the fixed vertex type into
3380 * an FVF format for D3D7
3381 *
3382 * Params:
3383 * PrimitiveType: The type of the primitives to draw
3384 * Vertex type: Flexible vertex format vertex description
3385 * Vertices: Pointer to the vertex array
3386 * VertexCount: The number of vertices to draw
3387 * Flags: As usual a few flags
3388 *
3389 * Returns:
3390 * D3D_OK on success
3391 * DDERR_INVALIDPARAMS if Vertices is NULL
3392 *
3393 *****************************************************************************/
3394
3395 /* The caller is responsible for wined3d locking */
3396 static HRESULT d3d_device_prepare_vertex_buffer(struct d3d_device *device, UINT min_size)
3397 {
3398 HRESULT hr;
3399
3400 if (device->vertex_buffer_size < min_size || !device->vertex_buffer)
3401 {
3402 UINT size = max(device->vertex_buffer_size * 2, min_size);
3403 struct wined3d_buffer_desc desc;
3404 struct wined3d_buffer *buffer;
3405
3406 TRACE("Growing vertex buffer to %u bytes\n", size);
3407
3408 desc.byte_width = size;
3409 desc.usage = WINED3DUSAGE_DYNAMIC;
3410 desc.bind_flags = WINED3D_BIND_VERTEX_BUFFER;
3411 desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_W;
3412 desc.misc_flags = 0;
3413 desc.structure_byte_stride = 0;
3414
3415 if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc,
3416 NULL, NULL, &ddraw_null_wined3d_parent_ops, &buffer)))
3417 {
3418 ERR("Failed to create vertex buffer, hr %#x.\n", hr);
3419 return hr;
3420 }
3421
3422 if (device->vertex_buffer)
3423 wined3d_buffer_decref(device->vertex_buffer);
3424
3425 device->vertex_buffer = buffer;
3426 device->vertex_buffer_size = size;
3427 device->vertex_buffer_pos = 0;
3428 }
3429 return D3D_OK;
3430 }
3431
3432 static void d3d_device_sync_rendertarget(struct d3d_device *device)
3433 {
3434 struct wined3d_rendertarget_view *rtv;
3435
3436 if (device->hardware_device)
3437 return;
3438
3439 if ((rtv = wined3d_device_context_get_rendertarget_view(device->immediate_context, 0)))
3440 ddraw_surface_get_draw_texture(wined3d_rendertarget_view_get_parent(rtv), DDRAW_SURFACE_RW);
3441
3442 if ((rtv = wined3d_device_context_get_depth_stencil_view(device->immediate_context)))
3443 ddraw_surface_get_draw_texture(wined3d_rendertarget_view_get_parent(rtv), DDRAW_SURFACE_RW);
3444 }
3445
3446 void d3d_device_sync_surfaces(struct d3d_device *device)
3447 {
3448 const struct wined3d_stateblock_state *state = device->stateblock_state;
3449 struct ddraw_surface *surface;
3450 unsigned int i, j;
3451
3452 if (device->hardware_device)
3453 return;
3454
3455 d3d_device_sync_rendertarget(device);
3456
3457 for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
3458 {
3459 if (!state->textures[i])
3460 continue;
3461
3462 j = 0;
3463 while ((surface = wined3d_texture_get_sub_resource_parent(state->textures[i], j)))
3464 {
3465 if (!surface->draw_texture)
3466 break;
3467 ddraw_surface_get_draw_texture(surface, DDRAW_SURFACE_READ);
3468 ++j;
3469 }
3470 }
3471 }
3472
3473 static HRESULT d3d_device7_DrawPrimitive(IDirect3DDevice7 *iface,
3474 D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices,
3475 DWORD vertex_count, DWORD flags)
3476 {
3477 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
3478 struct wined3d_map_desc wined3d_map_desc;
3479 struct wined3d_box wined3d_box = {0};
3480 UINT stride, vb_pos, size, align;
3481 struct wined3d_resource *vb;
3482 HRESULT hr;
3483
3484 TRACE("iface %p, primitive_type %#x, fvf %#x, vertices %p, vertex_count %u, flags %#x.\n",
3485 iface, primitive_type, fvf, vertices, vertex_count, flags);
3486
3487 if (!vertex_count)
3488 {
3489 WARN("0 vertex count.\n");
3490 return D3D_OK;
3491 }
3492
3493 /* Get the stride */
3494 stride = get_flexible_vertex_size(fvf);
3495 size = vertex_count * stride;
3496
3497 wined3d_mutex_lock();
3498 hr = d3d_device_prepare_vertex_buffer(device, size);
3499 if (FAILED(hr))
3500 goto done;
3501
3502 vb_pos = device->vertex_buffer_pos;
3503 align = vb_pos % stride;
3504 if (align) align = stride - align;
3505 if (vb_pos + size + align > device->vertex_buffer_size)
3506 vb_pos = 0;
3507 else
3508 vb_pos += align;
3509
3510 wined3d_box.left = vb_pos;
3511 wined3d_box.right = vb_pos + size;
3512 vb = wined3d_buffer_get_resource(device->vertex_buffer);
3513 if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box,
3514 WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
3515 goto done;
3516 memcpy(wined3d_map_desc.data, vertices, size);
3517 wined3d_resource_unmap(vb, 0);
3518 device->vertex_buffer_pos = vb_pos + size;
3519
3520 hr = wined3d_stateblock_set_stream_source(device->state, 0, device->vertex_buffer, 0, stride);
3521 if (FAILED(hr))
3522 goto done;
3523
3524 wined3d_stateblock_set_vertex_declaration(device->state, ddraw_find_decl(device->ddraw, fvf));
3525 wined3d_device_context_set_primitive_type(device->immediate_context,
3526 wined3d_primitive_type_from_ddraw(primitive_type), 0);
3527 wined3d_device_apply_stateblock(device->wined3d_device, device->state);
3528 d3d_device_sync_surfaces(device);
3529 wined3d_device_context_draw(device->immediate_context, vb_pos / stride, vertex_count, 0, 0);
3530
3531 done:
3532 wined3d_mutex_unlock();
3533 return hr;
3534 }
3535
3536 static HRESULT WINAPI d3d_device7_DrawPrimitive_FPUSetup(IDirect3DDevice7 *iface,
3537 D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices,
3538 DWORD vertex_count, DWORD flags)
3539 {
3540 return d3d_device7_DrawPrimitive(iface, primitive_type, fvf, vertices, vertex_count, flags);
3541 }
3542
3543 static HRESULT WINAPI d3d_device7_DrawPrimitive_FPUPreserve(IDirect3DDevice7 *iface,
3544 D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices,
3545 DWORD vertex_count, DWORD flags)
3546 {
3547 HRESULT hr;
3548 WORD old_fpucw;
3549
3550 old_fpucw = d3d_fpu_setup();
3551 hr = d3d_device7_DrawPrimitive(iface, primitive_type, fvf, vertices, vertex_count, flags);
3552 set_fpu_control_word(old_fpucw);
3553
3554 return hr;
3555 }
3556
3557 static void setup_lighting(const struct d3d_device *device, DWORD fvf, DWORD flags)
3558 {
3559 BOOL enable = TRUE;
3560
3561 /* Ignore the D3DFVF_XYZRHW case here, wined3d takes care of that */
3562 if (!device->material || !(fvf & D3DFVF_NORMAL) || (flags & D3DDP_DONOTLIGHT))
3563 enable = FALSE;
3564
3565 wined3d_stateblock_set_render_state(device->state, WINED3D_RS_LIGHTING, enable);
3566 }
3567
3568
3569 static HRESULT WINAPI d3d_device3_DrawPrimitive(IDirect3DDevice3 *iface,
3570 D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count,
3571 DWORD flags)
3572 {
3573 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
3574
3575 TRACE("iface %p, primitive_type %#x, fvf %#x, vertices %p, vertex_count %u, flags %#x.\n",
3576 iface, primitive_type, fvf, vertices, vertex_count, flags);
3577
3578 setup_lighting(device, fvf, flags);
3579
3580 return IDirect3DDevice7_DrawPrimitive(&device->IDirect3DDevice7_iface,
3581 primitive_type, fvf, vertices, vertex_count, flags);
3582 }
3583
3584 static HRESULT WINAPI d3d_device2_DrawPrimitive(IDirect3DDevice2 *iface,
3585 D3DPRIMITIVETYPE primitive_type, D3DVERTEXTYPE vertex_type, void *vertices,
3586 DWORD vertex_count, DWORD flags)
3587 {
3588 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
3589 DWORD fvf;
3590
3591 TRACE("iface %p, primitive_type %#x, vertex_type %#x, vertices %p, vertex_count %u, flags %#x.\n",
3592 iface, primitive_type, vertex_type, vertices, vertex_count, flags);
3593
3594 switch (vertex_type)
3595 {
3596 case D3DVT_VERTEX: fvf = D3DFVF_VERTEX; break;
3597 case D3DVT_LVERTEX: fvf = D3DFVF_LVERTEX; break;
3598 case D3DVT_TLVERTEX: fvf = D3DFVF_TLVERTEX; break;
3599 default:
3600 FIXME("Unhandled vertex type %#x.\n", vertex_type);
3601 return DDERR_INVALIDPARAMS; /* Should never happen */
3602 }
3603
3604 return d3d_device3_DrawPrimitive(&device->IDirect3DDevice3_iface,
3605 primitive_type, fvf, vertices, vertex_count, flags);
3606 }
3607
3608 /*****************************************************************************
3609 * IDirect3DDevice7::DrawIndexedPrimitive
3610 *
3611 * Draws vertices from an application-provided pointer, based on the index
3612 * numbers in a WORD array.
3613 *
3614 * Version 2, 3 and 7. The version 7 thunk translates the vertex type into
3615 * an FVF format for D3D7
3616 *
3617 * Params:
3618 * PrimitiveType: The primitive type to draw
3619 * VertexType: The FVF vertex description
3620 * Vertices: Pointer to the vertex array
3621 * VertexCount: ?
3622 * Indices: Pointer to the index array
3623 * IndexCount: Number of indices = Number of vertices to draw
3624 * Flags: As usual, some flags
3625 *
3626 * Returns:
3627 * D3D_OK on success
3628 * DDERR_INVALIDPARAMS if Vertices or Indices is NULL
3629 *
3630 *****************************************************************************/
3631 /* The caller is responsible for wined3d locking */
3632 static HRESULT d3d_device_prepare_index_buffer(struct d3d_device *device, UINT min_size)
3633 {
3634 HRESULT hr;
3635
3636 if (device->index_buffer_size < min_size || !device->index_buffer)
3637 {
3638 UINT size = max(device->index_buffer_size * 2, min_size);
3639 struct wined3d_buffer_desc desc;
3640 struct wined3d_buffer *buffer;
3641
3642 TRACE("Growing index buffer to %u bytes\n", size);
3643
3644 desc.byte_width = size;
3645 desc.usage = WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_STATICDECL;
3646 desc.bind_flags = WINED3D_BIND_INDEX_BUFFER;
3647 desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_W;
3648 desc.misc_flags = 0;
3649 desc.structure_byte_stride = 0;
3650
3651 if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc,
3652 NULL, NULL, &ddraw_null_wined3d_parent_ops, &buffer)))
3653 {
3654 ERR("Failed to create index buffer, hr %#x.\n", hr);
3655 return hr;
3656 }
3657
3658 if (device->index_buffer)
3659 wined3d_buffer_decref(device->index_buffer);
3660 device->index_buffer = buffer;
3661 device->index_buffer_size = size;
3662 device->index_buffer_pos = 0;
3663 }
3664 return D3D_OK;
3665 }
3666
3667 static HRESULT d3d_device7_DrawIndexedPrimitive(IDirect3DDevice7 *iface,
3668 D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count,
3669 WORD *indices, DWORD index_count, DWORD flags)
3670 {
3671 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
3672 HRESULT hr;
3673 UINT stride = get_flexible_vertex_size(fvf);
3674 UINT vtx_size = stride * vertex_count, idx_size = index_count * sizeof(*indices);
3675 struct wined3d_map_desc wined3d_map_desc;
3676 struct wined3d_box wined3d_box = {0};
3677 struct wined3d_resource *ib, *vb;
3678 UINT vb_pos, ib_pos, align;
3679
3680 TRACE("iface %p, primitive_type %#x, fvf %#x, vertices %p, vertex_count %u, "
3681 "indices %p, index_count %u, flags %#x.\n",
3682 iface, primitive_type, fvf, vertices, vertex_count, indices, index_count, flags);
3683
3684 if (!vertex_count || !index_count)
3685 {
3686 WARN("0 vertex or index count.\n");
3687 return D3D_OK;
3688 }
3689
3690 /* Set the D3DDevice's FVF */
3691 wined3d_mutex_lock();
3692
3693 hr = d3d_device_prepare_vertex_buffer(device, vtx_size);
3694 if (FAILED(hr))
3695 goto done;
3696
3697 vb_pos = device->vertex_buffer_pos;
3698 align = vb_pos % stride;
3699 if (align) align = stride - align;
3700 if (vb_pos + vtx_size + align > device->vertex_buffer_size)
3701 vb_pos = 0;
3702 else
3703 vb_pos += align;
3704
3705 wined3d_box.left = vb_pos;
3706 wined3d_box.right = vb_pos + vtx_size;
3707 vb = wined3d_buffer_get_resource(device->vertex_buffer);
3708 if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box,
3709 WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
3710 goto done;
3711 memcpy(wined3d_map_desc.data, vertices, vtx_size);
3712 wined3d_resource_unmap(vb, 0);
3713 device->vertex_buffer_pos = vb_pos + vtx_size;
3714
3715 hr = d3d_device_prepare_index_buffer(device, idx_size);
3716 if (FAILED(hr))
3717 goto done;
3718 ib_pos = device->index_buffer_pos;
3719 if (device->index_buffer_size - idx_size < ib_pos)
3720 ib_pos = 0;
3721
3722 wined3d_box.left = ib_pos;
3723 wined3d_box.right = ib_pos + idx_size;
3724 ib = wined3d_buffer_get_resource(device->index_buffer);
3725 if (FAILED(hr = wined3d_resource_map(ib, 0, &wined3d_map_desc, &wined3d_box,
3726 WINED3D_MAP_WRITE | (ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
3727 goto done;
3728 memcpy(wined3d_map_desc.data, indices, idx_size);
3729 wined3d_resource_unmap(ib, 0);
3730 device->index_buffer_pos = ib_pos + idx_size;
3731
3732 hr = wined3d_stateblock_set_stream_source(device->state, 0, device->vertex_buffer, 0, stride);
3733 if (FAILED(hr))
3734 goto done;
3735 wined3d_stateblock_set_index_buffer(device->state, device->index_buffer, WINED3DFMT_R16_UINT);
3736
3737 wined3d_stateblock_set_vertex_declaration(device->state, ddraw_find_decl(device->ddraw, fvf));
3738 wined3d_device_context_set_primitive_type(device->immediate_context,
3739 wined3d_primitive_type_from_ddraw(primitive_type), 0);
3740 wined3d_device_apply_stateblock(device->wined3d_device, device->state);
3741 d3d_device_sync_surfaces(device);
3742 wined3d_device_context_draw_indexed(device->immediate_context, vb_pos / stride,
3743 ib_pos / sizeof(*indices), index_count, 0, 0);
3744
3745 done:
3746 wined3d_mutex_unlock();
3747 return hr;
3748 }
3749
3750 static HRESULT WINAPI d3d_device7_DrawIndexedPrimitive_FPUSetup(IDirect3DDevice7 *iface,
3751 D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count,
3752 WORD *indices, DWORD index_count, DWORD flags)
3753 {
3754 return d3d_device7_DrawIndexedPrimitive(iface, primitive_type, fvf,
3755 vertices, vertex_count, indices, index_count, flags);
3756 }
3757
3758 static HRESULT WINAPI d3d_device7_DrawIndexedPrimitive_FPUPreserve(IDirect3DDevice7 *iface,
3759 D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count,
3760 WORD *indices, DWORD index_count, DWORD flags)
3761 {
3762 HRESULT hr;
3763 WORD old_fpucw;
3764
3765 old_fpucw = d3d_fpu_setup();
3766 hr = d3d_device7_DrawIndexedPrimitive(iface, primitive_type, fvf,
3767 vertices, vertex_count, indices, index_count, flags);
3768 set_fpu_control_word(old_fpucw);
3769
3770 return hr;
3771 }
3772
3773 static HRESULT WINAPI d3d_device3_DrawIndexedPrimitive(IDirect3DDevice3 *iface,
3774 D3DPRIMITIVETYPE primitive_type, DWORD fvf, void *vertices, DWORD vertex_count,
3775 WORD *indices, DWORD index_count, DWORD flags)
3776 {
3777 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
3778
3779 TRACE("iface %p, primitive_type %#x, fvf %#x, vertices %p, vertex_count %u, "
3780 "indices %p, index_count %u, flags %#x.\n",
3781 iface, primitive_type, fvf, vertices, vertex_count, indices, index_count, flags);
3782
3783 setup_lighting(device, fvf, flags);
3784
3785 return IDirect3DDevice7_DrawIndexedPrimitive(&device->IDirect3DDevice7_iface,
3786 primitive_type, fvf, vertices, vertex_count, indices, index_count, flags);
3787 }
3788
3789 static HRESULT WINAPI d3d_device2_DrawIndexedPrimitive(IDirect3DDevice2 *iface,
3790 D3DPRIMITIVETYPE primitive_type, D3DVERTEXTYPE vertex_type, void *vertices,
3791 DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags)
3792 {
3793 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
3794 DWORD fvf;
3795
3796 TRACE("iface %p, primitive_type %#x, vertex_type %#x, vertices %p, vertex_count %u, "
3797 "indices %p, index_count %u, flags %#x.\n",
3798 iface, primitive_type, vertex_type, vertices, vertex_count, indices, index_count, flags);
3799
3800 switch (vertex_type)
3801 {
3802 case D3DVT_VERTEX: fvf = D3DFVF_VERTEX; break;
3803 case D3DVT_LVERTEX: fvf = D3DFVF_LVERTEX; break;
3804 case D3DVT_TLVERTEX: fvf = D3DFVF_TLVERTEX; break;
3805 default:
3806 ERR("Unhandled vertex type %#x.\n", vertex_type);
3807 return DDERR_INVALIDPARAMS; /* Should never happen */
3808 }
3809
3810 return d3d_device3_DrawIndexedPrimitive(&device->IDirect3DDevice3_iface,
3811 primitive_type, fvf, vertices, vertex_count, indices, index_count, flags);
3812 }
3813
3814 /*****************************************************************************
3815 * IDirect3DDevice3::End
3816 *
3817 * Ends a draw begun with IDirect3DDevice3::Begin or
3818 * IDirect3DDevice::BeginIndexed. The vertices specified with
3819 * IDirect3DDevice::Vertex or IDirect3DDevice::Index are drawn using
3820 * the IDirect3DDevice3::DrawPrimitive method. So far only
3821 * non-indexed mode is supported
3822 *
3823 * Version 2 and 3
3824 *
3825 * Params:
3826 * Flags: Some flags, as usual. Don't know which are defined
3827 *
3828 * Returns:
3829 * The return value of IDirect3DDevice3::DrawPrimitive
3830 *
3831 *****************************************************************************/
3832 static HRESULT WINAPI d3d_device3_End(IDirect3DDevice3 *iface, DWORD flags)
3833 {
3834 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
3835
3836 TRACE("iface %p, flags %#x.\n", iface, flags);
3837
3838 return d3d_device3_DrawPrimitive(&device->IDirect3DDevice3_iface, device->primitive_type,
3839 device->vertex_type, device->sysmem_vertex_buffer, device->nb_vertices, device->render_flags);
3840 }
3841
3842 static HRESULT WINAPI d3d_device2_End(IDirect3DDevice2 *iface, DWORD flags)
3843 {
3844 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
3845
3846 TRACE("iface %p, flags %#x.\n", iface, flags);
3847
3848 return d3d_device3_End(&device->IDirect3DDevice3_iface, flags);
3849 }
3850
3851 /*****************************************************************************
3852 * IDirect3DDevice7::SetClipStatus
3853 *
3854 * Sets the clip status. This defines things as clipping conditions and
3855 * the extents of the clipping region.
3856 *
3857 * Version 2, 3 and 7
3858 *
3859 * Params:
3860 * ClipStatus:
3861 *
3862 * Returns:
3863 * D3D_OK because it's a stub
3864 * (DDERR_INVALIDPARAMS if ClipStatus == NULL)
3865 *
3866 *****************************************************************************/
3867 static HRESULT WINAPI d3d_device7_SetClipStatus(IDirect3DDevice7 *iface, D3DCLIPSTATUS *clip_status)
3868 {
3869 FIXME("iface %p, clip_status %p stub!\n", iface, clip_status);
3870
3871 return D3D_OK;
3872 }
3873
3874 static HRESULT WINAPI d3d_device3_SetClipStatus(IDirect3DDevice3 *iface, D3DCLIPSTATUS *clip_status)
3875 {
3876 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
3877
3878 TRACE("iface %p, clip_status %p.\n", iface, clip_status);
3879
3880 return IDirect3DDevice7_SetClipStatus(&device->IDirect3DDevice7_iface, clip_status);
3881 }
3882
3883 static HRESULT WINAPI d3d_device2_SetClipStatus(IDirect3DDevice2 *iface, D3DCLIPSTATUS *clip_status)
3884 {
3885 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
3886
3887 TRACE("iface %p, clip_status %p.\n", iface, clip_status);
3888
3889 return IDirect3DDevice7_SetClipStatus(&device->IDirect3DDevice7_iface, clip_status);
3890 }
3891
3892 /*****************************************************************************
3893 * IDirect3DDevice7::GetClipStatus
3894 *
3895 * Returns the clip status
3896 *
3897 * Params:
3898 * ClipStatus: Address to write the clip status to
3899 *
3900 * Returns:
3901 * D3D_OK because it's a stub
3902 *
3903 *****************************************************************************/
3904 static HRESULT WINAPI d3d_device7_GetClipStatus(IDirect3DDevice7 *iface, D3DCLIPSTATUS *clip_status)
3905 {
3906 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
3907 struct wined3d_viewport vp;
3908
3909 FIXME("iface %p, clip_status %p stub.\n", iface, clip_status);
3910
3911 vp = device->stateblock_state->viewport;
3912 clip_status->minx = vp.x;
3913 clip_status->maxx = vp.x + vp.width;
3914 clip_status->miny = vp.y;
3915 clip_status->maxy = vp.y + vp.height;
3916 clip_status->minz = 0.0f;
3917 clip_status->maxz = 0.0f;
3918 clip_status->dwFlags = D3DCLIPSTATUS_EXTENTS2;
3919 clip_status->dwStatus = 0;
3920
3921 return D3D_OK;
3922 }
3923
3924 static HRESULT WINAPI d3d_device3_GetClipStatus(IDirect3DDevice3 *iface, D3DCLIPSTATUS *clip_status)
3925 {
3926 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
3927
3928 TRACE("iface %p, clip_status %p.\n", iface, clip_status);
3929
3930 return IDirect3DDevice7_GetClipStatus(&device->IDirect3DDevice7_iface, clip_status);
3931 }
3932
3933 static HRESULT WINAPI d3d_device2_GetClipStatus(IDirect3DDevice2 *iface, D3DCLIPSTATUS *clip_status)
3934 {
3935 struct d3d_device *device = impl_from_IDirect3DDevice2(iface);
3936
3937 TRACE("iface %p, clip_status %p.\n", iface, clip_status);
3938
3939 return IDirect3DDevice7_GetClipStatus(&device->IDirect3DDevice7_iface, clip_status);
3940 }
3941
3942 /*****************************************************************************
3943 * IDirect3DDevice::DrawPrimitiveStrided
3944 *
3945 * Draws vertices described by a D3DDRAWPRIMITIVESTRIDEDDATA structure.
3946 *
3947 * Version 3 and 7
3948 *
3949 * Params:
3950 * PrimitiveType: The primitive type to draw
3951 * VertexType: The FVF description of the vertices to draw (for the stride??)
3952 * D3DDrawPrimStrideData: A D3DDRAWPRIMITIVESTRIDEDDATA structure describing
3953 * the vertex data locations
3954 * VertexCount: The number of vertices to draw
3955 * Flags: Some flags
3956 *
3957 * Returns:
3958 * D3D_OK, because it's a stub
3959 * (DDERR_INVALIDPARAMS if D3DDrawPrimStrideData is NULL)
3960 *
3961 *****************************************************************************/
3962 static void pack_strided_data(BYTE *dst, DWORD count, const D3DDRAWPRIMITIVESTRIDEDDATA *src, DWORD fvf)
3963 {
3964 DWORD i, tex, offset;
3965
3966 for (i = 0; i < count; i++)
3967 {
3968 /* The contents of the strided data are determined by the fvf,
3969 * not by the members set in src. So it's valid
3970 * to have diffuse.lpvData set to 0xdeadbeef if the diffuse flag is
3971 * not set in the fvf. */
3972 if (fvf & D3DFVF_POSITION_MASK)
3973 {
3974 offset = i * src->position.dwStride;
3975 if (fvf & D3DFVF_XYZRHW)
3976 {
3977 memcpy(dst, ((BYTE *)src->position.lpvData) + offset, 4 * sizeof(float));
3978 dst += 4 * sizeof(float);
3979 }
3980 else
3981 {
3982 memcpy(dst, ((BYTE *)src->position.lpvData) + offset, 3 * sizeof(float));
3983 dst += 3 * sizeof(float);
3984 }
3985 }
3986
3987 if (fvf & D3DFVF_NORMAL)
3988 {
3989 offset = i * src->normal.dwStride;
3990 memcpy(dst, ((BYTE *)src->normal.lpvData) + offset, 3 * sizeof(float));
3991 dst += 3 * sizeof(float);
3992 }
3993
3994 if (fvf & D3DFVF_DIFFUSE)
3995 {
3996 offset = i * src->diffuse.dwStride;
3997 memcpy(dst, ((BYTE *)src->diffuse.lpvData) + offset, sizeof(DWORD));
3998 dst += sizeof(DWORD);
3999 }
4000
4001 if (fvf & D3DFVF_SPECULAR)
4002 {
4003 offset = i * src->specular.dwStride;
4004 memcpy(dst, ((BYTE *)src->specular.lpvData) + offset, sizeof(DWORD));
4005 dst += sizeof(DWORD);
4006 }
4007
4008 for (tex = 0; tex < GET_TEXCOUNT_FROM_FVF(fvf); ++tex)
4009 {
4010 DWORD attrib_count = GET_TEXCOORD_SIZE_FROM_FVF(fvf, tex);
4011 offset = i * src->textureCoords[tex].dwStride;
4012 memcpy(dst, ((BYTE *)src->textureCoords[tex].lpvData) + offset, attrib_count * sizeof(float));
4013 dst += attrib_count * sizeof(float);
4014 }
4015 }
4016 }
4017
4018 static HRESULT d3d_device7_DrawPrimitiveStrided(IDirect3DDevice7 *iface, D3DPRIMITIVETYPE primitive_type,
4019 DWORD fvf, D3DDRAWPRIMITIVESTRIDEDDATA *strided_data, DWORD vertex_count, DWORD flags)
4020 {
4021 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
4022 HRESULT hr;
4023 UINT dst_stride = get_flexible_vertex_size(fvf);
4024 UINT dst_size = dst_stride * vertex_count;
4025 struct wined3d_map_desc wined3d_map_desc;
4026 struct wined3d_box wined3d_box = {0};
4027 struct wined3d_resource *vb;
4028 UINT vb_pos, align;
4029
4030 TRACE("iface %p, primitive_type %#x, fvf %#x, strided_data %p, vertex_count %u, flags %#x.\n",
4031 iface, primitive_type, fvf, strided_data, vertex_count, flags);
4032
4033 if (!vertex_count)
4034 {
4035 WARN("0 vertex count.\n");
4036 return D3D_OK;
4037 }
4038
4039 wined3d_mutex_lock();
4040 hr = d3d_device_prepare_vertex_buffer(device, dst_size);
4041 if (FAILED(hr))
4042 goto done;
4043
4044 vb_pos = device->vertex_buffer_pos;
4045 align = vb_pos % dst_stride;
4046 if (align) align = dst_stride - align;
4047 if (vb_pos + dst_size + align > device->vertex_buffer_size)
4048 vb_pos = 0;
4049 else
4050 vb_pos += align;
4051
4052 wined3d_box.left = vb_pos;
4053 wined3d_box.right = vb_pos + dst_size;
4054 vb = wined3d_buffer_get_resource(device->vertex_buffer);
4055 if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box,
4056 WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
4057 goto done;
4058 pack_strided_data(wined3d_map_desc.data, vertex_count, strided_data, fvf);
4059 wined3d_resource_unmap(vb, 0);
4060 device->vertex_buffer_pos = vb_pos + dst_size;
4061
4062 hr = wined3d_stateblock_set_stream_source(device->state, 0, device->vertex_buffer, 0, dst_stride);
4063 if (FAILED(hr))
4064 goto done;
4065 wined3d_stateblock_set_vertex_declaration(device->state, ddraw_find_decl(device->ddraw, fvf));
4066
4067 wined3d_device_context_set_primitive_type(device->immediate_context,
4068 wined3d_primitive_type_from_ddraw(primitive_type), 0);
4069 wined3d_device_apply_stateblock(device->wined3d_device, device->state);
4070 d3d_device_sync_surfaces(device);
4071 wined3d_device_context_draw(device->immediate_context, vb_pos / dst_stride, vertex_count, 0, 0);
4072
4073 done:
4074 wined3d_mutex_unlock();
4075 return hr;
4076 }
4077
4078 static HRESULT WINAPI d3d_device7_DrawPrimitiveStrided_FPUSetup(IDirect3DDevice7 *iface,
4079 D3DPRIMITIVETYPE PrimitiveType, DWORD VertexType,
4080 D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData, DWORD VertexCount, DWORD Flags)
4081 {
4082 return d3d_device7_DrawPrimitiveStrided(iface, PrimitiveType,
4083 VertexType, D3DDrawPrimStrideData, VertexCount, Flags);
4084 }
4085
4086 static HRESULT WINAPI d3d_device7_DrawPrimitiveStrided_FPUPreserve(IDirect3DDevice7 *iface,
4087 D3DPRIMITIVETYPE PrimitiveType, DWORD VertexType,
4088 D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData, DWORD VertexCount, DWORD Flags)
4089 {
4090 HRESULT hr;
4091 WORD old_fpucw;
4092
4093 old_fpucw = d3d_fpu_setup();
4094 hr = d3d_device7_DrawPrimitiveStrided(iface, PrimitiveType,
4095 VertexType, D3DDrawPrimStrideData, VertexCount, Flags);
4096 set_fpu_control_word(old_fpucw);
4097
4098 return hr;
4099 }
4100
4101 static HRESULT WINAPI d3d_device3_DrawPrimitiveStrided(IDirect3DDevice3 *iface,
4102 D3DPRIMITIVETYPE PrimitiveType, DWORD VertexType,
4103 D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData, DWORD VertexCount, DWORD Flags)
4104 {
4105 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
4106
4107 TRACE("iface %p, primitive_type %#x, FVF %#x, strided_data %p, vertex_count %u, flags %#x.\n",
4108 iface, PrimitiveType, VertexType, D3DDrawPrimStrideData, VertexCount, Flags);
4109
4110 setup_lighting(device, VertexType, Flags);
4111
4112 return IDirect3DDevice7_DrawPrimitiveStrided(&device->IDirect3DDevice7_iface,
4113 PrimitiveType, VertexType, D3DDrawPrimStrideData, VertexCount, Flags);
4114 }
4115
4116 /*****************************************************************************
4117 * IDirect3DDevice7::DrawIndexedPrimitiveStrided
4118 *
4119 * Draws primitives specified by strided data locations based on indices
4120 *
4121 * Version 3 and 7
4122 *
4123 * Params:
4124 * PrimitiveType:
4125 *
4126 * Returns:
4127 * D3D_OK, because it's a stub
4128 * (DDERR_INVALIDPARAMS if D3DDrawPrimStrideData is NULL)
4129 * (DDERR_INVALIDPARAMS if Indices is NULL)
4130 *
4131 *****************************************************************************/
4132 static HRESULT d3d_device7_DrawIndexedPrimitiveStrided(IDirect3DDevice7 *iface,
4133 D3DPRIMITIVETYPE primitive_type, DWORD fvf, D3DDRAWPRIMITIVESTRIDEDDATA *strided_data,
4134 DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags)
4135 {
4136 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
4137 UINT vtx_dst_stride = get_flexible_vertex_size(fvf);
4138 UINT vtx_dst_size = vertex_count * vtx_dst_stride;
4139 UINT idx_size = index_count * sizeof(WORD);
4140 struct wined3d_map_desc wined3d_map_desc;
4141 struct wined3d_box wined3d_box = {0};
4142 struct wined3d_resource *ib, *vb;
4143 UINT vb_pos, align;
4144 UINT ib_pos;
4145 HRESULT hr;
4146
4147 TRACE("iface %p, primitive_type %#x, fvf %#x, strided_data %p, "
4148 "vertex_count %u, indices %p, index_count %u, flags %#x.\n",
4149 iface, primitive_type, fvf, strided_data, vertex_count, indices, index_count, flags);
4150
4151 if (!vertex_count || !index_count)
4152 {
4153 WARN("0 vertex or index count.\n");
4154 return D3D_OK;
4155 }
4156
4157 wined3d_mutex_lock();
4158
4159 hr = d3d_device_prepare_vertex_buffer(device, vtx_dst_size);
4160 if (FAILED(hr))
4161 goto done;
4162
4163 vb_pos = device->vertex_buffer_pos;
4164 align = vb_pos % vtx_dst_stride;
4165 if (align) align = vtx_dst_stride - align;
4166 if (vb_pos + vtx_dst_size + align > device->vertex_buffer_size)
4167 vb_pos = 0;
4168 else
4169 vb_pos += align;
4170
4171 wined3d_box.left = vb_pos;
4172 wined3d_box.right = vb_pos + vtx_dst_size;
4173 vb = wined3d_buffer_get_resource(device->vertex_buffer);
4174 if (FAILED(hr = wined3d_resource_map(vb, 0, &wined3d_map_desc, &wined3d_box,
4175 WINED3D_MAP_WRITE | (vb_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
4176 goto done;
4177 pack_strided_data(wined3d_map_desc.data, vertex_count, strided_data, fvf);
4178 wined3d_resource_unmap(vb, 0);
4179 device->vertex_buffer_pos = vb_pos + vtx_dst_size;
4180
4181 hr = d3d_device_prepare_index_buffer(device, idx_size);
4182 if (FAILED(hr))
4183 goto done;
4184 ib_pos = device->index_buffer_pos;
4185 if (device->index_buffer_size - idx_size < ib_pos)
4186 ib_pos = 0;
4187
4188 wined3d_box.left = ib_pos;
4189 wined3d_box.right = ib_pos + idx_size;
4190 ib = wined3d_buffer_get_resource(device->index_buffer);
4191 if (FAILED(hr = wined3d_resource_map(ib, 0, &wined3d_map_desc, &wined3d_box,
4192 WINED3D_MAP_WRITE | (ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
4193 goto done;
4194 memcpy(wined3d_map_desc.data, indices, idx_size);
4195 wined3d_resource_unmap(ib, 0);
4196 device->index_buffer_pos = ib_pos + idx_size;
4197
4198 hr = wined3d_stateblock_set_stream_source(device->state, 0, device->vertex_buffer, 0, vtx_dst_stride);
4199 if (FAILED(hr))
4200 goto done;
4201 wined3d_stateblock_set_index_buffer(device->state, device->index_buffer, WINED3DFMT_R16_UINT);
4202
4203 wined3d_stateblock_set_vertex_declaration(device->state, ddraw_find_decl(device->ddraw, fvf));
4204 wined3d_device_context_set_primitive_type(device->immediate_context,
4205 wined3d_primitive_type_from_ddraw(primitive_type), 0);
4206 wined3d_device_apply_stateblock(device->wined3d_device, device->state);
4207 d3d_device_sync_surfaces(device);
4208 wined3d_device_context_draw_indexed(device->immediate_context,
4209 vb_pos / vtx_dst_stride, ib_pos / sizeof(WORD), index_count, 0, 0);
4210
4211 done:
4212 wined3d_mutex_unlock();
4213 return hr;
4214 }
4215
4216 static HRESULT WINAPI d3d_device7_DrawIndexedPrimitiveStrided_FPUSetup(IDirect3DDevice7 *iface,
4217 D3DPRIMITIVETYPE PrimitiveType, DWORD VertexType,
4218 D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData, DWORD VertexCount,
4219 WORD *Indices, DWORD IndexCount, DWORD Flags)
4220 {
4221 return d3d_device7_DrawIndexedPrimitiveStrided(iface, PrimitiveType, VertexType,
4222 D3DDrawPrimStrideData, VertexCount, Indices, IndexCount, Flags);
4223 }
4224
4225 static HRESULT WINAPI d3d_device7_DrawIndexedPrimitiveStrided_FPUPreserve(IDirect3DDevice7 *iface,
4226 D3DPRIMITIVETYPE PrimitiveType, DWORD VertexType,
4227 D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData, DWORD VertexCount,
4228 WORD *Indices, DWORD IndexCount, DWORD Flags)
4229 {
4230 HRESULT hr;
4231 WORD old_fpucw;
4232
4233 old_fpucw = d3d_fpu_setup();
4234 hr = d3d_device7_DrawIndexedPrimitiveStrided(iface, PrimitiveType, VertexType,
4235 D3DDrawPrimStrideData, VertexCount, Indices, IndexCount, Flags);
4236 set_fpu_control_word(old_fpucw);
4237
4238 return hr;
4239 }
4240
4241 static HRESULT WINAPI d3d_device3_DrawIndexedPrimitiveStrided(IDirect3DDevice3 *iface,
4242 D3DPRIMITIVETYPE PrimitiveType, DWORD VertexType,
4243 D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData, DWORD VertexCount, WORD *Indices,
4244 DWORD IndexCount, DWORD Flags)
4245 {
4246 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
4247
4248 TRACE("iface %p, primitive_type %#x, FVF %#x, strided_data %p, vertex_count %u, indices %p, index_count %u, flags %#x.\n",
4249 iface, PrimitiveType, VertexType, D3DDrawPrimStrideData, VertexCount, Indices, IndexCount, Flags);
4250
4251 setup_lighting(device, VertexType, Flags);
4252
4253 return IDirect3DDevice7_DrawIndexedPrimitiveStrided(&device->IDirect3DDevice7_iface,
4254 PrimitiveType, VertexType, D3DDrawPrimStrideData, VertexCount, Indices, IndexCount, Flags);
4255 }
4256
4257 /*****************************************************************************
4258 * IDirect3DDevice7::DrawPrimitiveVB
4259 *
4260 * Draws primitives from a vertex buffer to the screen.
4261 *
4262 * Version 3 and 7
4263 *
4264 * Params:
4265 * PrimitiveType: Type of primitive to be rendered.
4266 * D3DVertexBuf: Source Vertex Buffer
4267 * StartVertex: Index of the first vertex from the buffer to be rendered
4268 * NumVertices: Number of vertices to be rendered
4269 * Flags: Can be D3DDP_WAIT to wait until rendering has finished
4270 *
4271 * Return values
4272 * D3D_OK on success
4273 * DDERR_INVALIDPARAMS if D3DVertexBuf is NULL
4274 *
4275 *****************************************************************************/
4276 static HRESULT d3d_device7_DrawPrimitiveVB(IDirect3DDevice7 *iface, D3DPRIMITIVETYPE primitive_type,
4277 IDirect3DVertexBuffer7 *vb, DWORD start_vertex, DWORD vertex_count, DWORD flags)
4278 {
4279 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
4280 struct d3d_vertex_buffer *vb_impl = unsafe_impl_from_IDirect3DVertexBuffer7(vb);
4281 struct wined3d_resource *wined3d_resource;
4282 struct wined3d_map_desc wined3d_map_desc;
4283 struct wined3d_box wined3d_box = {0};
4284 DWORD stride;
4285 HRESULT hr;
4286
4287 TRACE("iface %p, primitive_type %#x, vb %p, start_vertex %u, vertex_count %u, flags %#x.\n",
4288 iface, primitive_type, vb, start_vertex, vertex_count, flags);
4289
4290 if (!vertex_count)
4291 {
4292 WARN("0 vertex count.\n");
4293 return D3D_OK;
4294 }
4295
4296 stride = get_flexible_vertex_size(vb_impl->fvf);
4297
4298 if (vb_impl->Caps & D3DVBCAPS_SYSTEMMEMORY)
4299 {
4300 TRACE("Drawing from D3DVBCAPS_SYSTEMMEMORY vertex buffer, forwarding to DrawPrimitive().\n");
4301 wined3d_mutex_lock();
4302 wined3d_resource = wined3d_buffer_get_resource(vb_impl->wined3d_buffer);
4303 wined3d_box.left = start_vertex * stride;
4304 wined3d_box.right = wined3d_box.left + vertex_count * stride;
4305 if (FAILED(hr = wined3d_resource_map(wined3d_resource, 0, &wined3d_map_desc,
4306 &wined3d_box, WINED3D_MAP_READ)))
4307 {
4308 wined3d_mutex_unlock();
4309 return D3DERR_VERTEXBUFFERLOCKED;
4310 }
4311 hr = d3d_device7_DrawPrimitive(iface, primitive_type, vb_impl->fvf, wined3d_map_desc.data,
4312 vertex_count, flags);
4313 wined3d_resource_unmap(wined3d_resource, 0);
4314 wined3d_mutex_unlock();
4315 return hr;
4316 }
4317
4318 wined3d_mutex_lock();
4319 wined3d_stateblock_set_vertex_declaration(device->state, vb_impl->wined3d_declaration);
4320 if (FAILED(hr = wined3d_stateblock_set_stream_source(device->state,
4321 0, vb_impl->wined3d_buffer, 0, stride)))
4322 {
4323 WARN("Failed to set stream source, hr %#x.\n", hr);
4324 wined3d_mutex_unlock();
4325 return hr;
4326 }
4327
4328 /* Now draw the primitives */
4329 wined3d_device_context_set_primitive_type(device->immediate_context,
4330 wined3d_primitive_type_from_ddraw(primitive_type), 0);
4331 wined3d_device_apply_stateblock(device->wined3d_device, device->state);
4332 d3d_device_sync_surfaces(device);
4333 wined3d_device_context_draw(device->immediate_context, start_vertex, vertex_count, 0, 0);
4334
4335 wined3d_mutex_unlock();
4336
4337 return hr;
4338 }
4339
4340 static HRESULT WINAPI d3d_device7_DrawPrimitiveVB_FPUSetup(IDirect3DDevice7 *iface, D3DPRIMITIVETYPE PrimitiveType,
4341 IDirect3DVertexBuffer7 *D3DVertexBuf, DWORD StartVertex, DWORD NumVertices, DWORD Flags)
4342 {
4343 return d3d_device7_DrawPrimitiveVB(iface, PrimitiveType, D3DVertexBuf, StartVertex, NumVertices, Flags);
4344 }
4345
4346 static HRESULT WINAPI d3d_device7_DrawPrimitiveVB_FPUPreserve(IDirect3DDevice7 *iface, D3DPRIMITIVETYPE PrimitiveType,
4347 IDirect3DVertexBuffer7 *D3DVertexBuf, DWORD StartVertex, DWORD NumVertices, DWORD Flags)
4348 {
4349 HRESULT hr;
4350 WORD old_fpucw;
4351
4352 old_fpucw = d3d_fpu_setup();
4353 hr = d3d_device7_DrawPrimitiveVB(iface, PrimitiveType, D3DVertexBuf, StartVertex, NumVertices, Flags);
4354 set_fpu_control_word(old_fpucw);
4355
4356 return hr;
4357 }
4358
4359 static HRESULT WINAPI d3d_device3_DrawPrimitiveVB(IDirect3DDevice3 *iface, D3DPRIMITIVETYPE PrimitiveType,
4360 IDirect3DVertexBuffer *D3DVertexBuf, DWORD StartVertex, DWORD NumVertices, DWORD Flags)
4361 {
4362 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
4363 struct d3d_vertex_buffer *vb = unsafe_impl_from_IDirect3DVertexBuffer7((IDirect3DVertexBuffer7 *)D3DVertexBuf);
4364
4365 TRACE("iface %p, primitive_type %#x, vb %p, start_vertex %u, vertex_count %u, flags %#x.\n",
4366 iface, PrimitiveType, D3DVertexBuf, StartVertex, NumVertices, Flags);
4367
4368 setup_lighting(device, vb->fvf, Flags);
4369
4370 return IDirect3DDevice7_DrawPrimitiveVB(&device->IDirect3DDevice7_iface,
4371 PrimitiveType, &vb->IDirect3DVertexBuffer7_iface, StartVertex, NumVertices, Flags);
4372 }
4373
4374 /*****************************************************************************
4375 * IDirect3DDevice7::DrawIndexedPrimitiveVB
4376 *
4377 * Draws primitives from a vertex buffer to the screen
4378 *
4379 * Params:
4380 * PrimitiveType: Type of primitive to be rendered.
4381 * D3DVertexBuf: Source Vertex Buffer
4382 * StartVertex: Index of the first vertex from the buffer to be rendered
4383 * NumVertices: Number of vertices to be rendered
4384 * Indices: Array of DWORDs used to index into the Vertices
4385 * IndexCount: Number of indices in Indices
4386 * Flags: Can be D3DDP_WAIT to wait until rendering has finished
4387 *
4388 * Return values
4389 *
4390 *****************************************************************************/
4391 static HRESULT d3d_device7_DrawIndexedPrimitiveVB(IDirect3DDevice7 *iface,
4392 D3DPRIMITIVETYPE primitive_type, IDirect3DVertexBuffer7 *vb,
4393 DWORD start_vertex, DWORD vertex_count, WORD *indices, DWORD index_count, DWORD flags)
4394 {
4395 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
4396 struct d3d_vertex_buffer *vb_impl = unsafe_impl_from_IDirect3DVertexBuffer7(vb);
4397 DWORD stride = get_flexible_vertex_size(vb_impl->fvf);
4398 struct wined3d_resource *wined3d_resource;
4399 struct wined3d_map_desc wined3d_map_desc;
4400 struct wined3d_box wined3d_box = {0};
4401 struct wined3d_resource *ib;
4402 HRESULT hr;
4403 UINT ib_pos;
4404
4405 TRACE("iface %p, primitive_type %#x, vb %p, start_vertex %u, "
4406 "vertex_count %u, indices %p, index_count %u, flags %#x.\n",
4407 iface, primitive_type, vb, start_vertex, vertex_count, indices, index_count, flags);
4408
4409 if (!vertex_count || !index_count)
4410 {
4411 WARN("0 vertex or index count.\n");
4412 return D3D_OK;
4413 }
4414
4415 if (vb_impl->Caps & D3DVBCAPS_SYSTEMMEMORY)
4416 {
4417 TRACE("Drawing from D3DVBCAPS_SYSTEMMEMORY vertex buffer, forwarding to DrawIndexedPrimitive().\n");
4418 wined3d_mutex_lock();
4419 wined3d_box.left = start_vertex * stride;
4420 wined3d_box.right = wined3d_box.left + vertex_count * stride;
4421 wined3d_resource = wined3d_buffer_get_resource(vb_impl->wined3d_buffer);
4422 if (FAILED(hr = wined3d_resource_map(wined3d_resource, 0, &wined3d_map_desc,
4423 &wined3d_box, WINED3D_MAP_READ)))
4424 {
4425 wined3d_mutex_unlock();
4426 return D3DERR_VERTEXBUFFERLOCKED;
4427 }
4428 hr = d3d_device7_DrawIndexedPrimitive(iface, primitive_type, vb_impl->fvf,
4429 wined3d_map_desc.data, vertex_count, indices, index_count, flags);
4430 wined3d_resource_unmap(wined3d_resource, 0);
4431 wined3d_mutex_unlock();
4432 return hr;
4433 }
4434
4435 /* Steps:
4436 * 1) Upload the indices to the index buffer
4437 * 2) Set the index source
4438 * 3) Set the Vertex Buffer as the Stream source
4439 * 4) Call wined3d_device_context_draw_indexed()
4440 */
4441
4442 wined3d_mutex_lock();
4443
4444 wined3d_stateblock_set_vertex_declaration(device->state, vb_impl->wined3d_declaration);
4445
4446 hr = d3d_device_prepare_index_buffer(device, index_count * sizeof(WORD));
4447 if (FAILED(hr))
4448 {
4449 wined3d_mutex_unlock();
4450 return hr;
4451 }
4452 ib_pos = device->index_buffer_pos;
4453
4454 if (device->index_buffer_size - index_count * sizeof(WORD) < ib_pos)
4455 ib_pos = 0;
4456
4457 /* Copy the index stream into the index buffer. */
4458 wined3d_box.left = ib_pos;
4459 wined3d_box.right = ib_pos + index_count * sizeof(WORD);
4460 ib = wined3d_buffer_get_resource(device->index_buffer);
4461 if (FAILED(hr = wined3d_resource_map(ib, 0, &wined3d_map_desc, &wined3d_box,
4462 WINED3D_MAP_WRITE | (ib_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
4463 {
4464 ERR("Failed to map buffer, hr %#x.\n", hr);
4465 wined3d_mutex_unlock();
4466 return hr;
4467 }
4468 memcpy(wined3d_map_desc.data, indices, index_count * sizeof(WORD));
4469 wined3d_resource_unmap(ib, 0);
4470 device->index_buffer_pos = ib_pos + index_count * sizeof(WORD);
4471
4472 /* Set the index stream */
4473 wined3d_stateblock_set_index_buffer(device->state, device->index_buffer, WINED3DFMT_R16_UINT);
4474
4475 /* Set the vertex stream source */
4476 if (FAILED(hr = wined3d_stateblock_set_stream_source(device->state,
4477 0, vb_impl->wined3d_buffer, 0, stride)))
4478 {
4479 ERR("(%p) IDirect3DDevice::SetStreamSource failed with hr = %08x\n", device, hr);
4480 wined3d_mutex_unlock();
4481 return hr;
4482 }
4483
4484 wined3d_device_context_set_primitive_type(device->immediate_context,
4485 wined3d_primitive_type_from_ddraw(primitive_type), 0);
4486 wined3d_device_apply_stateblock(device->wined3d_device, device->state);
4487 d3d_device_sync_surfaces(device);
4488 wined3d_device_context_draw_indexed(device->immediate_context, start_vertex,
4489 ib_pos / sizeof(WORD), index_count, 0, 0);
4490
4491 wined3d_mutex_unlock();
4492
4493 return hr;
4494 }
4495
4496 static HRESULT WINAPI d3d_device7_DrawIndexedPrimitiveVB_FPUSetup(IDirect3DDevice7 *iface,
4497 D3DPRIMITIVETYPE PrimitiveType, IDirect3DVertexBuffer7 *D3DVertexBuf,
4498 DWORD StartVertex, DWORD NumVertices, WORD *Indices, DWORD IndexCount, DWORD Flags)
4499 {
4500 return d3d_device7_DrawIndexedPrimitiveVB(iface, PrimitiveType,
4501 D3DVertexBuf, StartVertex, NumVertices, Indices, IndexCount, Flags);
4502 }
4503
4504 static HRESULT WINAPI d3d_device7_DrawIndexedPrimitiveVB_FPUPreserve(IDirect3DDevice7 *iface,
4505 D3DPRIMITIVETYPE PrimitiveType, IDirect3DVertexBuffer7 *D3DVertexBuf,
4506 DWORD StartVertex, DWORD NumVertices, WORD *Indices, DWORD IndexCount, DWORD Flags)
4507 {
4508 HRESULT hr;
4509 WORD old_fpucw;
4510
4511 old_fpucw = d3d_fpu_setup();
4512 hr = d3d_device7_DrawIndexedPrimitiveVB(iface, PrimitiveType,
4513 D3DVertexBuf, StartVertex, NumVertices, Indices, IndexCount, Flags);
4514 set_fpu_control_word(old_fpucw);
4515
4516 return hr;
4517 }
4518
4519 static HRESULT WINAPI d3d_device3_DrawIndexedPrimitiveVB(IDirect3DDevice3 *iface,
4520 D3DPRIMITIVETYPE primitive_type, IDirect3DVertexBuffer *vertex_buffer,
4521 WORD *indices, DWORD index_count, DWORD flags)
4522 {
4523 struct d3d_vertex_buffer *vb =
4524 unsafe_impl_from_IDirect3DVertexBuffer7((IDirect3DVertexBuffer7 *)vertex_buffer);
4525 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
4526 DWORD stride;
4527
4528 TRACE("iface %p, primitive_type %#x, vb %p, indices %p, index_count %u, flags %#x.\n",
4529 iface, primitive_type, vertex_buffer, indices, index_count, flags);
4530
4531 setup_lighting(device, vb->fvf, flags);
4532
4533 if (!(stride = get_flexible_vertex_size(vb->fvf)))
4534 return D3D_OK;
4535
4536 return IDirect3DDevice7_DrawIndexedPrimitiveVB(&device->IDirect3DDevice7_iface, primitive_type,
4537 &vb->IDirect3DVertexBuffer7_iface, 0, vb->size / stride, indices, index_count, flags);
4538 }
4539
4540 /*****************************************************************************
4541 * IDirect3DDevice7::ComputeSphereVisibility
4542 *
4543 * Calculates the visibility of spheres in the current viewport. The spheres
4544 * are passed in the Centers and Radii arrays, the results are passed back
4545 * in the ReturnValues array. Return values are either completely visible,
4546 * partially visible or completely invisible.
4547 * The return value consists of a combination of D3DCLIP_* flags, or is
4548 * 0 if the sphere is completely visible (according to the SDK, not checked)
4549 *
4550 * Version 3 and 7
4551 *
4552 * Params:
4553 * Centers: Array containing the sphere centers
4554 * Radii: Array containing the sphere radii
4555 * NumSpheres: The number of centers and radii in the arrays
4556 * Flags: Some flags
4557 * ReturnValues: Array to write the results to
4558 *
4559 * Returns:
4560 * D3D_OK
4561 * (DDERR_INVALIDPARAMS if Centers, Radii or ReturnValues are NULL)
4562 * (D3DERR_INVALIDMATRIX if the combined world, view and proj matrix
4563 * is singular)
4564 *
4565 *****************************************************************************/
4566
4567 static DWORD in_plane(UINT idx, struct wined3d_vec4 p, D3DVECTOR center, D3DVALUE radius, BOOL equality)
4568 {
4569 float distance, norm;
4570
4571 norm = sqrtf(p.x * p.x + p.y * p.y + p.z * p.z);
4572 distance = (p.x * center.u1.x + p.y * center.u2.y + p.z * center.u3.z + p.w) / norm;
4573
4574 if (equality)
4575 {
4576 if (fabs(distance) <= radius)
4577 return D3DSTATUS_CLIPUNIONLEFT << idx;
4578 if (distance <= -radius)
4579 return (D3DSTATUS_CLIPUNIONLEFT | D3DSTATUS_CLIPINTERSECTIONLEFT) << idx;
4580 }
4581 else
4582 {
4583 if (fabs(distance) < radius)
4584 return D3DSTATUS_CLIPUNIONLEFT << idx;
4585 if (distance < -radius)
4586 return (D3DSTATUS_CLIPUNIONLEFT | D3DSTATUS_CLIPINTERSECTIONLEFT) << idx;
4587 }
4588 return 0;
4589 }
4590
4591 static void prepare_clip_space_planes(struct d3d_device *device, struct wined3d_vec4 *plane)
4592 {
4593 const struct wined3d_stateblock_state *state;
4594 struct wined3d_matrix m;
4595
4596 /* We want the wined3d matrices since those include the legacy viewport
4597 * transformation. */
4598 wined3d_mutex_lock();
4599 state = device->stateblock_state;
4600 multiply_matrix(&m, &state->transforms[WINED3D_TS_VIEW], &state->transforms[WINED3D_TS_WORLD]);
4601 multiply_matrix(&m, &state->transforms[WINED3D_TS_PROJECTION], &m);
4602 wined3d_mutex_unlock();
4603
4604 /* Left plane. */
4605 plane[0].x = m._14 + m._11;
4606 plane[0].y = m._24 + m._21;
4607 plane[0].z = m._34 + m._31;
4608 plane[0].w = m._44 + m._41;
4609
4610 /* Right plane. */
4611 plane[1].x = m._14 - m._11;
4612 plane[1].y = m._24 - m._21;
4613 plane[1].z = m._34 - m._31;
4614 plane[1].w = m._44 - m._41;
4615
4616 /* Top plane. */
4617 plane[2].x = m._14 - m._12;
4618 plane[2].y = m._24 - m._22;
4619 plane[2].z = m._34 - m._32;
4620 plane[2].w = m._44 - m._42;
4621
4622 /* Bottom plane. */
4623 plane[3].x = m._14 + m._12;
4624 plane[3].y = m._24 + m._22;
4625 plane[3].z = m._34 + m._32;
4626 plane[3].w = m._44 + m._42;
4627
4628 /* Front plane. */
4629 plane[4].x = m._13;
4630 plane[4].y = m._23;
4631 plane[4].z = m._33;
4632 plane[4].w = m._43;
4633
4634 /* Back plane. */
4635 plane[5].x = m._14 - m._13;
4636 plane[5].y = m._24 - m._23;
4637 plane[5].z = m._34 - m._33;
4638 plane[5].w = m._44 - m._43;
4639 }
4640
4641 static void compute_sphere_visibility(struct wined3d_vec4 plane[12], DWORD enabled_planes, BOOL equality,
4642 D3DVECTOR *centers, D3DVALUE *radii, DWORD sphere_count, DWORD *return_values)
4643 {
4644 UINT i, j;
4645
4646 for (i = 0; i < sphere_count; ++i)
4647 {
4648 return_values[i] = 0;
4649 for (j = 0; j < 12; ++j)
4650 if (enabled_planes & 1u << j)
4651 return_values[i] |= in_plane(j, plane[j], centers[i], radii[i], equality);
4652 }
4653 }
4654
4655 static HRESULT WINAPI d3d_device7_ComputeSphereVisibility(IDirect3DDevice7 *iface,
4656 D3DVECTOR *centers, D3DVALUE *radii, DWORD sphere_count, DWORD flags, DWORD *return_values)
4657 {
4658 struct wined3d_vec4 plane[12];
4659 DWORD enabled_planes = 0x3f;
4660 DWORD user_clip_planes;
4661 UINT j;
4662
4663 TRACE("iface %p, centers %p, radii %p, sphere_count %u, flags %#x, return_values %p.\n",
4664 iface, centers, radii, sphere_count, flags, return_values);
4665
4666 prepare_clip_space_planes(impl_from_IDirect3DDevice7(iface), plane);
4667
4668 IDirect3DDevice7_GetRenderState(iface, D3DRENDERSTATE_CLIPPLANEENABLE, &user_clip_planes);
4669 enabled_planes |= user_clip_planes << 6;
4670 for (j = 6; j < 12; ++j)
4671 IDirect3DDevice7_GetClipPlane(iface, j - 6, (D3DVALUE *)&plane[j]);
4672
4673 compute_sphere_visibility(plane, enabled_planes, FALSE, centers, radii, sphere_count, return_values);
4674 return D3D_OK;
4675 }
4676
4677 static HRESULT WINAPI d3d_device3_ComputeSphereVisibility(IDirect3DDevice3 *iface,
4678 D3DVECTOR *centers, D3DVALUE *radii, DWORD sphere_count, DWORD flags, DWORD *return_values)
4679 {
4680 static const DWORD enabled_planes = 0x3f;
4681 struct wined3d_vec4 plane[6];
4682 unsigned int i, j;
4683
4684 TRACE("iface %p, centers %p, radii %p, sphere_count %u, flags %#x, return_values %p.\n",
4685 iface, centers, radii, sphere_count, flags, return_values);
4686
4687 prepare_clip_space_planes(impl_from_IDirect3DDevice3(iface), plane);
4688
4689 compute_sphere_visibility(plane, enabled_planes, TRUE, centers, radii, sphere_count, return_values);
4690 for (i = 0; i < sphere_count; ++i)
4691 {
4692 BOOL intersect_frustum = FALSE, outside_frustum = FALSE;
4693 DWORD d3d7_result = return_values[i];
4694
4695 return_values[i] = 0;
4696
4697 for (j = 0; j < 6; ++j)
4698 {
4699 DWORD clip = (d3d7_result >> j) & (D3DSTATUS_CLIPUNIONLEFT | D3DSTATUS_CLIPINTERSECTIONLEFT);
4700
4701 if (clip == D3DSTATUS_CLIPUNIONLEFT)
4702 {
4703 return_values[i] |= D3DVIS_INTERSECT_LEFT << j * 2;
4704 intersect_frustum = TRUE;
4705 }
4706 else if (clip)
4707 {
4708 return_values[i] |= D3DVIS_OUTSIDE_LEFT << j * 2;
4709 outside_frustum = TRUE;
4710 }
4711 }
4712 if (outside_frustum)
4713 return_values[i] |= D3DVIS_OUTSIDE_FRUSTUM;
4714 else if (intersect_frustum)
4715 return_values[i] |= D3DVIS_INTERSECT_FRUSTUM;
4716 }
4717 return D3D_OK;
4718 }
4719
4720 /*****************************************************************************
4721 * IDirect3DDevice7::GetTexture
4722 *
4723 * Returns the texture interface handle assigned to a texture stage.
4724 * The returned texture is AddRefed. This is taken from old ddraw,
4725 * not checked in Windows.
4726 *
4727 * Version 3 and 7
4728 *
4729 * Params:
4730 * Stage: Texture stage to read the texture from
4731 * Texture: Address to store the interface pointer at
4732 *
4733 * Returns:
4734 * D3D_OK on success
4735 * DDERR_INVALIDPARAMS if Texture is NULL
4736 *
4737 *****************************************************************************/
4738 static HRESULT d3d_device7_GetTexture(IDirect3DDevice7 *iface,
4739 DWORD stage, IDirectDrawSurface7 **texture)
4740 {
4741 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
4742 struct wined3d_texture *wined3d_texture;
4743 struct ddraw_texture *ddraw_texture;
4744
4745 TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture);
4746
4747 if (!texture)
4748 return DDERR_INVALIDPARAMS;
4749
4750 if (stage >= DDRAW_MAX_TEXTURES)
4751 {
4752 WARN("Invalid stage %u.\n", stage);
4753 *texture = NULL;
4754 return D3D_OK;
4755 }
4756
4757 wined3d_mutex_lock();
4758 if (!(wined3d_texture = device->stateblock_state->textures[stage]))
4759 {
4760 *texture = NULL;
4761 wined3d_mutex_unlock();
4762 return D3D_OK;
4763 }
4764
4765 ddraw_texture = wined3d_texture_get_parent(wined3d_texture);
4766 *texture = &ddraw_texture->root->IDirectDrawSurface7_iface;
4767 IDirectDrawSurface7_AddRef(*texture);
4768 wined3d_mutex_unlock();
4769
4770 return D3D_OK;
4771 }
4772
4773 static HRESULT WINAPI d3d_device7_GetTexture_FPUSetup(IDirect3DDevice7 *iface,
4774 DWORD stage, IDirectDrawSurface7 **Texture)
4775 {
4776 return d3d_device7_GetTexture(iface, stage, Texture);
4777 }
4778
4779 static HRESULT WINAPI d3d_device7_GetTexture_FPUPreserve(IDirect3DDevice7 *iface,
4780 DWORD stage, IDirectDrawSurface7 **Texture)
4781 {
4782 HRESULT hr;
4783 WORD old_fpucw;
4784
4785 old_fpucw = d3d_fpu_setup();
4786 hr = d3d_device7_GetTexture(iface, stage, Texture);
4787 set_fpu_control_word(old_fpucw);
4788
4789 return hr;
4790 }
4791
4792 static HRESULT WINAPI d3d_device3_GetTexture(IDirect3DDevice3 *iface, DWORD stage, IDirect3DTexture2 **Texture2)
4793 {
4794 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
4795 struct ddraw_surface *ret_val_impl;
4796 HRESULT ret;
4797 IDirectDrawSurface7 *ret_val;
4798
4799 TRACE("iface %p, stage %u, texture %p.\n", iface, stage, Texture2);
4800
4801 ret = IDirect3DDevice7_GetTexture(&device->IDirect3DDevice7_iface, stage, &ret_val);
4802
4803 ret_val_impl = unsafe_impl_from_IDirectDrawSurface7(ret_val);
4804 *Texture2 = ret_val_impl ? &ret_val_impl->IDirect3DTexture2_iface : NULL;
4805
4806 TRACE("Returning texture %p.\n", *Texture2);
4807
4808 return ret;
4809 }
4810
4811 /*****************************************************************************
4812 * IDirect3DDevice7::SetTexture
4813 *
4814 * Assigns a texture to a texture stage. Is the texture AddRef-ed?
4815 *
4816 * Version 3 and 7
4817 *
4818 * Params:
4819 * Stage: The stage to assign the texture to
4820 * Texture: Interface pointer to the texture surface
4821 *
4822 * Returns
4823 * D3D_OK on success
4824 *
4825 *****************************************************************************/
4826 static HRESULT d3d_device7_SetTexture(IDirect3DDevice7 *iface,
4827 DWORD stage, IDirectDrawSurface7 *texture)
4828 {
4829 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
4830 struct ddraw_surface *surf = unsafe_impl_from_IDirectDrawSurface7(texture);
4831 struct wined3d_texture *wined3d_texture = NULL;
4832
4833 TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture);
4834
4835 if (surf && (surf->surface_desc.ddsCaps.dwCaps & DDSCAPS_TEXTURE))
4836 wined3d_texture = surf->draw_texture ? surf->draw_texture : surf->wined3d_texture;
4837
4838 wined3d_mutex_lock();
4839 wined3d_stateblock_set_texture(device->update_state, stage, wined3d_texture);
4840 wined3d_mutex_unlock();
4841
4842 return D3D_OK;
4843 }
4844
4845 static HRESULT WINAPI d3d_device7_SetTexture_FPUSetup(IDirect3DDevice7 *iface,
4846 DWORD stage, IDirectDrawSurface7 *texture)
4847 {
4848 return d3d_device7_SetTexture(iface, stage, texture);
4849 }
4850
4851 static HRESULT WINAPI d3d_device7_SetTexture_FPUPreserve(IDirect3DDevice7 *iface,
4852 DWORD stage, IDirectDrawSurface7 *texture)
4853 {
4854 HRESULT hr;
4855 WORD old_fpucw;
4856
4857 old_fpucw = d3d_fpu_setup();
4858 hr = d3d_device7_SetTexture(iface, stage, texture);
4859 set_fpu_control_word(old_fpucw);
4860
4861 return hr;
4862 }
4863
4864 static HRESULT WINAPI d3d_device3_SetTexture(IDirect3DDevice3 *iface,
4865 DWORD stage, IDirect3DTexture2 *texture)
4866 {
4867 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
4868 struct ddraw_surface *tex = unsafe_impl_from_IDirect3DTexture2(texture);
4869 struct wined3d_texture *wined3d_texture = NULL;
4870
4871 TRACE("iface %p, stage %u, texture %p.\n", iface, stage, texture);
4872
4873 wined3d_mutex_lock();
4874
4875 if (tex && ((tex->surface_desc.ddsCaps.dwCaps & DDSCAPS_TEXTURE) || !device->hardware_device))
4876 wined3d_texture = tex->draw_texture ? tex->draw_texture : tex->wined3d_texture;
4877
4878 wined3d_stateblock_set_texture(device->state, stage, wined3d_texture);
4879 fixup_texture_alpha_op(device);
4880
4881 wined3d_mutex_unlock();
4882
4883 return D3D_OK;
4884 }
4885
4886 static const struct tss_lookup
4887 {
4888 BOOL sampler_state;
4889 union
4890 {
4891 enum wined3d_texture_stage_state texture_state;
4892 enum wined3d_sampler_state sampler_state;
4893 } u;
4894 }
4895 tss_lookup[] =
4896 {
4897 {FALSE, {WINED3D_TSS_INVALID}}, /* 0, unused */
4898 {FALSE, {WINED3D_TSS_COLOR_OP}}, /* 1, D3DTSS_COLOROP */
4899 {FALSE, {WINED3D_TSS_COLOR_ARG1}}, /* 2, D3DTSS_COLORARG1 */
4900 {FALSE, {WINED3D_TSS_COLOR_ARG2}}, /* 3, D3DTSS_COLORARG2 */
4901 {FALSE, {WINED3D_TSS_ALPHA_OP}}, /* 4, D3DTSS_ALPHAOP */
4902 {FALSE, {WINED3D_TSS_ALPHA_ARG1}}, /* 5, D3DTSS_ALPHAARG1 */
4903 {FALSE, {WINED3D_TSS_ALPHA_ARG2}}, /* 6, D3DTSS_ALPHAARG2 */
4904 {FALSE, {WINED3D_TSS_BUMPENV_MAT00}}, /* 7, D3DTSS_BUMPENVMAT00 */
4905 {FALSE, {WINED3D_TSS_BUMPENV_MAT01}}, /* 8, D3DTSS_BUMPENVMAT01 */
4906 {FALSE, {WINED3D_TSS_BUMPENV_MAT10}}, /* 9, D3DTSS_BUMPENVMAT10 */
4907 {FALSE, {WINED3D_TSS_BUMPENV_MAT11}}, /* 10, D3DTSS_BUMPENVMAT11 */
4908 {FALSE, {WINED3D_TSS_TEXCOORD_INDEX}}, /* 11, D3DTSS_TEXCOORDINDEX */
4909 {TRUE, {WINED3D_SAMP_ADDRESS_U}}, /* 12, D3DTSS_ADDRESS */
4910 {TRUE, {WINED3D_SAMP_ADDRESS_U}}, /* 13, D3DTSS_ADDRESSU */
4911 {TRUE, {WINED3D_SAMP_ADDRESS_V}}, /* 14, D3DTSS_ADDRESSV */
4912 {TRUE, {WINED3D_SAMP_BORDER_COLOR}}, /* 15, D3DTSS_BORDERCOLOR */
4913 {TRUE, {WINED3D_SAMP_MAG_FILTER}}, /* 16, D3DTSS_MAGFILTER */
4914 {TRUE, {WINED3D_SAMP_MIN_FILTER}}, /* 17, D3DTSS_MINFILTER */
4915 {TRUE, {WINED3D_SAMP_MIP_FILTER}}, /* 18, D3DTSS_MIPFILTER */
4916 {TRUE, {WINED3D_SAMP_MIPMAP_LOD_BIAS}}, /* 19, D3DTSS_MIPMAPLODBIAS */
4917 {TRUE, {WINED3D_SAMP_MAX_MIP_LEVEL}}, /* 20, D3DTSS_MAXMIPLEVEL */
4918 {TRUE, {WINED3D_SAMP_MAX_ANISOTROPY}}, /* 21, D3DTSS_MAXANISOTROPY */
4919 {FALSE, {WINED3D_TSS_BUMPENV_LSCALE}}, /* 22, D3DTSS_BUMPENVLSCALE */
4920 {FALSE, {WINED3D_TSS_BUMPENV_LOFFSET}}, /* 23, D3DTSS_BUMPENVLOFFSET */
4921 {FALSE, {WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS}}, /* 24, D3DTSS_TEXTURETRANSFORMFLAGS */
4922 };
4923
4924 /*****************************************************************************
4925 * IDirect3DDevice7::GetTextureStageState
4926 *
4927 * Retrieves a state from a texture stage.
4928 *
4929 * Version 3 and 7
4930 *
4931 * Params:
4932 * Stage: The stage to retrieve the state from
4933 * TexStageStateType: The state type to retrieve
4934 * State: Address to store the state's value at
4935 *
4936 * Returns:
4937 * D3D_OK on success
4938 * DDERR_INVALIDPARAMS if State is NULL
4939 *
4940 *****************************************************************************/
4941 static HRESULT d3d_device7_GetTextureStageState(IDirect3DDevice7 *iface,
4942 DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD *value)
4943 {
4944 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
4945 const struct wined3d_stateblock_state *device_state;
4946 const struct tss_lookup *l;
4947
4948 TRACE("iface %p, stage %u, state %#x, value %p.\n",
4949 iface, stage, state, value);
4950
4951 if (!value)
4952 return DDERR_INVALIDPARAMS;
4953
4954 if (state > D3DTSS_TEXTURETRANSFORMFLAGS)
4955 {
4956 WARN("Invalid state %#x passed.\n", state);
4957 return DD_OK;
4958 }
4959
4960 if (stage >= DDRAW_MAX_TEXTURES)
4961 {
4962 WARN("Invalid stage %u.\n", stage);
4963 *value = 0;
4964 return D3D_OK;
4965 }
4966
4967 l = &tss_lookup[state];
4968
4969 wined3d_mutex_lock();
4970
4971 device_state = device->stateblock_state;
4972
4973 if (l->sampler_state)
4974 {
4975 *value = device_state->sampler_states[stage][l->u.sampler_state];
4976
4977 switch (state)
4978 {
4979 /* Mipfilter is a sampler state with different values */
4980 case D3DTSS_MIPFILTER:
4981 {
4982 switch (*value)
4983 {
4984 case WINED3D_TEXF_NONE:
4985 *value = D3DTFP_NONE;
4986 break;
4987 case WINED3D_TEXF_POINT:
4988 *value = D3DTFP_POINT;
4989 break;
4990 case WINED3D_TEXF_LINEAR:
4991 *value = D3DTFP_LINEAR;
4992 break;
4993 default:
4994 ERR("Unexpected mipfilter value %#x.\n", *value);
4995 *value = D3DTFP_NONE;
4996 break;
4997 }
4998 break;
4999 }
5000
5001 /* Magfilter has slightly different values */
5002 case D3DTSS_MAGFILTER:
5003 {
5004 switch (*value)
5005 {
5006 case WINED3D_TEXF_POINT:
5007 *value = D3DTFG_POINT;
5008 break;
5009 case WINED3D_TEXF_LINEAR:
5010 *value = D3DTFG_LINEAR;
5011 break;
5012 case WINED3D_TEXF_ANISOTROPIC:
5013 *value = D3DTFG_ANISOTROPIC;
5014 break;
5015 case WINED3D_TEXF_FLAT_CUBIC:
5016 *value = D3DTFG_FLATCUBIC;
5017 break;
5018 case WINED3D_TEXF_GAUSSIAN_CUBIC:
5019 *value = D3DTFG_GAUSSIANCUBIC;
5020 break;
5021 default:
5022 ERR("Unexpected wined3d mag filter value %#x.\n", *value);
5023 *value = D3DTFG_POINT;
5024 break;
5025 }
5026 break;
5027 }
5028
5029 default:
5030 break;
5031 }
5032 }
5033 else
5034 {
5035 *value = device_state->texture_states[stage][l->u.texture_state];
5036 }
5037
5038 wined3d_mutex_unlock();
5039
5040 return D3D_OK;
5041 }
5042
5043 static HRESULT WINAPI d3d_device7_GetTextureStageState_FPUSetup(IDirect3DDevice7 *iface,
5044 DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD *value)
5045 {
5046 return d3d_device7_GetTextureStageState(iface, stage, state, value);
5047 }
5048
5049 static HRESULT WINAPI d3d_device7_GetTextureStageState_FPUPreserve(IDirect3DDevice7 *iface,
5050 DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD *value)
5051 {
5052 HRESULT hr;
5053 WORD old_fpucw;
5054
5055 old_fpucw = d3d_fpu_setup();
5056 hr = d3d_device7_GetTextureStageState(iface, stage, state, value);
5057 set_fpu_control_word(old_fpucw);
5058
5059 return hr;
5060 }
5061
5062 static HRESULT WINAPI d3d_device3_GetTextureStageState(IDirect3DDevice3 *iface,
5063 DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD *value)
5064 {
5065 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
5066
5067 TRACE("iface %p, stage %u, state %#x, value %p.\n",
5068 iface, stage, state, value);
5069
5070 return IDirect3DDevice7_GetTextureStageState(&device->IDirect3DDevice7_iface, stage, state, value);
5071 }
5072
5073 /*****************************************************************************
5074 * IDirect3DDevice7::SetTextureStageState
5075 *
5076 * Sets a texture stage state. Some stage types need to be handled specially,
5077 * because they do not exist in WineD3D and were moved to another place
5078 *
5079 * Version 3 and 7
5080 *
5081 * Params:
5082 * Stage: The stage to modify
5083 * TexStageStateType: The state to change
5084 * State: The new value for the state
5085 *
5086 * Returns:
5087 * D3D_OK on success
5088 *
5089 *****************************************************************************/
5090 static HRESULT d3d_device7_SetTextureStageState(IDirect3DDevice7 *iface,
5091 DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD value)
5092 {
5093 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5094 const struct tss_lookup *l;
5095
5096 TRACE("iface %p, stage %u, state %#x, value %#x.\n",
5097 iface, stage, state, value);
5098
5099 if (state > D3DTSS_TEXTURETRANSFORMFLAGS)
5100 {
5101 WARN("Invalid state %#x passed.\n", state);
5102 return DD_OK;
5103 }
5104
5105 l = &tss_lookup[state];
5106
5107 wined3d_mutex_lock();
5108
5109 if (l->sampler_state)
5110 {
5111 switch (state)
5112 {
5113 /* Mipfilter is a sampler state with different values */
5114 case D3DTSS_MIPFILTER:
5115 {
5116 switch (value)
5117 {
5118 case D3DTFP_NONE:
5119 value = WINED3D_TEXF_NONE;
5120 break;
5121 case D3DTFP_POINT:
5122 value = WINED3D_TEXF_POINT;
5123 break;
5124 case 0: /* Unchecked */
5125 case D3DTFP_LINEAR:
5126 value = WINED3D_TEXF_LINEAR;
5127 break;
5128 default:
5129 ERR("Unexpected mipfilter value %#x.\n", value);
5130 value = WINED3D_TEXF_NONE;
5131 break;
5132 }
5133 break;
5134 }
5135
5136 /* Magfilter has slightly different values */
5137 case D3DTSS_MAGFILTER:
5138 {
5139 switch (value)
5140 {
5141 case D3DTFG_POINT:
5142 value = WINED3D_TEXF_POINT;
5143 break;
5144 case D3DTFG_LINEAR:
5145 value = WINED3D_TEXF_LINEAR;
5146 break;
5147 case D3DTFG_FLATCUBIC:
5148 value = WINED3D_TEXF_FLAT_CUBIC;
5149 break;
5150 case D3DTFG_GAUSSIANCUBIC:
5151 value = WINED3D_TEXF_GAUSSIAN_CUBIC;
5152 break;
5153 case D3DTFG_ANISOTROPIC:
5154 value = WINED3D_TEXF_ANISOTROPIC;
5155 break;
5156 default:
5157 ERR("Unexpected d3d7 mag filter value %#x.\n", value);
5158 value = WINED3D_TEXF_POINT;
5159 break;
5160 }
5161 break;
5162 }
5163
5164 case D3DTSS_ADDRESS:
5165 wined3d_stateblock_set_sampler_state(device->state, stage, WINED3D_SAMP_ADDRESS_V, value);
5166 break;
5167
5168 default:
5169 break;
5170 }
5171
5172 wined3d_stateblock_set_sampler_state(device->state, stage, l->u.sampler_state, value);
5173 }
5174 else
5175 wined3d_stateblock_set_texture_stage_state(device->update_state, stage, l->u.texture_state, value);
5176
5177 wined3d_mutex_unlock();
5178
5179 return D3D_OK;
5180 }
5181
5182 static HRESULT WINAPI d3d_device7_SetTextureStageState_FPUSetup(IDirect3DDevice7 *iface,
5183 DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD value)
5184 {
5185 return d3d_device7_SetTextureStageState(iface, stage, state, value);
5186 }
5187
5188 static HRESULT WINAPI d3d_device7_SetTextureStageState_FPUPreserve(IDirect3DDevice7 *iface,
5189 DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD value)
5190 {
5191 HRESULT hr;
5192 WORD old_fpucw;
5193
5194 old_fpucw = d3d_fpu_setup();
5195 hr = d3d_device7_SetTextureStageState(iface, stage, state, value);
5196 set_fpu_control_word(old_fpucw);
5197
5198 return hr;
5199 }
5200
5201 static HRESULT WINAPI d3d_device3_SetTextureStageState(IDirect3DDevice3 *iface,
5202 DWORD stage, D3DTEXTURESTAGESTATETYPE state, DWORD value)
5203 {
5204 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
5205 DWORD old_value;
5206 HRESULT hr;
5207
5208 TRACE("iface %p, stage %u, state %#x, value %#x.\n",
5209 iface, stage, state, value);
5210
5211 /* Tests show that legacy texture blending is not reset if the texture stage state
5212 * value is unchanged. */
5213 if (FAILED(hr = IDirect3DDevice7_GetTextureStageState(&device->IDirect3DDevice7_iface,
5214 stage, state, &old_value)))
5215 return hr;
5216
5217 if (old_value == value)
5218 {
5219 TRACE("Application is setting the same value over, nothing to do.\n");
5220 return D3D_OK;
5221 }
5222
5223 device->legacyTextureBlending = FALSE;
5224
5225 return IDirect3DDevice7_SetTextureStageState(&device->IDirect3DDevice7_iface, stage, state, value);
5226 }
5227
5228 /*****************************************************************************
5229 * IDirect3DDevice7::ValidateDevice
5230 *
5231 * SDK: "Reports the device's ability to render the currently set
5232 * texture-blending operations in a single pass". Whatever that means
5233 * exactly...
5234 *
5235 * Version 3 and 7
5236 *
5237 * Params:
5238 * NumPasses: Address to write the number of necessary passes for the
5239 * desired effect to.
5240 *
5241 * Returns:
5242 * D3D_OK on success
5243 *
5244 *****************************************************************************/
5245 static HRESULT d3d_device7_ValidateDevice(IDirect3DDevice7 *iface, DWORD *pass_count)
5246 {
5247 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5248 HRESULT hr;
5249
5250 TRACE("iface %p, pass_count %p.\n", iface, pass_count);
5251
5252 wined3d_mutex_lock();
5253 wined3d_device_apply_stateblock(device->wined3d_device, device->state);
5254 hr = wined3d_device_validate_device(device->wined3d_device, pass_count);
5255 wined3d_mutex_unlock();
5256
5257 return hr;
5258 }
5259
5260 static HRESULT WINAPI d3d_device7_ValidateDevice_FPUSetup(IDirect3DDevice7 *iface, DWORD *pass_count)
5261 {
5262 return d3d_device7_ValidateDevice(iface, pass_count);
5263 }
5264
5265 static HRESULT WINAPI d3d_device7_ValidateDevice_FPUPreserve(IDirect3DDevice7 *iface, DWORD *pass_count)
5266 {
5267 HRESULT hr;
5268 WORD old_fpucw;
5269
5270 old_fpucw = d3d_fpu_setup();
5271 hr = d3d_device7_ValidateDevice(iface, pass_count);
5272 set_fpu_control_word(old_fpucw);
5273
5274 return hr;
5275 }
5276
5277 static HRESULT WINAPI d3d_device3_ValidateDevice(IDirect3DDevice3 *iface, DWORD *pass_count)
5278 {
5279 struct d3d_device *device = impl_from_IDirect3DDevice3(iface);
5280
5281 TRACE("iface %p, pass_count %p.\n", iface, pass_count);
5282
5283 return IDirect3DDevice7_ValidateDevice(&device->IDirect3DDevice7_iface, pass_count);
5284 }
5285
5286 /*****************************************************************************
5287 * IDirect3DDevice7::Clear
5288 *
5289 * Fills the render target, the z buffer and the stencil buffer with a
5290 * clear color / value
5291 *
5292 * Version 7 only
5293 *
5294 * Params:
5295 * Count: Number of rectangles in Rects must be 0 if Rects is NULL
5296 * Rects: Rectangles to clear. If NULL, the whole surface is cleared
5297 * Flags: Some flags, as usual
5298 * Color: Clear color for the render target
5299 * Z: Clear value for the Z buffer
5300 * Stencil: Clear value to store in each stencil buffer entry
5301 *
5302 * Returns:
5303 * D3D_OK on success
5304 *
5305 *****************************************************************************/
5306 static HRESULT d3d_device7_Clear(IDirect3DDevice7 *iface, DWORD count,
5307 D3DRECT *rects, DWORD flags, D3DCOLOR color, D3DVALUE z, DWORD stencil)
5308 {
5309 const struct wined3d_color c =
5310 {
5311 ((color >> 16) & 0xff) / 255.0f,
5312 ((color >> 8) & 0xff) / 255.0f,
5313 (color & 0xff) / 255.0f,
5314 ((color >> 24) & 0xff) / 255.0f,
5315 };
5316 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5317 HRESULT hr;
5318
5319 TRACE("iface %p, count %u, rects %p, flags %#x, color 0x%08x, z %.8e, stencil %#x.\n",
5320 iface, count, rects, flags, color, z, stencil);
5321
5322 if (count && !rects)
5323 {
5324 WARN("count %u with NULL rects.\n", count);
5325 count = 0;
5326 }
5327
5328 wined3d_mutex_lock();
5329 wined3d_device_apply_stateblock(device->wined3d_device, device->state);
5330 d3d_device_sync_rendertarget(device);
5331 hr = wined3d_device_clear(device->wined3d_device, count, (RECT *)rects, flags, &c, z, stencil);
5332 wined3d_mutex_unlock();
5333
5334 return hr;
5335 }
5336
5337 static HRESULT WINAPI d3d_device7_Clear_FPUSetup(IDirect3DDevice7 *iface, DWORD count,
5338 D3DRECT *rects, DWORD flags, D3DCOLOR color, D3DVALUE z, DWORD stencil)
5339 {
5340 return d3d_device7_Clear(iface, count, rects, flags, color, z, stencil);
5341 }
5342
5343 static HRESULT WINAPI d3d_device7_Clear_FPUPreserve(IDirect3DDevice7 *iface, DWORD count,
5344 D3DRECT *rects, DWORD flags, D3DCOLOR color, D3DVALUE z, DWORD stencil)
5345 {
5346 HRESULT hr;
5347 WORD old_fpucw;
5348
5349 old_fpucw = d3d_fpu_setup();
5350 hr = d3d_device7_Clear(iface, count, rects, flags, color, z, stencil);
5351 set_fpu_control_word(old_fpucw);
5352
5353 return hr;
5354 }
5355
5356 static HRESULT d3d_device7_SetViewport(IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
5357 {
5358 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5359 struct wined3d_sub_resource_desc rt_desc;
5360 struct wined3d_rendertarget_view *rtv;
5361 struct ddraw_surface *surface;
5362 struct wined3d_viewport vp;
5363
5364 TRACE("iface %p, viewport %p.\n", iface, viewport);
5365
5366 if (!viewport)
5367 return DDERR_INVALIDPARAMS;
5368
5369 wined3d_mutex_lock();
5370 if (!(rtv = wined3d_device_context_get_rendertarget_view(device->immediate_context, 0)))
5371 {
5372 wined3d_mutex_unlock();
5373 return DDERR_INVALIDCAPS;
5374 }
5375 surface = wined3d_rendertarget_view_get_sub_resource_parent(rtv);
5376 wined3d_texture_get_sub_resource_desc(surface->wined3d_texture, surface->sub_resource_idx, &rt_desc);
5377
5378 if (!wined3d_bound_range(viewport->dwX, viewport->dwWidth, rt_desc.width)
5379 || !wined3d_bound_range(viewport->dwY, viewport->dwHeight, rt_desc.height))
5380 {
5381 WARN("Invalid viewport, returning E_INVALIDARG.\n");
5382 wined3d_mutex_unlock();
5383 return E_INVALIDARG;
5384 }
5385
5386 vp.x = viewport->dwX;
5387 vp.y = viewport->dwY;
5388 vp.width = viewport->dwWidth;
5389 vp.height = viewport->dwHeight;
5390 vp.min_z = viewport->dvMinZ;
5391 vp.max_z = viewport->dvMaxZ;
5392
5393 wined3d_stateblock_set_viewport(device->update_state, &vp);
5394 wined3d_mutex_unlock();
5395
5396 return D3D_OK;
5397 }
5398
5399 static HRESULT WINAPI d3d_device7_SetViewport_FPUSetup(IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
5400 {
5401 return d3d_device7_SetViewport(iface, viewport);
5402 }
5403
5404 static HRESULT WINAPI d3d_device7_SetViewport_FPUPreserve(IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
5405 {
5406 HRESULT hr;
5407 WORD old_fpucw;
5408
5409 old_fpucw = d3d_fpu_setup();
5410 hr = d3d_device7_SetViewport(iface, viewport);
5411 set_fpu_control_word(old_fpucw);
5412
5413 return hr;
5414 }
5415
5416 static HRESULT d3d_device7_GetViewport(IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
5417 {
5418 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5419 struct wined3d_viewport wined3d_viewport;
5420
5421 TRACE("iface %p, viewport %p.\n", iface, viewport);
5422
5423 if (!viewport)
5424 return DDERR_INVALIDPARAMS;
5425
5426 wined3d_mutex_lock();
5427 wined3d_viewport = device->stateblock_state->viewport;
5428 wined3d_mutex_unlock();
5429
5430 viewport->dwX = wined3d_viewport.x;
5431 viewport->dwY = wined3d_viewport.y;
5432 viewport->dwWidth = wined3d_viewport.width;
5433 viewport->dwHeight = wined3d_viewport.height;
5434 viewport->dvMinZ = wined3d_viewport.min_z;
5435 viewport->dvMaxZ = wined3d_viewport.max_z;
5436
5437 return D3D_OK;
5438 }
5439
5440 static HRESULT WINAPI d3d_device7_GetViewport_FPUSetup(IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
5441 {
5442 return d3d_device7_GetViewport(iface, viewport);
5443 }
5444
5445 static HRESULT WINAPI d3d_device7_GetViewport_FPUPreserve(IDirect3DDevice7 *iface, D3DVIEWPORT7 *viewport)
5446 {
5447 HRESULT hr;
5448 WORD old_fpucw;
5449
5450 old_fpucw = d3d_fpu_setup();
5451 hr = d3d_device7_GetViewport(iface, viewport);
5452 set_fpu_control_word(old_fpucw);
5453
5454 return hr;
5455 }
5456
5457 /*****************************************************************************
5458 * IDirect3DDevice7::SetMaterial
5459 *
5460 * Sets the Material
5461 *
5462 * Version 7
5463 *
5464 * Params:
5465 * Mat: The material to set
5466 *
5467 * Returns:
5468 * D3D_OK on success
5469 * DDERR_INVALIDPARAMS if Mat is NULL.
5470 *
5471 *****************************************************************************/
5472 static HRESULT d3d_device7_SetMaterial(IDirect3DDevice7 *iface, D3DMATERIAL7 *material)
5473 {
5474 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5475
5476 TRACE("iface %p, material %p.\n", iface, material);
5477
5478 if (!material)
5479 return DDERR_INVALIDPARAMS;
5480
5481 wined3d_mutex_lock();
5482 /* Note: D3DMATERIAL7 is compatible with struct wined3d_material. */
5483 wined3d_stateblock_set_material(device->update_state, (const struct wined3d_material *)material);
5484 wined3d_mutex_unlock();
5485
5486 return D3D_OK;
5487 }
5488
5489 static HRESULT WINAPI d3d_device7_SetMaterial_FPUSetup(IDirect3DDevice7 *iface, D3DMATERIAL7 *material)
5490 {
5491 return d3d_device7_SetMaterial(iface, material);
5492 }
5493
5494 static HRESULT WINAPI d3d_device7_SetMaterial_FPUPreserve(IDirect3DDevice7 *iface, D3DMATERIAL7 *material)
5495 {
5496 HRESULT hr;
5497 WORD old_fpucw;
5498
5499 old_fpucw = d3d_fpu_setup();
5500 hr = d3d_device7_SetMaterial(iface, material);
5501 set_fpu_control_word(old_fpucw);
5502
5503 return hr;
5504 }
5505
5506 /*****************************************************************************
5507 * IDirect3DDevice7::GetMaterial
5508 *
5509 * Returns the current material
5510 *
5511 * Version 7
5512 *
5513 * Params:
5514 * Mat: D3DMATERIAL7 structure to write the material parameters to
5515 *
5516 * Returns:
5517 * D3D_OK on success
5518 * DDERR_INVALIDPARAMS if Mat is NULL
5519 *
5520 *****************************************************************************/
5521 static HRESULT d3d_device7_GetMaterial(IDirect3DDevice7 *iface, D3DMATERIAL7 *material)
5522 {
5523 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5524
5525 TRACE("iface %p, material %p.\n", iface, material);
5526
5527 wined3d_mutex_lock();
5528 /* Note: D3DMATERIAL7 is compatible with struct wined3d_material. */
5529 memcpy(material, &device->stateblock_state->material, sizeof(*material));
5530 wined3d_mutex_unlock();
5531
5532 return D3D_OK;
5533 }
5534
5535 static HRESULT WINAPI d3d_device7_GetMaterial_FPUSetup(IDirect3DDevice7 *iface, D3DMATERIAL7 *material)
5536 {
5537 return d3d_device7_GetMaterial(iface, material);
5538 }
5539
5540 static HRESULT WINAPI d3d_device7_GetMaterial_FPUPreserve(IDirect3DDevice7 *iface, D3DMATERIAL7 *material)
5541 {
5542 HRESULT hr;
5543 WORD old_fpucw;
5544
5545 old_fpucw = d3d_fpu_setup();
5546 hr = d3d_device7_GetMaterial(iface, material);
5547 set_fpu_control_word(old_fpucw);
5548
5549 return hr;
5550 }
5551
5552 /*****************************************************************************
5553 * IDirect3DDevice7::SetLight
5554 *
5555 * Assigns a light to a light index, but doesn't activate it yet.
5556 *
5557 * Version 7, IDirect3DLight uses this method for older versions
5558 *
5559 * Params:
5560 * LightIndex: The index of the new light
5561 * Light: A D3DLIGHT7 structure describing the light
5562 *
5563 * Returns:
5564 * D3D_OK on success
5565 *
5566 *****************************************************************************/
5567 static HRESULT d3d_device7_SetLight(IDirect3DDevice7 *iface, DWORD light_idx, D3DLIGHT7 *light)
5568 {
5569 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5570 HRESULT hr;
5571
5572 TRACE("iface %p, light_idx %u, light %p.\n", iface, light_idx, light);
5573
5574 wined3d_mutex_lock();
5575 /* Note: D3DLIGHT7 is compatible with struct wined3d_light. */
5576 hr = wined3d_stateblock_set_light(device->update_state, light_idx, (const struct wined3d_light *)light);
5577 wined3d_mutex_unlock();
5578
5579 return hr_ddraw_from_wined3d(hr);
5580 }
5581
5582 static HRESULT WINAPI d3d_device7_SetLight_FPUSetup(IDirect3DDevice7 *iface, DWORD light_idx, D3DLIGHT7 *light)
5583 {
5584 return d3d_device7_SetLight(iface, light_idx, light);
5585 }
5586
5587 static HRESULT WINAPI d3d_device7_SetLight_FPUPreserve(IDirect3DDevice7 *iface, DWORD light_idx, D3DLIGHT7 *light)
5588 {
5589 HRESULT hr;
5590 WORD old_fpucw;
5591
5592 old_fpucw = d3d_fpu_setup();
5593 hr = d3d_device7_SetLight(iface, light_idx, light);
5594 set_fpu_control_word(old_fpucw);
5595
5596 return hr;
5597 }
5598
5599 /*****************************************************************************
5600 * IDirect3DDevice7::GetLight
5601 *
5602 * Returns the light assigned to a light index
5603 *
5604 * Params:
5605 * Light: Structure to write the light information to
5606 *
5607 * Returns:
5608 * D3D_OK on success
5609 * DDERR_INVALIDPARAMS if Light is NULL
5610 *
5611 *****************************************************************************/
5612 static HRESULT d3d_device7_GetLight(IDirect3DDevice7 *iface, DWORD light_idx, D3DLIGHT7 *light)
5613 {
5614 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5615 BOOL enabled;
5616 HRESULT hr;
5617
5618 TRACE("iface %p, light_idx %u, light %p.\n", iface, light_idx, light);
5619
5620 wined3d_mutex_lock();
5621 /* Note: D3DLIGHT7 is compatible with struct wined3d_light. */
5622 hr = wined3d_stateblock_get_light(device->state, light_idx, (struct wined3d_light *)light, &enabled);
5623 wined3d_mutex_unlock();
5624
5625 return hr_ddraw_from_wined3d(hr);
5626 }
5627
5628 static HRESULT WINAPI d3d_device7_GetLight_FPUSetup(IDirect3DDevice7 *iface, DWORD light_idx, D3DLIGHT7 *light)
5629 {
5630 return d3d_device7_GetLight(iface, light_idx, light);
5631 }
5632
5633 static HRESULT WINAPI d3d_device7_GetLight_FPUPreserve(IDirect3DDevice7 *iface, DWORD light_idx, D3DLIGHT7 *light)
5634 {
5635 HRESULT hr;
5636 WORD old_fpucw;
5637
5638 old_fpucw = d3d_fpu_setup();
5639 hr = d3d_device7_GetLight(iface, light_idx, light);
5640 set_fpu_control_word(old_fpucw);
5641
5642 return hr;
5643 }
5644
5645 /*****************************************************************************
5646 * IDirect3DDevice7::BeginStateBlock
5647 *
5648 * Begins recording to a stateblock
5649 *
5650 * Version 7
5651 *
5652 * Returns:
5653 * D3D_OK on success
5654 *
5655 *****************************************************************************/
5656 static HRESULT d3d_device7_BeginStateBlock(IDirect3DDevice7 *iface)
5657 {
5658 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5659 struct wined3d_stateblock *stateblock;
5660 HRESULT hr;
5661
5662 TRACE("iface %p.\n", iface);
5663
5664 wined3d_mutex_lock();
5665 if (device->recording)
5666 {
5667 wined3d_mutex_unlock();
5668 WARN("Trying to begin a stateblock while recording, returning D3DERR_INBEGINSTATEBLOCK.\n");
5669 return D3DERR_INBEGINSTATEBLOCK;
5670 }
5671 if (SUCCEEDED(hr = wined3d_stateblock_create(device->wined3d_device, NULL, WINED3D_SBT_RECORDED, &stateblock)))
5672 device->update_state = device->recording = stateblock;
5673 wined3d_mutex_unlock();
5674
5675 return hr_ddraw_from_wined3d(hr);
5676 }
5677
5678 static HRESULT WINAPI d3d_device7_BeginStateBlock_FPUSetup(IDirect3DDevice7 *iface)
5679 {
5680 return d3d_device7_BeginStateBlock(iface);
5681 }
5682
5683 static HRESULT WINAPI d3d_device7_BeginStateBlock_FPUPreserve(IDirect3DDevice7 *iface)
5684 {
5685 HRESULT hr;
5686 WORD old_fpucw;
5687
5688 old_fpucw = d3d_fpu_setup();
5689 hr = d3d_device7_BeginStateBlock(iface);
5690 set_fpu_control_word(old_fpucw);
5691
5692 return hr;
5693 }
5694
5695 /*****************************************************************************
5696 * IDirect3DDevice7::EndStateBlock
5697 *
5698 * Stops recording to a state block and returns the created stateblock
5699 * handle.
5700 *
5701 * Version 7
5702 *
5703 * Params:
5704 * BlockHandle: Address to store the stateblock's handle to
5705 *
5706 * Returns:
5707 * D3D_OK on success
5708 * DDERR_INVALIDPARAMS if BlockHandle is NULL
5709 *
5710 *****************************************************************************/
5711 static HRESULT d3d_device7_EndStateBlock(IDirect3DDevice7 *iface, DWORD *stateblock)
5712 {
5713 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5714 struct wined3d_stateblock *wined3d_sb;
5715 DWORD h;
5716
5717 TRACE("iface %p, stateblock %p.\n", iface, stateblock);
5718
5719 if (!stateblock)
5720 return DDERR_INVALIDPARAMS;
5721
5722 wined3d_mutex_lock();
5723 if (!device->recording)
5724 {
5725 wined3d_mutex_unlock();
5726 WARN("Trying to end a stateblock, but no stateblock is being recorded.\n");
5727 return D3DERR_NOTINBEGINSTATEBLOCK;
5728 }
5729 wined3d_sb = device->recording;
5730 wined3d_stateblock_init_contained_states(wined3d_sb);
5731 device->recording = NULL;
5732 device->update_state = device->state;
5733
5734 h = ddraw_allocate_handle(&device->handle_table, wined3d_sb, DDRAW_HANDLE_STATEBLOCK);
5735 if (h == DDRAW_INVALID_HANDLE)
5736 {
5737 ERR("Failed to allocate a stateblock handle.\n");
5738 wined3d_stateblock_decref(wined3d_sb);
5739 wined3d_mutex_unlock();
5740 *stateblock = 0;
5741 return DDERR_OUTOFMEMORY;
5742 }
5743
5744 wined3d_mutex_unlock();
5745 *stateblock = h + 1;
5746
5747 return D3D_OK;
5748 }
5749
5750 static HRESULT WINAPI d3d_device7_EndStateBlock_FPUSetup(IDirect3DDevice7 *iface, DWORD *stateblock)
5751 {
5752 return d3d_device7_EndStateBlock(iface, stateblock);
5753 }
5754
5755 static HRESULT WINAPI d3d_device7_EndStateBlock_FPUPreserve(IDirect3DDevice7 *iface, DWORD *stateblock)
5756 {
5757 HRESULT hr;
5758 WORD old_fpucw;
5759
5760 old_fpucw = d3d_fpu_setup();
5761 hr = d3d_device7_EndStateBlock(iface, stateblock);
5762 set_fpu_control_word(old_fpucw);
5763
5764 return hr;
5765 }
5766
5767 /*****************************************************************************
5768 * IDirect3DDevice7::PreLoad
5769 *
5770 * Allows the app to signal that a texture will be used soon, to allow
5771 * the Direct3DDevice to load it to the video card in the meantime.
5772 *
5773 * Version 7
5774 *
5775 * Params:
5776 * Texture: The texture to preload
5777 *
5778 * Returns:
5779 * D3D_OK on success
5780 * DDERR_INVALIDPARAMS if Texture is NULL
5781 *
5782 *****************************************************************************/
5783 static HRESULT d3d_device7_PreLoad(IDirect3DDevice7 *iface, IDirectDrawSurface7 *texture)
5784 {
5785 struct ddraw_surface *surface = unsafe_impl_from_IDirectDrawSurface7(texture);
5786
5787 TRACE("iface %p, texture %p.\n", iface, texture);
5788
5789 if (!texture)
5790 return DDERR_INVALIDPARAMS;
5791
5792 wined3d_mutex_lock();
5793 wined3d_resource_preload(wined3d_texture_get_resource(surface->draw_texture ? surface->draw_texture
5794 : surface->wined3d_texture));
5795 wined3d_mutex_unlock();
5796
5797 return D3D_OK;
5798 }
5799
5800 static HRESULT WINAPI d3d_device7_PreLoad_FPUSetup(IDirect3DDevice7 *iface, IDirectDrawSurface7 *texture)
5801 {
5802 return d3d_device7_PreLoad(iface, texture);
5803 }
5804
5805 static HRESULT WINAPI d3d_device7_PreLoad_FPUPreserve(IDirect3DDevice7 *iface, IDirectDrawSurface7 *texture)
5806 {
5807 HRESULT hr;
5808 WORD old_fpucw;
5809
5810 old_fpucw = d3d_fpu_setup();
5811 hr = d3d_device7_PreLoad(iface, texture);
5812 set_fpu_control_word(old_fpucw);
5813
5814 return hr;
5815 }
5816
5817 /*****************************************************************************
5818 * IDirect3DDevice7::ApplyStateBlock
5819 *
5820 * Activates the state stored in a state block handle.
5821 *
5822 * Params:
5823 * BlockHandle: The stateblock handle to activate
5824 *
5825 * Returns:
5826 * D3D_OK on success
5827 * D3DERR_INVALIDSTATEBLOCK if BlockHandle is NULL
5828 *
5829 *****************************************************************************/
5830 static HRESULT d3d_device7_ApplyStateBlock(IDirect3DDevice7 *iface, DWORD stateblock)
5831 {
5832 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5833 struct wined3d_stateblock *wined3d_sb;
5834
5835 TRACE("iface %p, stateblock %#x.\n", iface, stateblock);
5836
5837 wined3d_mutex_lock();
5838 if (device->recording)
5839 {
5840 wined3d_mutex_unlock();
5841 WARN("Trying to apply a stateblock while recording, returning D3DERR_INBEGINSTATEBLOCK.\n");
5842 return D3DERR_INBEGINSTATEBLOCK;
5843 }
5844 wined3d_sb = ddraw_get_object(&device->handle_table, stateblock - 1, DDRAW_HANDLE_STATEBLOCK);
5845 if (!wined3d_sb)
5846 {
5847 WARN("Invalid stateblock handle.\n");
5848 wined3d_mutex_unlock();
5849 return D3DERR_INVALIDSTATEBLOCK;
5850 }
5851
5852 wined3d_stateblock_apply(wined3d_sb, device->state);
5853 wined3d_mutex_unlock();
5854
5855 return D3D_OK;
5856 }
5857
5858 static HRESULT WINAPI d3d_device7_ApplyStateBlock_FPUSetup(IDirect3DDevice7 *iface, DWORD stateblock)
5859 {
5860 return d3d_device7_ApplyStateBlock(iface, stateblock);
5861 }
5862
5863 static HRESULT WINAPI d3d_device7_ApplyStateBlock_FPUPreserve(IDirect3DDevice7 *iface, DWORD stateblock)
5864 {
5865 HRESULT hr;
5866 WORD old_fpucw;
5867
5868 old_fpucw = d3d_fpu_setup();
5869 hr = d3d_device7_ApplyStateBlock(iface, stateblock);
5870 set_fpu_control_word(old_fpucw);
5871
5872 return hr;
5873 }
5874
5875 /*****************************************************************************
5876 * IDirect3DDevice7::CaptureStateBlock
5877 *
5878 * Updates a stateblock's values to the values currently set for the device
5879 *
5880 * Version 7
5881 *
5882 * Params:
5883 * BlockHandle: Stateblock to update
5884 *
5885 * Returns:
5886 * D3D_OK on success
5887 * D3DERR_INVALIDSTATEBLOCK if BlockHandle is NULL
5888 *
5889 *****************************************************************************/
5890 static HRESULT d3d_device7_CaptureStateBlock(IDirect3DDevice7 *iface, DWORD stateblock)
5891 {
5892 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5893 struct wined3d_stateblock *wined3d_sb;
5894
5895 TRACE("iface %p, stateblock %#x.\n", iface, stateblock);
5896
5897 wined3d_mutex_lock();
5898 if (device->recording)
5899 {
5900 wined3d_mutex_unlock();
5901 WARN("Trying to capture a stateblock while recording, returning D3DERR_INBEGINSTATEBLOCK.\n");
5902 return D3DERR_INBEGINSTATEBLOCK;
5903 }
5904 wined3d_sb = ddraw_get_object(&device->handle_table, stateblock - 1, DDRAW_HANDLE_STATEBLOCK);
5905 if (!wined3d_sb)
5906 {
5907 WARN("Invalid stateblock handle.\n");
5908 wined3d_mutex_unlock();
5909 return D3DERR_INVALIDSTATEBLOCK;
5910 }
5911
5912 wined3d_stateblock_capture(wined3d_sb, device->state);
5913 wined3d_mutex_unlock();
5914
5915 return D3D_OK;
5916 }
5917
5918 static HRESULT WINAPI d3d_device7_CaptureStateBlock_FPUSetup(IDirect3DDevice7 *iface, DWORD stateblock)
5919 {
5920 return d3d_device7_CaptureStateBlock(iface, stateblock);
5921 }
5922
5923 static HRESULT WINAPI d3d_device7_CaptureStateBlock_FPUPreserve(IDirect3DDevice7 *iface, DWORD stateblock)
5924 {
5925 HRESULT hr;
5926 WORD old_fpucw;
5927
5928 old_fpucw = d3d_fpu_setup();
5929 hr = d3d_device7_CaptureStateBlock(iface, stateblock);
5930 set_fpu_control_word(old_fpucw);
5931
5932 return hr;
5933 }
5934
5935 /*****************************************************************************
5936 * IDirect3DDevice7::DeleteStateBlock
5937 *
5938 * Deletes a stateblock handle. This means releasing the WineD3DStateBlock
5939 *
5940 * Version 7
5941 *
5942 * Params:
5943 * BlockHandle: Stateblock handle to delete
5944 *
5945 * Returns:
5946 * D3D_OK on success
5947 * D3DERR_INVALIDSTATEBLOCK if BlockHandle is 0
5948 *
5949 *****************************************************************************/
5950 static HRESULT d3d_device7_DeleteStateBlock(IDirect3DDevice7 *iface, DWORD stateblock)
5951 {
5952 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
5953 struct wined3d_stateblock *wined3d_sb;
5954 ULONG ref;
5955
5956 TRACE("iface %p, stateblock %#x.\n", iface, stateblock);
5957
5958 wined3d_mutex_lock();
5959
5960 wined3d_sb = ddraw_free_handle(&device->handle_table, stateblock - 1, DDRAW_HANDLE_STATEBLOCK);
5961 if (!wined3d_sb)
5962 {
5963 WARN("Invalid stateblock handle.\n");
5964 wined3d_mutex_unlock();
5965 return D3DERR_INVALIDSTATEBLOCK;
5966 }
5967
5968 if ((ref = wined3d_stateblock_decref(wined3d_sb)))
5969 {
5970 ERR("Something is still holding stateblock %p (refcount %u).\n", wined3d_sb, ref);
5971 }
5972
5973 wined3d_mutex_unlock();
5974
5975 return D3D_OK;
5976 }
5977
5978 static HRESULT WINAPI d3d_device7_DeleteStateBlock_FPUSetup(IDirect3DDevice7 *iface, DWORD stateblock)
5979 {
5980 return d3d_device7_DeleteStateBlock(iface, stateblock);
5981 }
5982
5983 static HRESULT WINAPI d3d_device7_DeleteStateBlock_FPUPreserve(IDirect3DDevice7 *iface, DWORD stateblock)
5984 {
5985 HRESULT hr;
5986 WORD old_fpucw;
5987
5988 old_fpucw = d3d_fpu_setup();
5989 hr = d3d_device7_DeleteStateBlock(iface, stateblock);
5990 set_fpu_control_word(old_fpucw);
5991
5992 return hr;
5993 }
5994
5995 /*****************************************************************************
5996 * IDirect3DDevice7::CreateStateBlock
5997 *
5998 * Creates a new state block handle.
5999 *
6000 * Version 7
6001 *
6002 * Params:
6003 * Type: The state block type
6004 * BlockHandle: Address to write the created handle to
6005 *
6006 * Returns:
6007 * D3D_OK on success
6008 * DDERR_INVALIDPARAMS if BlockHandle is NULL
6009 *
6010 *****************************************************************************/
6011 static HRESULT d3d_device7_CreateStateBlock(IDirect3DDevice7 *iface,
6012 D3DSTATEBLOCKTYPE type, DWORD *stateblock)
6013 {
6014 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
6015 struct wined3d_stateblock *wined3d_sb;
6016 HRESULT hr;
6017 DWORD h;
6018
6019 TRACE("iface %p, type %#x, stateblock %p.\n", iface, type, stateblock);
6020
6021 if (!stateblock)
6022 return DDERR_INVALIDPARAMS;
6023
6024 if (type != D3DSBT_ALL
6025 && type != D3DSBT_PIXELSTATE
6026 && type != D3DSBT_VERTEXSTATE)
6027 {
6028 WARN("Unexpected stateblock type, returning DDERR_INVALIDPARAMS\n");
6029 return DDERR_INVALIDPARAMS;
6030 }
6031
6032 wined3d_mutex_lock();
6033
6034 if (device->recording)
6035 {
6036 wined3d_mutex_unlock();
6037 WARN("Trying to apply a stateblock while recording, returning D3DERR_INBEGINSTATEBLOCK.\n");
6038 return D3DERR_INBEGINSTATEBLOCK;
6039 }
6040
6041 if (FAILED(hr = wined3d_stateblock_create(device->wined3d_device,
6042 device->state, wined3d_stateblock_type_from_ddraw(type), &wined3d_sb)))
6043 {
6044 WARN("Failed to create stateblock, hr %#x.\n", hr);
6045 wined3d_mutex_unlock();
6046 return hr_ddraw_from_wined3d(hr);
6047 }
6048
6049 h = ddraw_allocate_handle(&device->handle_table, wined3d_sb, DDRAW_HANDLE_STATEBLOCK);
6050 if (h == DDRAW_INVALID_HANDLE)
6051 {
6052 ERR("Failed to allocate stateblock handle.\n");
6053 wined3d_stateblock_decref(wined3d_sb);
6054 wined3d_mutex_unlock();
6055 return DDERR_OUTOFMEMORY;
6056 }
6057
6058 *stateblock = h + 1;
6059 wined3d_mutex_unlock();
6060
6061 return hr_ddraw_from_wined3d(hr);
6062 }
6063
6064 static HRESULT WINAPI d3d_device7_CreateStateBlock_FPUSetup(IDirect3DDevice7 *iface,
6065 D3DSTATEBLOCKTYPE type, DWORD *stateblock)
6066 {
6067 return d3d_device7_CreateStateBlock(iface, type, stateblock);
6068 }
6069
6070 static HRESULT WINAPI d3d_device7_CreateStateBlock_FPUPreserve(IDirect3DDevice7 *iface,
6071 D3DSTATEBLOCKTYPE type, DWORD *stateblock)
6072 {
6073 HRESULT hr;
6074 WORD old_fpucw;
6075
6076 old_fpucw = d3d_fpu_setup();
6077 hr = d3d_device7_CreateStateBlock(iface, type, stateblock);
6078 set_fpu_control_word(old_fpucw);
6079
6080 return hr;
6081 }
6082
6083 static BOOL is_mip_level_subset(struct ddraw_surface *dest, struct ddraw_surface *src)
6084 {
6085 struct ddraw_surface *src_level, *dest_level;
6086 IDirectDrawSurface7 *temp;
6087 DDSURFACEDESC2 ddsd;
6088 BOOL levelFound; /* at least one suitable sublevel in dest found */
6089
6090 /* To satisfy "destination is mip level subset of source" criteria (regular texture counts as 1 level),
6091 * 1) there must be at least one mip level in destination that matched dimensions of some mip level in source and
6092 * 2) there must be no destination levels that don't match any levels in source. Otherwise it's INVALIDPARAMS.
6093 */
6094 levelFound = FALSE;
6095
6096 src_level = src;
6097 dest_level = dest;
6098
6099 for (;src_level && dest_level;)
6100 {
6101 if (src_level->surface_desc.dwWidth == dest_level->surface_desc.dwWidth &&
6102 src_level->surface_desc.dwHeight == dest_level->surface_desc.dwHeight)
6103 {
6104 levelFound = TRUE;
6105
6106 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
6107 ddsd.ddsCaps.dwCaps2 = DDSCAPS2_MIPMAPSUBLEVEL;
6108 IDirectDrawSurface7_GetAttachedSurface(&dest_level->IDirectDrawSurface7_iface, &ddsd.ddsCaps, &temp);
6109
6110 if (dest_level != dest) IDirectDrawSurface7_Release(&dest_level->IDirectDrawSurface7_iface);
6111
6112 dest_level = unsafe_impl_from_IDirectDrawSurface7(temp);
6113 }
6114
6115 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
6116 ddsd.ddsCaps.dwCaps2 = DDSCAPS2_MIPMAPSUBLEVEL;
6117 IDirectDrawSurface7_GetAttachedSurface(&src_level->IDirectDrawSurface7_iface, &ddsd.ddsCaps, &temp);
6118
6119 if (src_level != src) IDirectDrawSurface7_Release(&src_level->IDirectDrawSurface7_iface);
6120
6121 src_level = unsafe_impl_from_IDirectDrawSurface7(temp);
6122 }
6123
6124 if (src_level && src_level != src) IDirectDrawSurface7_Release(&src_level->IDirectDrawSurface7_iface);
6125 if (dest_level && dest_level != dest) IDirectDrawSurface7_Release(&dest_level->IDirectDrawSurface7_iface);
6126
6127 return !dest_level && levelFound;
6128 }
6129
6130 static void copy_mipmap_chain(struct d3d_device *device, struct ddraw_surface *dst,
6131 struct ddraw_surface *src, const POINT *DestPoint, const RECT *SrcRect)
6132 {
6133 struct ddraw_surface *dst_level, *src_level;
6134 IDirectDrawSurface7 *temp;
6135 DDSURFACEDESC2 ddsd;
6136 POINT point;
6137 RECT src_rect;
6138 HRESULT hr;
6139 IDirectDrawPalette *pal = NULL, *pal_src = NULL;
6140 DWORD ckeyflag;
6141 DDCOLORKEY ddckey;
6142
6143 /* Copy palette, if possible. */
6144 IDirectDrawSurface7_GetPalette(&src->IDirectDrawSurface7_iface, &pal_src);
6145 IDirectDrawSurface7_GetPalette(&dst->IDirectDrawSurface7_iface, &pal);
6146
6147 if (pal_src != NULL && pal != NULL)
6148 {
6149 PALETTEENTRY palent[256];
6150
6151 IDirectDrawPalette_GetEntries(pal_src, 0, 0, 256, palent);
6152 IDirectDrawPalette_SetEntries(pal, 0, 0, 256, palent);
6153 }
6154
6155 if (pal) IDirectDrawPalette_Release(pal);
6156 if (pal_src) IDirectDrawPalette_Release(pal_src);
6157
6158 /* Copy colorkeys, if present. */
6159 for (ckeyflag = DDCKEY_DESTBLT; ckeyflag <= DDCKEY_SRCOVERLAY; ckeyflag <<= 1)
6160 {
6161 hr = IDirectDrawSurface7_GetColorKey(&src->IDirectDrawSurface7_iface, ckeyflag, &ddckey);
6162
6163 if (SUCCEEDED(hr))
6164 {
6165 IDirectDrawSurface7_SetColorKey(&dst->IDirectDrawSurface7_iface, ckeyflag, &ddckey);
6166 }
6167 }
6168
6169 src_level = src;
6170 dst_level = dst;
6171
6172 point = *DestPoint;
6173 src_rect = *SrcRect;
6174
6175 for (;src_level && dst_level;)
6176 {
6177 if (src_level->surface_desc.dwWidth == dst_level->surface_desc.dwWidth
6178 && src_level->surface_desc.dwHeight == dst_level->surface_desc.dwHeight)
6179 {
6180 UINT src_w = src_rect.right - src_rect.left;
6181 UINT src_h = src_rect.bottom - src_rect.top;
6182 RECT dst_rect = {point.x, point.y, point.x + src_w, point.y + src_h};
6183
6184 if (FAILED(hr = wined3d_device_context_blt(device->immediate_context,
6185 ddraw_surface_get_any_texture(dst_level, DDRAW_SURFACE_RW), dst_level->sub_resource_idx, &dst_rect,
6186 ddraw_surface_get_any_texture(src_level, DDRAW_SURFACE_READ),
6187 src_level->sub_resource_idx, &src_rect, 0, NULL, WINED3D_TEXF_POINT)))
6188 ERR("Blit failed, hr %#x.\n", hr);
6189
6190 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
6191 ddsd.ddsCaps.dwCaps2 = DDSCAPS2_MIPMAPSUBLEVEL;
6192 IDirectDrawSurface7_GetAttachedSurface(&dst_level->IDirectDrawSurface7_iface, &ddsd.ddsCaps, &temp);
6193
6194 if (dst_level != dst)
6195 IDirectDrawSurface7_Release(&dst_level->IDirectDrawSurface7_iface);
6196
6197 dst_level = unsafe_impl_from_IDirectDrawSurface7(temp);
6198 }
6199
6200 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
6201 ddsd.ddsCaps.dwCaps2 = DDSCAPS2_MIPMAPSUBLEVEL;
6202 IDirectDrawSurface7_GetAttachedSurface(&src_level->IDirectDrawSurface7_iface, &ddsd.ddsCaps, &temp);
6203
6204 if (src_level != src) IDirectDrawSurface7_Release(&src_level->IDirectDrawSurface7_iface);
6205
6206 src_level = unsafe_impl_from_IDirectDrawSurface7(temp);
6207
6208 point.x /= 2;
6209 point.y /= 2;
6210
6211 src_rect.top /= 2;
6212 src_rect.left /= 2;
6213 src_rect.right = (src_rect.right + 1) / 2;
6214 src_rect.bottom = (src_rect.bottom + 1) / 2;
6215 }
6216
6217 if (src_level && src_level != src)
6218 IDirectDrawSurface7_Release(&src_level->IDirectDrawSurface7_iface);
6219 if (dst_level && dst_level != dst)
6220 IDirectDrawSurface7_Release(&dst_level->IDirectDrawSurface7_iface);
6221 }
6222
6223 /*****************************************************************************
6224 * IDirect3DDevice7::Load
6225 *
6226 * Loads a rectangular area from the source into the destination texture.
6227 * It can also copy the source to the faces of a cubic environment map
6228 *
6229 * Version 7
6230 *
6231 * Params:
6232 * DestTex: Destination texture
6233 * DestPoint: Point in the destination where the source image should be
6234 * written to
6235 * SrcTex: Source texture
6236 * SrcRect: Source rectangle
6237 * Flags: Cubemap faces to load (DDSCAPS2_CUBEMAP_ALLFACES, DDSCAPS2_CUBEMAP_POSITIVEX,
6238 * DDSCAPS2_CUBEMAP_NEGATIVEX, DDSCAPS2_CUBEMAP_POSITIVEY, DDSCAPS2_CUBEMAP_NEGATIVEY,
6239 * DDSCAPS2_CUBEMAP_POSITIVEZ, DDSCAPS2_CUBEMAP_NEGATIVEZ)
6240 *
6241 * Returns:
6242 * D3D_OK on success
6243 * DDERR_INVALIDPARAMS if dst_texture or src_texture is NULL, broken coordinates or anything unexpected.
6244 *
6245 *
6246 *****************************************************************************/
6247 static HRESULT d3d_device7_Load(IDirect3DDevice7 *iface, IDirectDrawSurface7 *dst_texture, POINT *dst_pos,
6248 IDirectDrawSurface7 *src_texture, RECT *src_rect, DWORD flags)
6249 {
6250 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
6251 struct ddraw_surface *dest = unsafe_impl_from_IDirectDrawSurface7(dst_texture);
6252 struct ddraw_surface *src = unsafe_impl_from_IDirectDrawSurface7(src_texture);
6253 POINT destpoint;
6254 RECT srcrect;
6255
6256 TRACE("iface %p, dst_texture %p, dst_pos %s, src_texture %p, src_rect %s, flags %#x.\n",
6257 iface, dst_texture, wine_dbgstr_point(dst_pos), src_texture, wine_dbgstr_rect(src_rect), flags);
6258
6259 if( (!src) || (!dest) )
6260 return DDERR_INVALIDPARAMS;
6261
6262 wined3d_mutex_lock();
6263
6264 if (!src_rect)
6265 SetRect(&srcrect, 0, 0, src->surface_desc.dwWidth, src->surface_desc.dwHeight);
6266 else
6267 srcrect = *src_rect;
6268
6269 if (!dst_pos)
6270 destpoint.x = destpoint.y = 0;
6271 else
6272 destpoint = *dst_pos;
6273
6274 /* Check bad dimensions. dst_pos is validated against src, not dest, because
6275 * destination can be a subset of mip levels, in which case actual coordinates used
6276 * for it may be divided. If any dimension of dest is larger than source, it can't be
6277 * mip level subset, so an error can be returned early.
6278 */
6279 if (IsRectEmpty(&srcrect) || srcrect.right > src->surface_desc.dwWidth ||
6280 srcrect.bottom > src->surface_desc.dwHeight ||
6281 destpoint.x + srcrect.right - srcrect.left > src->surface_desc.dwWidth ||
6282 destpoint.y + srcrect.bottom - srcrect.top > src->surface_desc.dwHeight ||
6283 dest->surface_desc.dwWidth > src->surface_desc.dwWidth ||
6284 dest->surface_desc.dwHeight > src->surface_desc.dwHeight)
6285 {
6286 wined3d_mutex_unlock();
6287 return DDERR_INVALIDPARAMS;
6288 }
6289
6290 /* Must be top level surfaces. */
6291 if (src->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_MIPMAPSUBLEVEL ||
6292 dest->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_MIPMAPSUBLEVEL)
6293 {
6294 wined3d_mutex_unlock();
6295 return DDERR_INVALIDPARAMS;
6296 }
6297
6298 if (src->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
6299 {
6300 struct ddraw_surface *src_face, *dest_face;
6301 DWORD src_face_flag, dest_face_flag;
6302 IDirectDrawSurface7 *temp;
6303 DDSURFACEDESC2 ddsd;
6304 int i;
6305
6306 if (!(dest->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP))
6307 {
6308 wined3d_mutex_unlock();
6309 return DDERR_INVALIDPARAMS;
6310 }
6311
6312 /* Iterate through cube faces 2 times. First time is just to check INVALIDPARAMS conditions, second
6313 * time it's actual surface loading. */
6314 for (i = 0; i < 2; i++)
6315 {
6316 dest_face = dest;
6317 src_face = src;
6318
6319 for (;dest_face && src_face;)
6320 {
6321 src_face_flag = src_face->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES;
6322 dest_face_flag = dest_face->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES;
6323
6324 if (src_face_flag == dest_face_flag)
6325 {
6326 if (i == 0)
6327 {
6328 /* Destination mip levels must be subset of source mip levels. */
6329 if (!is_mip_level_subset(dest_face, src_face))
6330 {
6331 wined3d_mutex_unlock();
6332 return DDERR_INVALIDPARAMS;
6333 }
6334 }
6335 else if (flags & dest_face_flag)
6336 {
6337 copy_mipmap_chain(device, dest_face, src_face, &destpoint, &srcrect);
6338 }
6339
6340 if (src_face_flag < DDSCAPS2_CUBEMAP_NEGATIVEZ)
6341 {
6342 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
6343 ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP | (src_face_flag << 1);
6344 IDirectDrawSurface7_GetAttachedSurface(&src->IDirectDrawSurface7_iface, &ddsd.ddsCaps, &temp);
6345
6346 if (src_face != src) IDirectDrawSurface7_Release(&src_face->IDirectDrawSurface7_iface);
6347
6348 src_face = unsafe_impl_from_IDirectDrawSurface7(temp);
6349 }
6350 else
6351 {
6352 if (src_face != src) IDirectDrawSurface7_Release(&src_face->IDirectDrawSurface7_iface);
6353
6354 src_face = NULL;
6355 }
6356 }
6357
6358 if (dest_face_flag < DDSCAPS2_CUBEMAP_NEGATIVEZ)
6359 {
6360 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
6361 ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP | (dest_face_flag << 1);
6362 IDirectDrawSurface7_GetAttachedSurface(&dest->IDirectDrawSurface7_iface, &ddsd.ddsCaps, &temp);
6363
6364 if (dest_face != dest) IDirectDrawSurface7_Release(&dest_face->IDirectDrawSurface7_iface);
6365
6366 dest_face = unsafe_impl_from_IDirectDrawSurface7(temp);
6367 }
6368 else
6369 {
6370 if (dest_face != dest) IDirectDrawSurface7_Release(&dest_face->IDirectDrawSurface7_iface);
6371
6372 dest_face = NULL;
6373 }
6374 }
6375
6376 if (i == 0)
6377 {
6378 /* Native returns error if src faces are not subset of dest faces. */
6379 if (src_face)
6380 {
6381 wined3d_mutex_unlock();
6382 return DDERR_INVALIDPARAMS;
6383 }
6384 }
6385 }
6386
6387 wined3d_mutex_unlock();
6388 return D3D_OK;
6389 }
6390 else if (dest->surface_desc.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
6391 {
6392 wined3d_mutex_unlock();
6393 return DDERR_INVALIDPARAMS;
6394 }
6395
6396 /* Handle non cube map textures. */
6397
6398 /* Destination mip levels must be subset of source mip levels. */
6399 if (!is_mip_level_subset(dest, src))
6400 {
6401 wined3d_mutex_unlock();
6402 return DDERR_INVALIDPARAMS;
6403 }
6404
6405 copy_mipmap_chain(device, dest, src, &destpoint, &srcrect);
6406
6407 wined3d_mutex_unlock();
6408
6409 return D3D_OK;
6410 }
6411
6412 static HRESULT WINAPI d3d_device7_Load_FPUSetup(IDirect3DDevice7 *iface, IDirectDrawSurface7 *dst_texture,
6413 POINT *dst_pos, IDirectDrawSurface7 *src_texture, RECT *src_rect, DWORD flags)
6414 {
6415 return d3d_device7_Load(iface, dst_texture, dst_pos, src_texture, src_rect, flags);
6416 }
6417
6418 static HRESULT WINAPI d3d_device7_Load_FPUPreserve(IDirect3DDevice7 *iface, IDirectDrawSurface7 *dst_texture,
6419 POINT *dst_pos, IDirectDrawSurface7 *src_texture, RECT *src_rect, DWORD flags)
6420 {
6421 HRESULT hr;
6422 WORD old_fpucw;
6423
6424 old_fpucw = d3d_fpu_setup();
6425 hr = d3d_device7_Load(iface, dst_texture, dst_pos, src_texture, src_rect, flags);
6426 set_fpu_control_word(old_fpucw);
6427
6428 return hr;
6429 }
6430
6431 /*****************************************************************************
6432 * IDirect3DDevice7::LightEnable
6433 *
6434 * Enables or disables a light
6435 *
6436 * Version 7, IDirect3DLight uses this method too.
6437 *
6438 * Params:
6439 * LightIndex: The index of the light to enable / disable
6440 * Enable: Enable or disable the light
6441 *
6442 * Returns:
6443 * D3D_OK on success
6444 *
6445 *****************************************************************************/
6446 static HRESULT d3d_device7_LightEnable(IDirect3DDevice7 *iface, DWORD light_idx, BOOL enabled)
6447 {
6448 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
6449 HRESULT hr;
6450
6451 TRACE("iface %p, light_idx %u, enabled %#x.\n", iface, light_idx, enabled);
6452
6453 wined3d_mutex_lock();
6454 hr = wined3d_stateblock_set_light_enable(device->update_state, light_idx, enabled);
6455 wined3d_mutex_unlock();
6456
6457 return hr_ddraw_from_wined3d(hr);
6458 }
6459
6460 static HRESULT WINAPI d3d_device7_LightEnable_FPUSetup(IDirect3DDevice7 *iface, DWORD light_idx, BOOL enabled)
6461 {
6462 return d3d_device7_LightEnable(iface, light_idx, enabled);
6463 }
6464
6465 static HRESULT WINAPI d3d_device7_LightEnable_FPUPreserve(IDirect3DDevice7 *iface, DWORD light_idx, BOOL enabled)
6466 {
6467 HRESULT hr;
6468 WORD old_fpucw;
6469
6470 old_fpucw = d3d_fpu_setup();
6471 hr = d3d_device7_LightEnable(iface, light_idx, enabled);
6472 set_fpu_control_word(old_fpucw);
6473
6474 return hr;
6475 }
6476
6477 /*****************************************************************************
6478 * IDirect3DDevice7::GetLightEnable
6479 *
6480 * Retrieves if the light with the given index is enabled or not
6481 *
6482 * Version 7
6483 *
6484 * Params:
6485 * LightIndex: Index of desired light
6486 * Enable: Pointer to a BOOL which contains the result
6487 *
6488 * Returns:
6489 * D3D_OK on success
6490 * DDERR_INVALIDPARAMS if Enable is NULL
6491 *
6492 *****************************************************************************/
6493 static HRESULT d3d_device7_GetLightEnable(IDirect3DDevice7 *iface, DWORD light_idx, BOOL *enabled)
6494 {
6495 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
6496 struct wined3d_light light;
6497 HRESULT hr;
6498
6499 TRACE("iface %p, light_idx %u, enabled %p.\n", iface, light_idx, enabled);
6500
6501 if (!enabled)
6502 return DDERR_INVALIDPARAMS;
6503
6504 wined3d_mutex_lock();
6505 hr = wined3d_stateblock_get_light(device->state, light_idx, &light, enabled);
6506 wined3d_mutex_unlock();
6507
6508 return hr_ddraw_from_wined3d(hr);
6509 }
6510
6511 static HRESULT WINAPI d3d_device7_GetLightEnable_FPUSetup(IDirect3DDevice7 *iface, DWORD light_idx, BOOL *enabled)
6512 {
6513 return d3d_device7_GetLightEnable(iface, light_idx, enabled);
6514 }
6515
6516 static HRESULT WINAPI d3d_device7_GetLightEnable_FPUPreserve(IDirect3DDevice7 *iface, DWORD light_idx, BOOL *enabled)
6517 {
6518 HRESULT hr;
6519 WORD old_fpucw;
6520
6521 old_fpucw = d3d_fpu_setup();
6522 hr = d3d_device7_GetLightEnable(iface, light_idx, enabled);
6523 set_fpu_control_word(old_fpucw);
6524
6525 return hr;
6526 }
6527
6528 /*****************************************************************************
6529 * IDirect3DDevice7::SetClipPlane
6530 *
6531 * Sets custom clipping plane
6532 *
6533 * Version 7
6534 *
6535 * Params:
6536 * Index: The index of the clipping plane
6537 * PlaneEquation: An equation defining the clipping plane
6538 *
6539 * Returns:
6540 * D3D_OK on success
6541 * DDERR_INVALIDPARAMS if PlaneEquation is NULL
6542 *
6543 *****************************************************************************/
6544 static HRESULT d3d_device7_SetClipPlane(IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
6545 {
6546 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
6547 const struct wined3d_vec4 *wined3d_plane;
6548 HRESULT hr;
6549
6550 TRACE("iface %p, idx %u, plane %p.\n", iface, idx, plane);
6551
6552 if (!plane)
6553 return DDERR_INVALIDPARAMS;
6554
6555 wined3d_plane = (struct wined3d_vec4 *)plane;
6556
6557 wined3d_mutex_lock();
6558 hr = wined3d_stateblock_set_clip_plane(device->update_state, idx, wined3d_plane);
6559 if (idx < ARRAY_SIZE(device->user_clip_planes))
6560 {
6561 device->user_clip_planes[idx] = *wined3d_plane;
6562 if (hr == WINED3DERR_INVALIDCALL)
6563 {
6564 WARN("Clip plane %u is not supported.\n", idx);
6565 hr = D3D_OK;
6566 }
6567 }
6568 wined3d_mutex_unlock();
6569
6570 return hr;
6571 }
6572
6573 static HRESULT WINAPI d3d_device7_SetClipPlane_FPUSetup(IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
6574 {
6575 return d3d_device7_SetClipPlane(iface, idx, plane);
6576 }
6577
6578 static HRESULT WINAPI d3d_device7_SetClipPlane_FPUPreserve(IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
6579 {
6580 HRESULT hr;
6581 WORD old_fpucw;
6582
6583 old_fpucw = d3d_fpu_setup();
6584 hr = d3d_device7_SetClipPlane(iface, idx, plane);
6585 set_fpu_control_word(old_fpucw);
6586
6587 return hr;
6588 }
6589
6590 /*****************************************************************************
6591 * IDirect3DDevice7::GetClipPlane
6592 *
6593 * Returns the clipping plane with a specific index
6594 *
6595 * Params:
6596 * Index: The index of the desired plane
6597 * PlaneEquation: Address to store the plane equation to
6598 *
6599 * Returns:
6600 * D3D_OK on success
6601 * DDERR_INVALIDPARAMS if PlaneEquation is NULL
6602 *
6603 *****************************************************************************/
6604 static HRESULT d3d_device7_GetClipPlane(IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
6605 {
6606 struct d3d_device *device = impl_from_IDirect3DDevice7(iface);
6607
6608 TRACE("iface %p, idx %u, plane %p.\n", iface, idx, plane);
6609
6610 if (!plane)
6611 return DDERR_INVALIDPARAMS;
6612
6613 wined3d_mutex_lock();
6614 if (idx < WINED3D_MAX_CLIP_DISTANCES)
6615 memcpy(plane, &device->stateblock_state->clip_planes[idx], sizeof(struct wined3d_vec4));
6616 else
6617 {
6618 WARN("Clip plane %u is not supported.\n", idx);
6619 if (idx < ARRAY_SIZE(device->user_clip_planes))
6620 memcpy(plane, &device->user_clip_planes[idx], sizeof(struct wined3d_vec4));
6621 }
6622 wined3d_mutex_unlock();
6623
6624 return D3D_OK;
6625 }
6626
6627 static HRESULT WINAPI d3d_device7_GetClipPlane_FPUSetup(IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
6628 {
6629 return d3d_device7_GetClipPlane(iface, idx, plane);
6630 }
6631
6632 static HRESULT WINAPI d3d_device7_GetClipPlane_FPUPreserve(IDirect3DDevice7 *iface, DWORD idx, D3DVALUE *plane)
6633 {
6634 HRESULT hr;
6635 WORD old_fpucw;
6636
6637 old_fpucw = d3d_fpu_setup();
6638 hr = d3d_device7_GetClipPlane(iface, idx, plane);
6639 set_fpu_control_word(old_fpucw);
6640
6641 return hr;
6642 }
6643
6644 /*****************************************************************************
6645 * IDirect3DDevice7::GetInfo
6646 *
6647 * Retrieves some information about the device. The DirectX sdk says that
6648 * this version returns S_FALSE for all retail builds of DirectX, that's what
6649 * this implementation does.
6650 *
6651 * Params:
6652 * DevInfoID: Information type requested
6653 * DevInfoStruct: Pointer to a structure to store the info to
6654 * Size: Size of the structure
6655 *
6656 * Returns:
6657 * S_FALSE, because it's a non-debug driver
6658 *
6659 *****************************************************************************/
6660 static HRESULT WINAPI d3d_device7_GetInfo(IDirect3DDevice7 *iface, DWORD info_id, void *info, DWORD info_size)
6661 {
6662 TRACE("iface %p, info_id %#x, info %p, info_size %u.\n",
6663 iface, info_id, info, info_size);
6664
6665 if (TRACE_ON(ddraw))
6666 {
6667 TRACE(" info requested : ");
6668 switch (info_id)
6669 {
6670 case D3DDEVINFOID_TEXTUREMANAGER: TRACE("D3DDEVINFOID_TEXTUREMANAGER\n"); break;
6671 case D3DDEVINFOID_D3DTEXTUREMANAGER: TRACE("D3DDEVINFOID_D3DTEXTUREMANAGER\n"); break;
6672 case D3DDEVINFOID_TEXTURING: TRACE("D3DDEVINFOID_TEXTURING\n"); break;
6673 default: ERR(" invalid flag !!!\n"); return DDERR_INVALIDPARAMS;
6674 }
6675 }
6676
6677 return S_FALSE; /* According to MSDN, this is valid for a non-debug driver */
6678 }
6679
6680 /* For performance optimization, devices created in FPUSETUP and FPUPRESERVE modes
6681 * have separate vtables. Simple functions where this doesn't matter like GetDirect3D
6682 * are not duplicated.
6683
6684 * Device created with DDSCL_FPUSETUP (d3d7 default) - device methods assume that FPU
6685 * has already been setup for optimal d3d operation.
6686
6687 * Device created with DDSCL_FPUPRESERVE - resets and restores FPU mode when necessary in
6688 * d3d calls (FPU may be in a mode non-suitable for d3d when the app calls d3d). Required
6689 * by Sacrifice (game). */
6690 static const struct IDirect3DDevice7Vtbl d3d_device7_fpu_setup_vtbl =
6691 {
6692 /*** IUnknown Methods ***/
6693 d3d_device7_QueryInterface,
6694 d3d_device7_AddRef,
6695 d3d_device7_Release,
6696 /*** IDirect3DDevice7 ***/
6697 d3d_device7_GetCaps_FPUSetup,
6698 d3d_device7_EnumTextureFormats_FPUSetup,
6699 d3d_device7_BeginScene_FPUSetup,
6700 d3d_device7_EndScene_FPUSetup,
6701 d3d_device7_GetDirect3D,
6702 d3d_device7_SetRenderTarget_FPUSetup,
6703 d3d_device7_GetRenderTarget,
6704 d3d_device7_Clear_FPUSetup,
6705 d3d_device7_SetTransform_FPUSetup,
6706 d3d_device7_GetTransform_FPUSetup,
6707 d3d_device7_SetViewport_FPUSetup,
6708 d3d_device7_MultiplyTransform_FPUSetup,
6709 d3d_device7_GetViewport_FPUSetup,
6710 d3d_device7_SetMaterial_FPUSetup,
6711 d3d_device7_GetMaterial_FPUSetup,
6712 d3d_device7_SetLight_FPUSetup,
6713 d3d_device7_GetLight_FPUSetup,
6714 d3d_device7_SetRenderState_FPUSetup,
6715 d3d_device7_GetRenderState_FPUSetup,
6716 d3d_device7_BeginStateBlock_FPUSetup,
6717 d3d_device7_EndStateBlock_FPUSetup,
6718 d3d_device7_PreLoad_FPUSetup,
6719 d3d_device7_DrawPrimitive_FPUSetup,
6720 d3d_device7_DrawIndexedPrimitive_FPUSetup,
6721 d3d_device7_SetClipStatus,
6722 d3d_device7_GetClipStatus,
6723 d3d_device7_DrawPrimitiveStrided_FPUSetup,
6724 d3d_device7_DrawIndexedPrimitiveStrided_FPUSetup,
6725 d3d_device7_DrawPrimitiveVB_FPUSetup,
6726 d3d_device7_DrawIndexedPrimitiveVB_FPUSetup,
6727 d3d_device7_ComputeSphereVisibility,
6728 d3d_device7_GetTexture_FPUSetup,
6729 d3d_device7_SetTexture_FPUSetup,
6730 d3d_device7_GetTextureStageState_FPUSetup,
6731 d3d_device7_SetTextureStageState_FPUSetup,
6732 d3d_device7_ValidateDevice_FPUSetup,
6733 d3d_device7_ApplyStateBlock_FPUSetup,
6734 d3d_device7_CaptureStateBlock_FPUSetup,
6735 d3d_device7_DeleteStateBlock_FPUSetup,
6736 d3d_device7_CreateStateBlock_FPUSetup,
6737 d3d_device7_Load_FPUSetup,
6738 d3d_device7_LightEnable_FPUSetup,
6739 d3d_device7_GetLightEnable_FPUSetup,
6740 d3d_device7_SetClipPlane_FPUSetup,
6741 d3d_device7_GetClipPlane_FPUSetup,
6742 d3d_device7_GetInfo
6743 };
6744
6745 static const struct IDirect3DDevice7Vtbl d3d_device7_fpu_preserve_vtbl =
6746 {
6747 /*** IUnknown Methods ***/
6748 d3d_device7_QueryInterface,
6749 d3d_device7_AddRef,
6750 d3d_device7_Release,
6751 /*** IDirect3DDevice7 ***/
6752 d3d_device7_GetCaps_FPUPreserve,
6753 d3d_device7_EnumTextureFormats_FPUPreserve,
6754 d3d_device7_BeginScene_FPUPreserve,
6755 d3d_device7_EndScene_FPUPreserve,
6756 d3d_device7_GetDirect3D,
6757 d3d_device7_SetRenderTarget_FPUPreserve,
6758 d3d_device7_GetRenderTarget,
6759 d3d_device7_Clear_FPUPreserve,
6760 d3d_device7_SetTransform_FPUPreserve,
6761 d3d_device7_GetTransform_FPUPreserve,
6762 d3d_device7_SetViewport_FPUPreserve,
6763 d3d_device7_MultiplyTransform_FPUPreserve,
6764 d3d_device7_GetViewport_FPUPreserve,
6765 d3d_device7_SetMaterial_FPUPreserve,
6766 d3d_device7_GetMaterial_FPUPreserve,
6767 d3d_device7_SetLight_FPUPreserve,
6768 d3d_device7_GetLight_FPUPreserve,
6769 d3d_device7_SetRenderState_FPUPreserve,
6770 d3d_device7_GetRenderState_FPUPreserve,
6771 d3d_device7_BeginStateBlock_FPUPreserve,
6772 d3d_device7_EndStateBlock_FPUPreserve,
6773 d3d_device7_PreLoad_FPUPreserve,
6774 d3d_device7_DrawPrimitive_FPUPreserve,
6775 d3d_device7_DrawIndexedPrimitive_FPUPreserve,
6776 d3d_device7_SetClipStatus,
6777 d3d_device7_GetClipStatus,
6778 d3d_device7_DrawPrimitiveStrided_FPUPreserve,
6779 d3d_device7_DrawIndexedPrimitiveStrided_FPUPreserve,
6780 d3d_device7_DrawPrimitiveVB_FPUPreserve,
6781 d3d_device7_DrawIndexedPrimitiveVB_FPUPreserve,
6782 d3d_device7_ComputeSphereVisibility,
6783 d3d_device7_GetTexture_FPUPreserve,
6784 d3d_device7_SetTexture_FPUPreserve,
6785 d3d_device7_GetTextureStageState_FPUPreserve,
6786 d3d_device7_SetTextureStageState_FPUPreserve,
6787 d3d_device7_ValidateDevice_FPUPreserve,
6788 d3d_device7_ApplyStateBlock_FPUPreserve,
6789 d3d_device7_CaptureStateBlock_FPUPreserve,
6790 d3d_device7_DeleteStateBlock_FPUPreserve,
6791 d3d_device7_CreateStateBlock_FPUPreserve,
6792 d3d_device7_Load_FPUPreserve,
6793 d3d_device7_LightEnable_FPUPreserve,
6794 d3d_device7_GetLightEnable_FPUPreserve,
6795 d3d_device7_SetClipPlane_FPUPreserve,
6796 d3d_device7_GetClipPlane_FPUPreserve,
6797 d3d_device7_GetInfo
6798 };
6799
6800 static const struct IDirect3DDevice3Vtbl d3d_device3_vtbl =
6801 {
6802 /*** IUnknown Methods ***/
6803 d3d_device3_QueryInterface,
6804 d3d_device3_AddRef,
6805 d3d_device3_Release,
6806 /*** IDirect3DDevice3 ***/
6807 d3d_device3_GetCaps,
6808 d3d_device3_GetStats,
6809 d3d_device3_AddViewport,
6810 d3d_device3_DeleteViewport,
6811 d3d_device3_NextViewport,
6812 d3d_device3_EnumTextureFormats,
6813 d3d_device3_BeginScene,
6814 d3d_device3_EndScene,
6815 d3d_device3_GetDirect3D,
6816 d3d_device3_SetCurrentViewport,
6817 d3d_device3_GetCurrentViewport,
6818 d3d_device3_SetRenderTarget,
6819 d3d_device3_GetRenderTarget,
6820 d3d_device3_Begin,
6821 d3d_device3_BeginIndexed,
6822 d3d_device3_Vertex,
6823 d3d_device3_Index,
6824 d3d_device3_End,
6825 d3d_device3_GetRenderState,
6826 d3d_device3_SetRenderState,
6827 d3d_device3_GetLightState,
6828 d3d_device3_SetLightState,
6829 d3d_device3_SetTransform,
6830 d3d_device3_GetTransform,
6831 d3d_device3_MultiplyTransform,
6832 d3d_device3_DrawPrimitive,
6833 d3d_device3_DrawIndexedPrimitive,
6834 d3d_device3_SetClipStatus,
6835 d3d_device3_GetClipStatus,
6836 d3d_device3_DrawPrimitiveStrided,
6837 d3d_device3_DrawIndexedPrimitiveStrided,
6838 d3d_device3_DrawPrimitiveVB,
6839 d3d_device3_DrawIndexedPrimitiveVB,
6840 d3d_device3_ComputeSphereVisibility,
6841 d3d_device3_GetTexture,
6842 d3d_device3_SetTexture,
6843 d3d_device3_GetTextureStageState,
6844 d3d_device3_SetTextureStageState,
6845 d3d_device3_ValidateDevice
6846 };
6847
6848 static const struct IDirect3DDevice2Vtbl d3d_device2_vtbl =
6849 {
6850 /*** IUnknown Methods ***/
6851 d3d_device2_QueryInterface,
6852 d3d_device2_AddRef,
6853 d3d_device2_Release,
6854 /*** IDirect3DDevice2 ***/
6855 d3d_device2_GetCaps,
6856 d3d_device2_SwapTextureHandles,
6857 d3d_device2_GetStats,
6858 d3d_device2_AddViewport,
6859 d3d_device2_DeleteViewport,
6860 d3d_device2_NextViewport,
6861 d3d_device2_EnumTextureFormats,
6862 d3d_device2_BeginScene,
6863 d3d_device2_EndScene,
6864 d3d_device2_GetDirect3D,
6865 d3d_device2_SetCurrentViewport,
6866 d3d_device2_GetCurrentViewport,
6867 d3d_device2_SetRenderTarget,
6868 d3d_device2_GetRenderTarget,
6869 d3d_device2_Begin,
6870 d3d_device2_BeginIndexed,
6871 d3d_device2_Vertex,
6872 d3d_device2_Index,
6873 d3d_device2_End,
6874 d3d_device2_GetRenderState,
6875 d3d_device2_SetRenderState,
6876 d3d_device2_GetLightState,
6877 d3d_device2_SetLightState,
6878 d3d_device2_SetTransform,
6879 d3d_device2_GetTransform,
6880 d3d_device2_MultiplyTransform,
6881 d3d_device2_DrawPrimitive,
6882 d3d_device2_DrawIndexedPrimitive,
6883 d3d_device2_SetClipStatus,
6884 d3d_device2_GetClipStatus
6885 };
6886
6887 static const struct IDirect3DDeviceVtbl d3d_device1_vtbl =
6888 {
6889 /*** IUnknown Methods ***/
6890 d3d_device1_QueryInterface,
6891 d3d_device1_AddRef,
6892 d3d_device1_Release,
6893 /*** IDirect3DDevice1 ***/
6894 d3d_device1_Initialize,
6895 d3d_device1_GetCaps,
6896 d3d_device1_SwapTextureHandles,
6897 d3d_device1_CreateExecuteBuffer,
6898 d3d_device1_GetStats,
6899 d3d_device1_Execute,
6900 d3d_device1_AddViewport,
6901 d3d_device1_DeleteViewport,
6902 d3d_device1_NextViewport,
6903 d3d_device1_Pick,
6904 d3d_device1_GetPickRecords,
6905 d3d_device1_EnumTextureFormats,
6906 d3d_device1_CreateMatrix,
6907 d3d_device1_SetMatrix,
6908 d3d_device1_GetMatrix,
6909 d3d_device1_DeleteMatrix,
6910 d3d_device1_BeginScene,
6911 d3d_device1_EndScene,
6912 d3d_device1_GetDirect3D
6913 };
6914
6915 static const struct IUnknownVtbl d3d_device_inner_vtbl =
6916 {
6917 d3d_device_inner_QueryInterface,
6918 d3d_device_inner_AddRef,
6919 d3d_device_inner_Release,
6920 };
6921
6922 struct d3d_device *unsafe_impl_from_IDirect3DDevice7(IDirect3DDevice7 *iface)
6923 {
6924 if (!iface) return NULL;
6925 assert((iface->lpVtbl == &d3d_device7_fpu_preserve_vtbl) || (iface->lpVtbl == &d3d_device7_fpu_setup_vtbl));
6926 return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice7_iface);
6927 }
6928
6929 struct d3d_device *unsafe_impl_from_IDirect3DDevice3(IDirect3DDevice3 *iface)
6930 {
6931 if (!iface) return NULL;
6932 assert(iface->lpVtbl == &d3d_device3_vtbl);
6933 return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice3_iface);
6934 }
6935
6936 struct d3d_device *unsafe_impl_from_IDirect3DDevice2(IDirect3DDevice2 *iface)
6937 {
6938 if (!iface) return NULL;
6939 assert(iface->lpVtbl == &d3d_device2_vtbl);
6940 return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice2_iface);
6941 }
6942
6943 struct d3d_device *unsafe_impl_from_IDirect3DDevice(IDirect3DDevice *iface)
6944 {
6945 if (!iface) return NULL;
6946 assert(iface->lpVtbl == &d3d_device1_vtbl);
6947 return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice_iface);
6948 }
6949
6950 enum wined3d_depth_buffer_type d3d_device_update_depth_stencil(struct d3d_device *device)
6951 {
6952 IDirectDrawSurface7 *depthStencil = NULL;
6953 IDirectDrawSurface7 *render_target;
6954 static DDSCAPS2 depthcaps = { DDSCAPS_ZBUFFER, 0, 0, {0} };
6955 struct ddraw_surface *dsi;
6956
6957 if (device->rt_iface && SUCCEEDED(IUnknown_QueryInterface(device->rt_iface,
6958 &IID_IDirectDrawSurface7, (void **)&render_target)))
6959 {
6960 IDirectDrawSurface7_GetAttachedSurface(render_target, &depthcaps, &depthStencil);
6961 IDirectDrawSurface7_Release(render_target);
6962 }
6963 if (!depthStencil)
6964 {
6965 TRACE("Setting wined3d depth stencil to NULL\n");
6966 wined3d_device_context_set_depth_stencil_view(device->immediate_context, NULL);
6967 return WINED3D_ZB_FALSE;
6968 }
6969
6970 dsi = impl_from_IDirectDrawSurface7(depthStencil);
6971 wined3d_device_context_set_depth_stencil_view(device->immediate_context,
6972 ddraw_surface_get_rendertarget_view(dsi));
6973
6974 IDirectDrawSurface7_Release(depthStencil);
6975 return WINED3D_ZB_TRUE;
6976 }
6977
6978 static void ddraw_reset_viewport_state(struct ddraw *ddraw)
6979 {
6980 struct wined3d_viewport vp;
6981 RECT rect;
6982
6983 wined3d_device_context_get_viewports(ddraw->immediate_context, NULL, &vp);
6984 wined3d_stateblock_set_viewport(ddraw->state, &vp);
6985 wined3d_device_context_get_scissor_rects(ddraw->immediate_context, NULL, &rect);
6986 wined3d_stateblock_set_scissor_rect(ddraw->state, &rect);
6987 }
6988
6989 static HRESULT d3d_device_init(struct d3d_device *device, struct ddraw *ddraw, const GUID *guid,
6990 struct ddraw_surface *target, IUnknown *rt_iface, UINT version, IUnknown *outer_unknown)
6991 {
6992 static const struct wined3d_matrix ident =
6993 {
6994 1.0f, 0.0f, 0.0f, 0.0f,
6995 0.0f, 1.0f, 0.0f, 0.0f,
6996 0.0f, 0.0f, 1.0f, 0.0f,
6997 0.0f, 0.0f, 0.0f, 1.0f,
6998 };
6999 struct wined3d_rendertarget_view *rtv;
7000 HRESULT hr;
7001
7002 if (ddraw->cooperative_level & DDSCL_FPUPRESERVE)
7003 device->IDirect3DDevice7_iface.lpVtbl = &d3d_device7_fpu_preserve_vtbl;
7004 else
7005 device->IDirect3DDevice7_iface.lpVtbl = &d3d_device7_fpu_setup_vtbl;
7006
7007 device->IDirect3DDevice3_iface.lpVtbl = &d3d_device3_vtbl;
7008 device->IDirect3DDevice2_iface.lpVtbl = &d3d_device2_vtbl;
7009 device->IDirect3DDevice_iface.lpVtbl = &d3d_device1_vtbl;
7010 device->IUnknown_inner.lpVtbl = &d3d_device_inner_vtbl;
7011 device->ref = 1;
7012 device->version = version;
7013 device->hardware_device = IsEqualGUID(&IID_IDirect3DTnLHalDevice, guid)
7014 || IsEqualGUID(&IID_IDirect3DHALDevice, guid);
7015
7016 if (device->hardware_device && !(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
7017 {
7018 WARN("Surface %p is not in video memory.\n", target);
7019 return D3DERR_SURFACENOTINVIDMEM;
7020 }
7021
7022 if (outer_unknown)
7023 device->outer_unknown = outer_unknown;
7024 else
7025 device->outer_unknown = &device->IUnknown_inner;
7026
7027 device->ddraw = ddraw;
7028 list_init(&device->viewport_list);
7029
7030 if (!ddraw_handle_table_init(&device->handle_table, 64))
7031 {
7032 ERR("Failed to initialize handle table.\n");
7033 return DDERR_OUTOFMEMORY;
7034 }
7035
7036 device->legacyTextureBlending = FALSE;
7037 device->legacy_projection = ident;
7038 device->legacy_clipspace = ident;
7039
7040 /* This is for convenience. */
7041 device->wined3d_device = ddraw->wined3d_device;
7042 device->immediate_context = ddraw->immediate_context;
7043 wined3d_device_incref(ddraw->wined3d_device);
7044 device->update_state = device->state = ddraw->state;
7045 device->stateblock_state = ddraw->stateblock_state;
7046 wined3d_stateblock_incref(ddraw->state);
7047
7048 /* Render to the back buffer */
7049 rtv = ddraw_surface_get_rendertarget_view(target);
7050 if (FAILED(hr = wined3d_device_context_set_rendertarget_views(device->immediate_context, 0, 1, &rtv, TRUE)))
7051 {
7052 ERR("Failed to set render target, hr %#x.\n", hr);
7053 wined3d_stateblock_decref(device->state);
7054 ddraw_handle_table_destroy(&device->handle_table);
7055 return hr;
7056 }
7057
7058 device->rt_iface = rt_iface;
7059 if (version != 1)
7060 IUnknown_AddRef(device->rt_iface);
7061
7062 ddraw->d3ddevice = device;
7063
7064 wined3d_stateblock_set_render_state(ddraw->state, WINED3D_RS_ZENABLE,
7065 d3d_device_update_depth_stencil(device));
7066 if (version == 1) /* Color keying is initially enabled for version 1 devices. */
7067 wined3d_stateblock_set_render_state(ddraw->state, WINED3D_RS_COLORKEYENABLE, TRUE);
7068 else if (version == 2)
7069 wined3d_stateblock_set_render_state(ddraw->state, WINED3D_RS_SPECULARENABLE, TRUE);
7070 if (version < 7)
7071 {
7072 wined3d_stateblock_set_render_state(ddraw->state, WINED3D_RS_NORMALIZENORMALS, TRUE);
7073 IDirect3DDevice3_SetRenderState(&device->IDirect3DDevice3_iface,
7074 D3DRENDERSTATE_TEXTUREMAPBLEND, D3DTBLEND_MODULATE);
7075 }
7076 ddraw_reset_viewport_state(ddraw);
7077 return D3D_OK;
7078 }
7079
7080 HRESULT d3d_device_create(struct ddraw *ddraw, const GUID *guid, struct ddraw_surface *target, IUnknown *rt_iface,
7081 UINT version, struct d3d_device **device, IUnknown *outer_unknown)
7082 {
7083 struct d3d_device *object;
7084 HRESULT hr;
7085
7086 TRACE("ddraw %p, guid %s, target %p, version %u, device %p, outer_unknown %p.\n",
7087 ddraw, debugstr_guid(guid), target, version, device, outer_unknown);
7088
7089 if (!(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
7090 || (target->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER))
7091 {
7092 WARN("Surface %p is not a render target.\n", target);
7093 return DDERR_INVALIDCAPS;
7094 }
7095
7096 if (!validate_surface_palette(target))
7097 {
7098 WARN("Surface %p has an indexed pixel format, but no palette.\n", target);
7099 return DDERR_NOPALETTEATTACHED;
7100 }
7101
7102 if (ddraw->flags & DDRAW_NO3D)
7103 {
7104 ERR_(winediag)("The application wants to create a Direct3D device, "
7105 "but the current DirectDrawRenderer does not support this.\n");
7106
7107 return DDERR_OUTOFMEMORY;
7108 }
7109
7110 if (ddraw->d3ddevice)
7111 {
7112 FIXME("Only one Direct3D device per DirectDraw object supported.\n");
7113 return DDERR_INVALIDPARAMS;
7114 }
7115
7116 if (!(object = heap_alloc_zero(sizeof(*object))))
7117 {
7118 ERR("Failed to allocate device memory.\n");
7119 return DDERR_OUTOFMEMORY;
7120 }
7121
7122 if (FAILED(hr = d3d_device_init(object, ddraw, guid, target, rt_iface, version, outer_unknown)))
7123 {
7124 WARN("Failed to initialize device, hr %#x.\n", hr);
7125 heap_free(object);
7126 return hr;
7127 }
7128
7129 TRACE("Created device %p.\n", object);
7130 *device = object;
7131
7132 return D3D_OK;
7133 }
Windows API implementation