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