git.oblomov.eu Git - wine/blob - dlls/ddraw/device.c

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