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  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * IDirect3DDevice implementation, version 1, 2, 3 and 7. Rendering is relayed
  21  * to WineD3D, some minimal DirectDraw specific management is handled here.
  22  * The Direct3DDevice is NOT the parent of the WineD3DDevice, because d3d
  23  * is initialized when DirectDraw creates the primary surface.
  24  * Some type management is necessary, because some D3D types changed between
  25  * D3D7 and D3D9.
  26  *
  27  */
  28
  29 #include "config.h"
  30 #include "wine/port.h"
  31 #include "wine/debug.h"
  32
  33 #include <assert.h>
  34 #include <stdarg.h>
  35 #include <string.h>
  36 #include <stdlib.h>
  37
  38 #define COBJMACROS
  39
  40 #include "windef.h"
  41 #include "winbase.h"
  42 #include "winnls.h"
  43 #include "winerror.h"
  44 #include "wingdi.h"
  45 #include "wine/exception.h"
  46 #include "excpt.h"
  47
  48 #include "ddraw.h"
  49 #include "d3d.h"
  50
  51 #include "ddraw_private.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 /*****************************************************************************
  65  * IUnknown Methods. Common for Version 1, 2, 3 and 7
  66  *****************************************************************************/
  67
  68 /*****************************************************************************
  69  * IDirect3DDevice7::QueryInterface
  70  *
  71  * Used to query other interfaces from a Direct3DDevice interface.
  72  * It can return interface pointers to all Direct3DDevice versions as well
  73  * as IDirectDraw and IDirect3D. For a link to QueryInterface
  74  * rules see ddraw.c, IDirectDraw7::QueryInterface
  75  *
  76  * Exists in Version 1, 2, 3 and 7
  77  *
  78  * Params:
  79  *  refiid: Interface ID queried for
  80  *  obj: Used to return the interface pointer
  81  *
  82  * Returns:
  83  *  D3D_OK or E_NOINTERFACE
  84  *
  85  *****************************************************************************/
  86 static HRESULT WINAPI
  87 IDirect3DDeviceImpl_7_QueryInterface(IDirect3DDevice7 *iface,
  88                                      REFIID refiid,
  89                                      void **obj)
  90 {
  91     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
  92     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(refiid), obj);
  93
  94     /* According to COM docs, if the QueryInterface fails, obj should be set to NULL */
  95     *obj = NULL;
  96
  97     if(!refiid)
  98         return DDERR_INVALIDPARAMS;
  99
 100     if ( IsEqualGUID( &IID_IUnknown, refiid ) )
 101     {
 102         *obj = ICOM_INTERFACE(This, IDirect3DDevice7);
 103     }
 104
 105     /* Check DirectDraw Interfac\ 1s */
 106     else if( IsEqualGUID( &IID_IDirectDraw7, refiid ) )
 107     {
 108         *obj = ICOM_INTERFACE(This->ddraw, IDirectDraw7);
 109         TRACE("(%p) Returning IDirectDraw7 interface at %p\n", This, *obj);
 110     }
 111     else if ( IsEqualGUID( &IID_IDirectDraw4, refiid ) )
 112     {
 113         *obj = ICOM_INTERFACE(This->ddraw, IDirectDraw4);
 114         TRACE("(%p) Returning IDirectDraw4 interface at %p\n", This, *obj);
 115     }
 116     else if ( IsEqualGUID( &IID_IDirectDraw2, refiid ) )
 117     {
 118         *obj = ICOM_INTERFACE(This->ddraw, IDirectDraw2);
 119         TRACE("(%p) Returning IDirectDraw2 interface at %p\n", This, *obj);
 120     }
 121     else if( IsEqualGUID( &IID_IDirectDraw, refiid ) )
 122     {
 123         *obj = ICOM_INTERFACE(This->ddraw, IDirectDraw);
 124         TRACE("(%p) Returning IDirectDraw interface at %p\n", This, *obj);
 125     }
 126
 127     /* Direct3D */
 128     else if ( IsEqualGUID( &IID_IDirect3D  , refiid ) )
 129     {
 130         *obj = ICOM_INTERFACE(This->ddraw, IDirect3D);
 131         TRACE("(%p) Returning IDirect3D interface at %p\n", This, *obj);
 132     }
 133     else if ( IsEqualGUID( &IID_IDirect3D2 , refiid ) )
 134     {
 135         *obj = ICOM_INTERFACE(This->ddraw, IDirect3D2);
 136         TRACE("(%p) Returning IDirect3D2 interface at %p\n", This, *obj);
 137     }
 138     else if ( IsEqualGUID( &IID_IDirect3D3 , refiid ) )
 139     {
 140         *obj = ICOM_INTERFACE(This->ddraw, IDirect3D3);
 141         TRACE("(%p) Returning IDirect3D3 interface at %p\n", This, *obj);
 142     }
 143     else if ( IsEqualGUID( &IID_IDirect3D7 , refiid ) )
 144     {
 145         *obj = ICOM_INTERFACE(This->ddraw, IDirect3D7);
 146         TRACE("(%p) Returning IDirect3D7 interface at %p\n", This, *obj);
 147     }
 148
 149     /* Direct3DDevice */
 150     else if ( IsEqualGUID( &IID_IDirect3DDevice  , refiid ) )
 151     {
 152         *obj = ICOM_INTERFACE(This, IDirect3DDevice);
 153         TRACE("(%p) Returning IDirect3DDevice interface at %p\n", This, *obj);
 154     }
 155     else if ( IsEqualGUID( &IID_IDirect3DDevice2  , refiid ) ) {
 156         *obj = ICOM_INTERFACE(This, IDirect3DDevice2);
 157         TRACE("(%p) Returning IDirect3DDevice2 interface at %p\n", This, *obj);
 158     }
 159     else if ( IsEqualGUID( &IID_IDirect3DDevice3  , refiid ) ) {
 160         *obj = ICOM_INTERFACE(This, IDirect3DDevice3);
 161         TRACE("(%p) Returning IDirect3DDevice3 interface at %p\n", This, *obj);
 162     }
 163     else if ( IsEqualGUID( &IID_IDirect3DDevice7  , refiid ) ) {
 164         *obj = ICOM_INTERFACE(This, IDirect3DDevice7);
 165         TRACE("(%p) Returning IDirect3DDevice7 interface at %p\n", This, *obj);
 166     }
 167
 168     /* Unknown interface */
 169     else
 170     {
 171         ERR("(%p)->(%s, %p): No interface found", This, debugstr_guid(refiid), obj);
 172         return E_NOINTERFACE;
 173     }
 174
 175     /* AddRef the returned interface */
 176     IUnknown_AddRef( (IUnknown *) *obj);
 177     return D3D_OK;
 178 }
 179
 180 static HRESULT WINAPI
 181 Thunk_IDirect3DDeviceImpl_3_QueryInterface(IDirect3DDevice3 *iface,
 182                                            REFIID riid,
 183                                            void **obj)
 184 {
 185     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 186     TRACE_(ddraw_thunk)("(%p)->(%s,%p) thunking to IDirect3DDevice7 interface.\n", This, debugstr_guid(riid), obj);
 187     return IDirect3DDevice7_QueryInterface(ICOM_INTERFACE(This, IDirect3DDevice7),
 188                                            riid,
 189                                            obj);
 190 }
 191
 192 static HRESULT WINAPI
 193 Thunk_IDirect3DDeviceImpl_2_QueryInterface(IDirect3DDevice2 *iface,
 194                                            REFIID riid,
 195                                            void **obj)
 196 {
 197     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 198     TRACE_(ddraw_thunk)("(%p)->(%s,%p) thunking to IDirect3DDevice7 interface.\n", This, debugstr_guid(riid), obj);
 199     return IDirect3DDevice7_QueryInterface(ICOM_INTERFACE(This, IDirect3DDevice7),
 200                                            riid,
 201                                            obj);
 202 }
 203
 204 static HRESULT WINAPI
 205 Thunk_IDirect3DDeviceImpl_1_QueryInterface(IDirect3DDevice *iface,
 206                                            REFIID riid,
 207                                            void **obp)
 208 {
 209     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
 210     TRACE_(ddraw_thunk)("(%p)->(%s,%p) thunking to IDirect3DDevice7 interface.\n", This, debugstr_guid(riid), obp);
 211     return IDirect3DDevice7_QueryInterface(ICOM_INTERFACE(This, IDirect3DDevice7),
 212                                            riid,
 213                                            obp);
 214 }
 215
 216 /*****************************************************************************
 217  * IDirect3DDevice7::AddRef
 218  *
 219  * Increases the refcount....
 220  * The most exciting Method, definitely
 221  *
 222  * Exists in Version 1, 2, 3 and 7
 223  *
 224  * Returns:
 225  *  The new refcount
 226  *
 227  *****************************************************************************/
 228 static ULONG WINAPI
 229 IDirect3DDeviceImpl_7_AddRef(IDirect3DDevice7 *iface)
 230 {
 231     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 232     ULONG ref = InterlockedIncrement(&This->ref);
 233
 234     TRACE("(%p) : incrementing from %lu.\n", This, ref -1);
 235
 236     return ref;
 237 }
 238
 239 static ULONG WINAPI
 240 Thunk_IDirect3DDeviceImpl_3_AddRef(IDirect3DDevice3 *iface)
 241 {
 242     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 243     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DDevice7 interface.\n", This);
 244     return IDirect3DDevice7_AddRef(ICOM_INTERFACE(This, IDirect3DDevice7));
 245 }
 246
 247 static ULONG WINAPI
 248 Thunk_IDirect3DDeviceImpl_2_AddRef(IDirect3DDevice2 *iface)
 249 {
 250     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 251     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DDevice7 interface.\n", This);
 252     return IDirect3DDevice7_AddRef(ICOM_INTERFACE(This, IDirect3DDevice7));
 253 }
 254
 255 static ULONG WINAPI
 256 Thunk_IDirect3DDeviceImpl_1_AddRef(IDirect3DDevice *iface)
 257 {
 258     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
 259     return IDirect3DDevice7_AddRef(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice7, iface));
 260 }
 261
 262 /*****************************************************************************
 263  * IDirect3DDevice7::Release
 264  *
 265  * Decreases the refcount of the interface
 266  * When the refcount is reduced to 0, the object is destroyed.
 267  *
 268  * Exists in Version 1, 2, 3 and 7
 269  *
 270  * Returns:d
 271  *  The new refcount
 272  *
 273  *****************************************************************************/
 274 static ULONG WINAPI
 275 IDirect3DDeviceImpl_7_Release(IDirect3DDevice7 *iface)
 276 {
 277     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 278     ULONG ref = InterlockedDecrement(&This->ref);
 279
 280     TRACE("(%p)->() decrementing from %lu.\n", This, ref +1);
 281
 282     /* This method doesn't destroy the WineD3DDevice, because it's still in use for
 283      * 2D rendering. IDirectDrawSurface7::Release will destroy the WineD3DDevice
 284      * when the render target is released
 285      */
 286     if (ref == 0)
 287     {
 288         IParent *IndexBufferParent;
 289         DWORD i;
 290
 291         /* Free the index buffer */
 292         IWineD3DDevice_SetIndices(This->wineD3DDevice,
 293                                   NULL,
 294                                   0);
 295         IWineD3DIndexBuffer_GetParent(This->indexbuffer,
 296                                       (IUnknown **) &IndexBufferParent);
 297         IParent_Release(IndexBufferParent); /* Once for the getParent */
 298         if( IParent_Release(IndexBufferParent) != 0)  /* And now to destroy it */
 299         {
 300             ERR(" (%p) Something is still holding the index buffer parent %p\n", This, IndexBufferParent);
 301         }
 302
 303         /* Restore the render targets */
 304         if(This->OffScreenTarget)
 305         {
 306             /* This->target is the offscreen target.
 307              * This->ddraw->d3d_target is the target used by DDraw
 308              */
 309             TRACE("(%p) Release: Using %p as front buffer, %p as back buffer\n", This, This->ddraw->d3d_target, NULL);
 310             IWineD3DDevice_SetFrontBackBuffers(This->wineD3DDevice,
 311                                                This->ddraw->d3d_target->WineD3DSurface,
 312                                                NULL);
 313         }
 314
 315         /* Release the WineD3DDevice. This won't destroy it */
 316         if(IWineD3DDevice_Release(This->wineD3DDevice) <= 0)
 317         {
 318             ERR(" (%p) The wineD3D device %p was destroyed unexpectadely. Prepare for trouble\n", This, This->wineD3DDevice);
 319         }
 320
 321         /* The texture handles should be unset by now, but there might be some bits
 322          * missing in our reference counting(needs test). Do a sanity check
 323          */
 324         for(i = 0; i < This->numHandles; i++)
 325         {
 326             if(This->Handles[i].ptr)
 327             {
 328                 switch(This->Handles[i].type)
 329                 {
 330                     case DDrawHandle_Texture:
 331                     {
 332                         IDirectDrawSurfaceImpl *surf = (IDirectDrawSurfaceImpl *) This->Handles[i].ptr;
 333                         FIXME("Texture Handle %ld not unset properly\n", i + 1);
 334                         surf->Handle = 0;
 335                     }
 336                     break;
 337
 338                     case DDrawHandle_Material:
 339                     {
 340                         IDirect3DMaterialImpl *mat = (IDirect3DMaterialImpl *) This->Handles[i].ptr;
 341                         FIXME("Material handle %ld not unset properly\n", i + 1);
 342                         mat->Handle = 0;
 343                     }
 344                     break;
 345
 346                     case DDrawHandle_Matrix:
 347                     {
 348                         /* No fixme here because this might happen because of sloppy apps */
 349                         WARN("Leftover matrix handle %ld, deleting\n", i + 1);
 350                         IDirect3DDevice_DeleteMatrix(ICOM_INTERFACE(This, IDirect3DDevice),
 351                                                      i + 1);
 352                     }
 353                     break;
 354
 355                     default:
 356                         FIXME("Unknown handle %ld not unset properly\n", i + 1);
 357                 }
 358             }
 359         }
 360
 361         HeapFree(GetProcessHeap(), 0, This->Handles);
 362
 363         /* Release the render target and the WineD3D render target
 364          * (See IDirect3D7::CreateDevice for more comments on this)
 365          */
 366         IDirectDrawSurface7_Release(ICOM_INTERFACE(This->target, IDirectDrawSurface7));
 367         IDirectDrawSurface7_Release(ICOM_INTERFACE(This->ddraw->d3d_target,IDirectDrawSurface7));
 368
 369         This->ddraw->d3ddevice = NULL;
 370
 371         /* Now free the structure */
 372         HeapFree(GetProcessHeap(), 0, This);
 373     }
 374
 375     return ref;
 376 }
 377
 378 static ULONG WINAPI
 379 Thunk_IDirect3DDeviceImpl_3_Release(IDirect3DDevice3 *iface)
 380 {
 381     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 382     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DDevice7 interface.\n", This);
 383     return IDirect3DDevice7_Release(ICOM_INTERFACE(This, IDirect3DDevice7));
 384 }
 385
 386 static ULONG WINAPI
 387 Thunk_IDirect3DDeviceImpl_2_Release(IDirect3DDevice2 *iface)
 388 {
 389     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 390     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DDevice7 interface.\n", This);
 391     return IDirect3DDevice7_Release(ICOM_INTERFACE(This, IDirect3DDevice7));
 392 }
 393
 394 static ULONG WINAPI
 395 Thunk_IDirect3DDeviceImpl_1_Release(IDirect3DDevice *iface)
 396 {
 397     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
 398     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DDevice7 interface.\n", This);
 399     return IDirect3DDevice7_Release(ICOM_INTERFACE(This, IDirect3DDevice7));
 400 }
 401
 402 /*****************************************************************************
 403  * IDirect3DDevice Methods
 404  *****************************************************************************/
 405
 406 /*****************************************************************************
 407  * IDirect3DDevice::Initialize
 408  *
 409  * Initializes a Direct3DDevice. This implementation is a no-op, as all
 410  * initialization is done at create time.
 411  *
 412  * Exists in Version 1
 413  *
 414  * Parameters:
 415  *  No idea what they mean, as the MSDN page is gone
 416  *
 417  * Returns: DD_OK
 418  *
 419  *****************************************************************************/
 420 static HRESULT WINAPI
 421 IDirect3DDeviceImpl_1_Initialize(IDirect3DDevice *iface,
 422                                  IDirect3D *Direct3D, GUID *guid,
 423                                  D3DDEVICEDESC *Desc)
 424 {
 425     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
 426
 427     /* It shouldn't be crucial, but print a FIXME, I'm interested if
 428      * any game calls it and when
 429      */
 430     FIXME("(%p)->(%p,%p,%p): No-op!\n", This, Direct3D, guid, Desc);
 431
 432     return D3D_OK;
 433 }
 434
 435 /*****************************************************************************
 436  * IDirect3DDevice7::GetCaps
 437  *
 438  * Retrieves the device's capabilities
 439  *
 440  * This implementation is used for Version 7 only, the older versions have
 441  * their own implementation.
 442  *
 443  * Parameters:
 444  *  Desc: Pointer to a D3DDEVICEDESC7 structure to fill
 445  *
 446  * Returns:
 447  *  D3D_OK on success
 448  *  D3DERR_* if a problem occurs. See WineD3D
 449  *
 450  *****************************************************************************/
 451 static HRESULT WINAPI
 452 IDirect3DDeviceImpl_7_GetCaps(IDirect3DDevice7 *iface,
 453                               D3DDEVICEDESC7 *Desc)
 454 {
 455     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 456     D3DDEVICEDESC OldDesc;
 457     TRACE("(%p)->(%p)\n", This, Desc);
 458
 459     /* Call the same function used by IDirect3D, this saves code */
 460     return IDirect3DImpl_GetCaps(This->ddraw->wineD3D, &OldDesc, Desc);
 461 }
 462
 463 /*****************************************************************************
 464  * IDirect3DDevice3::GetCaps
 465  *
 466  * Retrieves the capabilities of the hardware device and the emulation
 467  * device. For Wine, hardware and emulation are the same (it's all HW).
 468  *
 469  * This implementation is used for Version 1, 2, and 3. Version 7 has its own
 470  *
 471  * Parameters:
 472  *  HWDesc: Structure to fill with the HW caps
 473  *  HelDesc: Structure to fill with the hardare emulation caps
 474  *
 475  * Returns:
 476  *  D3D_OK on success
 477  *  D3DERR_* if a problem occurs. See WineD3D
 478  *
 479  *****************************************************************************/
 480 static HRESULT WINAPI
 481 IDirect3DDeviceImpl_3_GetCaps(IDirect3DDevice3 *iface,
 482                               D3DDEVICEDESC *HWDesc,
 483                               D3DDEVICEDESC *HelDesc)
 484 {
 485     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 486     D3DDEVICEDESC7 newDesc;
 487     HRESULT hr;
 488     TRACE("(%p)->(%p,%p)\n", iface, HWDesc, HelDesc);
 489
 490     hr = IDirect3DImpl_GetCaps(This->ddraw->wineD3D, HWDesc, &newDesc);
 491     if(hr != D3D_OK) return hr;
 492
 493     *HelDesc = *HWDesc;
 494     return D3D_OK;
 495 }
 496
 497 static HRESULT WINAPI
 498 Thunk_IDirect3DDeviceImpl_2_GetCaps(IDirect3DDevice2 *iface,
 499                                     D3DDEVICEDESC *D3DHWDevDesc,
 500                                     D3DDEVICEDESC *D3DHELDevDesc)
 501 {
 502     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 503     TRACE_(ddraw_thunk)("(%p)->(%p,%p) thunking to IDirect3DDevice3 interface.\n", This, D3DHWDevDesc, D3DHELDevDesc);
 504     return IDirect3DDevice3_GetCaps(ICOM_INTERFACE(This, IDirect3DDevice3),
 505                                     D3DHWDevDesc,
 506                                     D3DHELDevDesc);
 507 }
 508
 509 static HRESULT WINAPI
 510 Thunk_IDirect3DDeviceImpl_1_GetCaps(IDirect3DDevice *iface,
 511                                     D3DDEVICEDESC *D3DHWDevDesc,
 512                                     D3DDEVICEDESC *D3DHELDevDesc)
 513 {
 514     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
 515     TRACE_(ddraw_thunk)("(%p)->(%p,%p) thunking to IDirect3DDevice3 interface.\n", This, D3DHWDevDesc, D3DHELDevDesc);
 516     return IDirect3DDevice3_GetCaps(ICOM_INTERFACE(This, IDirect3DDevice3),
 517                                     D3DHWDevDesc,
 518                                     D3DHELDevDesc);
 519 }
 520
 521 /*****************************************************************************
 522  * IDirect3DDevice2::SwapTextureHandles
 523  *
 524  * Swaps the texture handles of 2 Texture interfaces. Version 1 and 2
 525  *
 526  * Parameters:
 527  *  Tex1, Tex2: The 2 Textures to swap
 528  *
 529  * Returns:
 530  *  D3D_OK
 531  *
 532  *****************************************************************************/
 533 static HRESULT WINAPI
 534 IDirect3DDeviceImpl_2_SwapTextureHandles(IDirect3DDevice2 *iface,
 535                                          IDirect3DTexture2 *Tex1,
 536                                          IDirect3DTexture2 *Tex2)
 537 {
 538     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 539     DWORD swap;
 540     IDirectDrawSurfaceImpl *surf1 = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirect3DTexture2, Tex1);
 541     IDirectDrawSurfaceImpl *surf2 = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirect3DTexture2, Tex2);
 542     TRACE("(%p)->(%p,%p)\n", This, surf1, surf2);
 543
 544     This->Handles[surf1->Handle - 1].ptr = surf2;
 545     This->Handles[surf2->Handle - 1].ptr = surf1;
 546
 547     swap = surf2->Handle;
 548     surf2->Handle = surf1->Handle;
 549     surf1->Handle = swap;
 550
 551     return D3D_OK;
 552 }
 553
 554 static HRESULT WINAPI
 555 Thunk_IDirect3DDeviceImpl_1_SwapTextureHandles(IDirect3DDevice *iface,
 556                                                IDirect3DTexture *D3DTex1,
 557                                                IDirect3DTexture *D3DTex2)
 558 {
 559     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 560     IDirectDrawSurfaceImpl *surf1 = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirect3DTexture, D3DTex1);
 561     IDirectDrawSurfaceImpl *surf2 = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirect3DTexture, D3DTex2);
 562     TRACE_(ddraw_thunk)("(%p)->(%p,%p) thunking to IDirect3DDevice2 interface.\n", This, surf1, surf2);
 563     return IDirect3DDevice2_SwapTextureHandles(ICOM_INTERFACE(This, IDirect3DDevice2),
 564                                                ICOM_INTERFACE(surf1, IDirect3DTexture2),
 565                                                ICOM_INTERFACE(surf2, IDirect3DTexture2));
 566 }
 567
 568 /*****************************************************************************
 569  * IDirect3DDevice3::GetStats
 570  *
 571  * This method seems to retrieve some stats from the device.
 572  * The MSDN documentation doesn't exist any more, but the D3DSTATS
 573  * structure suggests that the amout of drawn primitives and processed
 574  * vertices is returned.
 575  *
 576  * Exists in Version 1, 2 and 3
 577  *
 578  * Parameters:
 579  *  Stats: Pointer to a D3DSTATS structure to be filled
 580  *
 581  * Returns:
 582  *  D3D_OK on success
 583  *  DDERR_INVALIDPARAMS if Stats == NULL
 584  *
 585  *****************************************************************************/
 586 static HRESULT WINAPI
 587 IDirect3DDeviceImpl_3_GetStats(IDirect3DDevice3 *iface,
 588                                D3DSTATS *Stats)
 589 {
 590     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 591     FIXME("(%p)->(%p): Stub!\n", This, Stats);
 592
 593     if(!Stats)
 594         return DDERR_INVALIDPARAMS;
 595
 596     /* Fill the Stats with 0 */
 597     Stats->dwTrianglesDrawn = 0;
 598     Stats->dwLinesDrawn = 0;
 599     Stats->dwPointsDrawn = 0;
 600     Stats->dwSpansDrawn = 0;
 601     Stats->dwVerticesProcessed = 0;
 602
 603     return D3D_OK;
 604 }
 605
 606 static HRESULT WINAPI
 607 Thunk_IDirect3DDeviceImpl_2_GetStats(IDirect3DDevice2 *iface,
 608                                      D3DSTATS *Stats)
 609 {
 610     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 611     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", This, Stats);
 612     return IDirect3DDevice3_GetStats(ICOM_INTERFACE(This, IDirect3DDevice3),
 613                                      Stats);
 614 }
 615
 616 static HRESULT WINAPI
 617 Thunk_IDirect3DDeviceImpl_1_GetStats(IDirect3DDevice *iface,
 618                                      D3DSTATS *Stats)
 619 {
 620     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
 621     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", This, Stats);
 622     return IDirect3DDevice3_GetStats(ICOM_INTERFACE(This, IDirect3DDevice3),
 623                                      Stats);
 624 }
 625
 626 /*****************************************************************************
 627  * IDirect3DDevice::CreateExecuteBuffer
 628  *
 629  * Creates an IDirect3DExecuteBuffer, used for rendering with a
 630  * Direct3DDevice.
 631  *
 632  * Version 1 only.
 633  *
 634  * Params:
 635  *  Desc: Buffer description
 636  *  ExecuteBuffer: Address to return the Interface pointer at
 637  *  UnkOuter: Must be NULL. Basically for aggregation, which ddraw doesn't
 638  *            support
 639  *
 640  * Returns:
 641  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
 642  *  DDERR_OUTOFMEMORY if we ran out of memory
 643  *  D3D_OK on success
 644  *
 645  *****************************************************************************/
 646 static HRESULT WINAPI
 647 IDirect3DDeviceImpl_1_CreateExecuteBuffer(IDirect3DDevice *iface,
 648                                           D3DEXECUTEBUFFERDESC *Desc,
 649                                           IDirect3DExecuteBuffer **ExecuteBuffer,
 650                                           IUnknown *UnkOuter)
 651 {
 652     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
 653     IDirect3DExecuteBufferImpl* object;
 654     TRACE("(%p)->(%p,%p,%p)!\n", This, Desc, ExecuteBuffer, UnkOuter);
 655
 656     if(UnkOuter)
 657         return CLASS_E_NOAGGREGATION;
 658
 659     /* Allocate the new Execute Buffer */
 660     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DExecuteBufferImpl));
 661     if(!object)
 662     {
 663         ERR("Out of memory when allocating a IDirect3DExecuteBufferImpl structure\n");
 664         return DDERR_OUTOFMEMORY;
 665     }
 666
 667     ICOM_INIT_INTERFACE(object, IDirect3DExecuteBuffer, IDirect3DExecuteBuffer_Vtbl);
 668
 669     object->ref = 1;
 670     object->d3ddev = This;
 671
 672     /* Initializes memory */
 673     memcpy(&object->desc, Desc, Desc->dwSize);
 674
 675     /* No buffer given */
 676     if ((object->desc.dwFlags & D3DDEB_LPDATA) == 0)
 677         object->desc.lpData = NULL;
 678
 679     /* No buffer size given */
 680     if ((object->desc.dwFlags & D3DDEB_BUFSIZE) == 0)
 681         object->desc.dwBufferSize = 0;
 682
 683     /* Create buffer if asked */
 684     if ((object->desc.lpData == NULL) && (object->desc.dwBufferSize > 0))
 685     {
 686         object->need_free = TRUE;
 687         object->desc.lpData = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,object->desc.dwBufferSize);
 688         if(!object->desc.lpData)
 689         {
 690             ERR("Out of memory when allocating the execute buffer data\n");
 691             HeapFree(GetProcessHeap(), 0, object);
 692             return DDERR_OUTOFMEMORY;
 693         }
 694     }
 695     else
 696     {
 697         object->need_free = FALSE;
 698     }
 699
 700     /* No vertices for the moment */
 701     object->vertex_data = NULL;
 702
 703     object->desc.dwFlags |= D3DDEB_LPDATA;
 704
 705     object->indices = NULL;
 706     object->nb_indices = 0;
 707
 708     *ExecuteBuffer = ICOM_INTERFACE(object, IDirect3DExecuteBuffer);
 709
 710     TRACE(" Returning IDirect3DExecuteBuffer at %p, implementation is at %p\n", *ExecuteBuffer, object);
 711
 712     return D3D_OK;
 713 }
 714
 715 /*****************************************************************************
 716  * IDirect3DDevice::Execute
 717  *
 718  * Executes all the stuff in an execute buffer.
 719  *
 720  * Params:
 721  *  ExecuteBuffer: The buffer to execute
 722  *  Viewport: The viewport used for rendering
 723  *  Flags: Some flags
 724  *
 725  * Returns:
 726  *  DDERR_INVALIDPARAMS if ExecuteBuffer == NULL
 727  *  D3D_OK on sucess
 728  *
 729  *****************************************************************************/
 730 static HRESULT WINAPI
 731 IDirect3DDeviceImpl_1_Execute(IDirect3DDevice *iface,
 732                               IDirect3DExecuteBuffer *ExecuteBuffer,
 733                               IDirect3DViewport *Viewport,
 734                               DWORD Flags)
 735 {
 736     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
 737     IDirect3DExecuteBufferImpl *Direct3DExecuteBufferImpl = ICOM_OBJECT(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, ExecuteBuffer);
 738     IDirect3DViewportImpl *Direct3DViewportImpl = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, Viewport);
 739
 740     TRACE("(%p)->(%p,%p,%08lx)\n", This, Direct3DExecuteBufferImpl, Direct3DViewportImpl, Flags);
 741
 742     if(!Direct3DExecuteBufferImpl)
 743         return DDERR_INVALIDPARAMS;
 744
 745     /* Execute... */
 746     IDirect3DExecuteBufferImpl_Execute(Direct3DExecuteBufferImpl, This, Direct3DViewportImpl);
 747
 748     return D3D_OK;
 749 }
 750
 751 /*****************************************************************************
 752  * IDirect3DDevice3::AddViewport
 753  *
 754  * Add a Direct3DViewport to the device's viewport list. These viewports
 755  * are wrapped to IDirect3DDevice7 viewports in viewport.c
 756  *
 757  * Exists in Version 1, 2 and 3. Note that IDirect3DViewport 1, 2 and 3
 758  * are the same interfaces.
 759  *
 760  * Params:
 761  *  Viewport: The viewport to add
 762  *
 763  * Returns:
 764  *  DDERR_INVALIDPARAMS if Viewport == NULL
 765  *  D3D_OK on success
 766  *
 767  *****************************************************************************/
 768 static HRESULT WINAPI
 769 IDirect3DDeviceImpl_3_AddViewport(IDirect3DDevice3 *iface,
 770                                   IDirect3DViewport3 *Viewport)
 771 {
 772     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 773     IDirect3DViewportImpl *vp = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, Viewport);
 774
 775     TRACE("(%p)->(%p)\n", This, vp);
 776
 777     /* Sanity check */
 778     if(!vp)
 779         return DDERR_INVALIDPARAMS;
 780
 781     vp->next = This->viewport_list;
 782     This->viewport_list = vp;
 783
 784     return D3D_OK;
 785 }
 786
 787 static HRESULT WINAPI
 788 Thunk_IDirect3DDeviceImpl_2_AddViewport(IDirect3DDevice2 *iface,
 789                                         IDirect3DViewport2 *Direct3DViewport2)
 790 {
 791     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 792     IDirect3DViewportImpl *vp = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, Direct3DViewport2);
 793     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", This, vp);
 794     return IDirect3DDevice3_AddViewport(ICOM_INTERFACE(This, IDirect3DDevice3),
 795                                         ICOM_INTERFACE(vp, IDirect3DViewport3));
 796 }
 797
 798 static HRESULT WINAPI
 799 Thunk_IDirect3DDeviceImpl_1_AddViewport(IDirect3DDevice *iface,
 800                                         IDirect3DViewport *Direct3DViewport)
 801 {
 802     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 803     IDirect3DViewportImpl *vp = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, Direct3DViewport);
 804     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", This, vp);
 805     return IDirect3DDevice3_AddViewport(ICOM_INTERFACE(This, IDirect3DDevice3),
 806                                         ICOM_INTERFACE(vp, IDirect3DViewport3));
 807 }
 808
 809 /*****************************************************************************
 810  * IDirect3DDevice3::DeleteViewport
 811  *
 812  * Deletes a Direct3DViewport from the device's viewport list.
 813  *
 814  * Exists in Version 1, 2 and 3. Note that all Viewport interface versions
 815  * are equal.
 816  *
 817  * Params:
 818  *  Viewport: The viewport to delete
 819  *
 820  * Returns:
 821  *  D3D_OK on success
 822  *  DDERR_INVALIDPARAMS if the viewport wasn't found in the list
 823  *
 824  *****************************************************************************/
 825 static HRESULT WINAPI
 826 IDirect3DDeviceImpl_3_DeleteViewport(IDirect3DDevice3 *iface,
 827                                      IDirect3DViewport3 *Viewport)
 828 {
 829     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 830     IDirect3DViewportImpl *vp = (IDirect3DViewportImpl *) Viewport;
 831     IDirect3DViewportImpl *cur_viewport, *prev_viewport = NULL;
 832
 833     TRACE("(%p)->(%p)\n", This, vp);
 834
 835     cur_viewport = This->viewport_list;
 836     while (cur_viewport != NULL)
 837     {
 838         if (cur_viewport == vp)
 839         {
 840             if (prev_viewport == NULL) This->viewport_list = cur_viewport->next;
 841             else prev_viewport->next = cur_viewport->next;
 842             /* TODO : add desactivate of the viewport and all associated lights... */
 843             return D3D_OK;
 844         }
 845         prev_viewport = cur_viewport;
 846         cur_viewport = cur_viewport->next;
 847     }
 848
 849     return DDERR_INVALIDPARAMS;
 850 }
 851
 852 static HRESULT WINAPI
 853 Thunk_IDirect3DDeviceImpl_2_DeleteViewport(IDirect3DDevice2 *iface,
 854                                            IDirect3DViewport2 *Direct3DViewport2)
 855 {
 856     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 857     IDirect3DViewportImpl *vp = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, Direct3DViewport2);
 858     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", This, vp);
 859     return IDirect3DDevice3_DeleteViewport(ICOM_INTERFACE(This, IDirect3DDevice3),
 860                                            ICOM_INTERFACE(vp, IDirect3DViewport3));
 861 }
 862
 863 static HRESULT WINAPI
 864 Thunk_IDirect3DDeviceImpl_1_DeleteViewport(IDirect3DDevice *iface,
 865                                            IDirect3DViewport *Direct3DViewport2)
 866 {
 867     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
 868     IDirect3DViewportImpl *vp = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, Direct3DViewport2);
 869     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", This, vp);
 870     return IDirect3DDevice3_DeleteViewport(ICOM_INTERFACE(This, IDirect3DDevice3),
 871                                            ICOM_INTERFACE(vp, IDirect3DViewport3));
 872 }
 873
 874 /*****************************************************************************
 875  * IDirect3DDevice3::NextViewport
 876  *
 877  * Returns a viewport from the viewport list, depending on the
 878  * passed viewport and the flags.
 879  *
 880  * Exists in Version 1, 2 and 3. Note that all Viewport interface versions
 881  * are equal.
 882  *
 883  * Params:
 884  *  Viewport: Viewport to use for beginning the search
 885  *  Flags: D3DNEXT_NEXT, D3DNEXT_HEAD or D3DNEXT_TAIL
 886  *
 887  * Returns:
 888  *  D3D_OK on success
 889  *  DDERR_INVALIDPARAMS if the flags were wrong, or Viewport was NULL
 890  *
 891  *****************************************************************************/
 892 static HRESULT WINAPI
 893 IDirect3DDeviceImpl_3_NextViewport(IDirect3DDevice3 *iface,
 894                                    IDirect3DViewport3 *Viewport3,
 895                                    IDirect3DViewport3 **lplpDirect3DViewport3,
 896                                    DWORD Flags)
 897 {
 898     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
 899     IDirect3DViewportImpl *vp = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, Viewport3);
 900     IDirect3DViewportImpl *res = NULL;
 901
 902     TRACE("(%p)->(%p,%p,%08lx)\n", This, vp, lplpDirect3DViewport3, Flags);
 903
 904     if(!vp)
 905     {
 906         return DDERR_INVALIDPARAMS;
 907         *lplpDirect3DViewport3 = NULL;
 908     }
 909
 910
 911     switch (Flags)
 912     {
 913         case D3DNEXT_NEXT:
 914         {
 915             res = vp->next;
 916         }
 917         break;
 918         case D3DNEXT_HEAD:
 919         {
 920             res = This->viewport_list;
 921         }
 922         break;
 923         case D3DNEXT_TAIL:
 924         {
 925             IDirect3DViewportImpl *cur_viewport = This->viewport_list;
 926             if (cur_viewport != NULL)
 927             {
 928                 while (cur_viewport->next != NULL) cur_viewport = cur_viewport->next;
 929             }
 930             res = cur_viewport;
 931         }
 932         break;
 933         default:
 934             *lplpDirect3DViewport3 = NULL;
 935             return DDERR_INVALIDPARAMS;
 936     }
 937
 938     *lplpDirect3DViewport3 = ICOM_INTERFACE(res, IDirect3DViewport3);
 939     return D3D_OK;
 940 }
 941
 942 static HRESULT WINAPI
 943 Thunk_IDirect3DDeviceImpl_2_NextViewport(IDirect3DDevice2 *iface,
 944                                          IDirect3DViewport2 *Viewport2,
 945                                          IDirect3DViewport2 **lplpDirect3DViewport2,
 946                                          DWORD Flags)
 947 {
 948     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
 949     IDirect3DViewportImpl *vp = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, Viewport2);
 950     IDirect3DViewport3 *res;
 951     HRESULT hr;
 952     TRACE_(ddraw_thunk)("(%p)->(%p,%p,%08lx) thunking to IDirect3DDevice3 interface.\n", This, vp, lplpDirect3DViewport2, Flags);
 953     hr = IDirect3DDevice3_NextViewport(ICOM_INTERFACE(This, IDirect3DDevice3),
 954                                        ICOM_INTERFACE(vp, IDirect3DViewport3),
 955                                        &res,
 956                                        Flags);
 957     *lplpDirect3DViewport2 = (IDirect3DViewport2 *) COM_INTERFACE_CAST(IDirect3DViewportImpl, IDirect3DViewport3, IDirect3DViewport3, res);
 958     return hr;
 959 }
 960
 961 static HRESULT WINAPI
 962 Thunk_IDirect3DDeviceImpl_1_NextViewport(IDirect3DDevice *iface,
 963                                          IDirect3DViewport *Viewport,
 964                                          IDirect3DViewport **lplpDirect3DViewport,
 965                                          DWORD Flags)
 966 {
 967     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
 968     IDirect3DViewportImpl *vp = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, Viewport);
 969     IDirect3DViewport3 *res;
 970     HRESULT hr;
 971     TRACE_(ddraw_thunk)("(%p)->(%p,%p,%08lx) thunking to IDirect3DDevice3 interface.\n", This, vp, lplpDirect3DViewport, Flags);
 972     hr = IDirect3DDevice3_NextViewport(ICOM_INTERFACE(This, IDirect3DDevice3),
 973                                        ICOM_INTERFACE(vp, IDirect3DViewport3),
 974                                        &res,
 975                                        Flags);
 976     *lplpDirect3DViewport = (IDirect3DViewport *) COM_INTERFACE_CAST(IDirect3DViewportImpl, IDirect3DViewport3, IDirect3DViewport3, res);
 977     return hr;
 978 }
 979
 980 /*****************************************************************************
 981  * IDirect3DDevice::Pick
 982  *
 983  * Executes an execute buffer without performing rendering. Instead, a
 984  * list of primitives that intersect with (x1,y1) of the passed rectangle
 985  * is created. IDirect3DDevice::GetPickRecords can be used to retrieve
 986  * this list.
 987  *
 988  * Version 1 only
 989  *
 990  * Params:
 991  *  ExecuteBuffer: Buffer to execute
 992  *  Viewport: Viewport to use for execution
 993  *  Flags: None are defined, according to the SDK
 994  *  Rect: Specifies the coordinates to be picked. Only x1 and y2 are used,
 995  *        x2 and y2 are ignored.
 996  *
 997  * Returns:
 998  *  D3D_OK because it's a stub
 999  *
1000  *****************************************************************************/
1001 static HRESULT WINAPI
1002 IDirect3DDeviceImpl_1_Pick(IDirect3DDevice *iface,
1003                            IDirect3DExecuteBuffer *ExecuteBuffer,
1004                            IDirect3DViewport *Viewport,
1005                            DWORD Flags,
1006                            D3DRECT *Rect)
1007 {
1008     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1009     IDirect3DExecuteBufferImpl *execbuf = ICOM_OBJECT(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, ExecuteBuffer);
1010     IDirect3DViewportImpl *vp = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, Viewport);
1011     FIXME("(%p)->(%p,%p,%08lx,%p): stub!\n", This, execbuf, vp, Flags, Rect);
1012
1013     return D3D_OK;
1014 }
1015
1016 /*****************************************************************************
1017  * IDirect3DDevice::GetPickRecords
1018  *
1019  * Retrieves the pick records generated by IDirect3DDevice::GetPickRecords
1020  *
1021  * Version 1 only
1022  *
1023  * Params:
1024  *  Count: Pointer to a DWORD containing the numbers of pick records to
1025  *         retrieve
1026  *  D3DPickRec: Address to store the resulting D3DPICKRECORD arry.
1027  *
1028  * Returns:
1029  *  D3D_OK, because it's a stub
1030  *
1031  *****************************************************************************/
1032 static HRESULT WINAPI
1033 IDirect3DDeviceImpl_1_GetPickRecords(IDirect3DDevice *iface,
1034                                      DWORD *Count,
1035                                      D3DPICKRECORD *D3DPickRec)
1036 {
1037     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1038     FIXME("(%p)->(%p,%p): stub!\n", This, Count, D3DPickRec);
1039
1040     return D3D_OK;
1041 }
1042
1043 /*****************************************************************************
1044  * EnumTextureFormatsCB
1045  *
1046  * Callback called by WineD3D for each enumerated Texture format. It
1047  * translates the WineD3DFormat into a ddraw pixel format and calls
1048  * the application callback
1049  *
1050  * Params:
1051  *  Device: The WineD3DDevice's parents = The IDirect3DDevice7 interface
1052  *          of our device
1053  *  fmt: An enumerated pixel format
1054  *  Context: Data pointer passed to WineD3D by
1055  *           IDirect3DDevice7::EnumTexureformats
1056  *
1057  * Returns:
1058  *  The return value of the application-provided callback
1059  *
1060  *****************************************************************************/
1061 static HRESULT WINAPI
1062 EnumTextureFormatsCB(IUnknown *Device,
1063                      WINED3DFORMAT fmt,
1064                      void *Context)
1065 {
1066     struct EnumTextureFormatsCBS *cbs = (struct EnumTextureFormatsCBS *) Context;
1067
1068     DDSURFACEDESC sdesc;
1069     DDPIXELFORMAT *pformat;
1070
1071     memset(&sdesc, 0, sizeof(DDSURFACEDESC));
1072     sdesc.dwSize = sizeof(DDSURFACEDESC);
1073     sdesc.dwFlags = DDSD_PIXELFORMAT | DDSD_CAPS;
1074     sdesc.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1075     pformat = &(sdesc.ddpfPixelFormat);
1076     pformat->dwSize = sizeof(DDPIXELFORMAT);
1077
1078     PixelFormat_WineD3DtoDD(pformat, fmt);
1079
1080     if( ( fmt == WINED3DFMT_UYVY)        ||
1081         ( fmt == WINED3DFMT_YUY2)        ||
1082         ( fmt == WINED3DFMT_DXT1)        ||
1083         ( fmt == WINED3DFMT_DXT2)        ||
1084         ( fmt == WINED3DFMT_DXT3)        ||
1085         ( fmt == WINED3DFMT_DXT4)        ||
1086         ( fmt == WINED3DFMT_DXT5)        ||
1087         ( fmt == WINED3DFMT_MULTI2_ARGB) ||
1088         ( fmt == WINED3DFMT_G8R8_G8B8)   ||
1089         ( fmt == WINED3DFMT_R8G8_B8G8)   ||
1090         ( fmt == WINED3DFMT_L8)          ||
1091         ( fmt == WINED3DFMT_A8L8)        ||
1092         ( fmt == WINED3DFMT_A4L4)        ||
1093         ( fmt == WINED3DFMT_V8U8)        ||
1094         ( fmt == WINED3DFMT_L6V5U5)      )
1095     {
1096         /* These formats exist in D3D3 and D3D7 only,
1097          * so do not call the older callback
1098          */
1099         if(cbs->cbv7) return cbs->cbv7(pformat, cbs->Context);
1100     }
1101     else
1102     {
1103         /* Only one of these should be passed */
1104         if(cbs->cbv2) return cbs->cbv2(&sdesc, cbs->Context);
1105         if(cbs->cbv7) return cbs->cbv7(pformat, cbs->Context);
1106     }
1107
1108     return DDENUMRET_OK;
1109 }
1110
1111 /*****************************************************************************
1112  * IDirect3DDevice7::EnumTextureformats
1113  *
1114  * Enumerates the supported texture formats. This is relayed to WineD3D,
1115  * and a EnumTextureFormatsCB translated the WineD3DFormats to DDraw
1116  * formats and calls the application callback.
1117  *
1118  * This is for Version 7 and 3, older versions have a different
1119  * callback function and their own implementation
1120  *
1121  * Params:
1122  *  Callback: Callback to call for each enumerated format
1123  *  Arg: Argument to pass to the callback
1124  *
1125  * Returns:
1126  *  D3D_OK on success
1127  *  DDERR_INVALIDPARAMS if Callback == NULL
1128  *
1129  *****************************************************************************/
1130 static HRESULT WINAPI
1131 IDirect3DDeviceImpl_7_EnumTextureFormats(IDirect3DDevice7 *iface,
1132                                          LPD3DENUMPIXELFORMATSCALLBACK Callback,
1133                                          void *Arg)
1134 {
1135     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1136     HRESULT hr;
1137     struct EnumTextureFormatsCBS cbs = { NULL, Callback, Arg };
1138     TRACE("(%p)->(%p,%p): Relay\n", This, Callback, Arg);
1139
1140     if(!Callback)
1141         return DDERR_INVALIDPARAMS;
1142
1143     hr = IWineD3DDevice_EnumTextureFormats(This->wineD3DDevice,
1144                                            EnumTextureFormatsCB,
1145                                            &cbs);
1146     return hr_ddraw_from_wined3d(hr);
1147 }
1148
1149 static HRESULT WINAPI
1150 Thunk_IDirect3DDeviceImpl_3_EnumTextureFormats(IDirect3DDevice3 *iface,
1151                                                LPD3DENUMPIXELFORMATSCALLBACK Callback,
1152                                                void *Arg)
1153 {
1154     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1155     TRACE_(ddraw_thunk)("(%p)->(%p,%p) thunking to IDirect3DDevice7 interface.\n", This, Callback, Arg);
1156     return IDirect3DDevice7_EnumTextureFormats(ICOM_INTERFACE(This, IDirect3DDevice7),
1157                                                Callback,
1158                                                Arg);
1159 }
1160
1161 /*****************************************************************************
1162  * IDirect3DDevice2::EnumTextureformats
1163  *
1164  * EnumTextureFormats for Version 1 and 2, see
1165  * IDirect3DDevice7::EnumTexureFormats for a more detailed description
1166  *
1167  *****************************************************************************/
1168 static HRESULT WINAPI
1169 IDirect3DDeviceImpl_2_EnumTextureFormats(IDirect3DDevice2 *iface,
1170                                          LPD3DENUMTEXTUREFORMATSCALLBACK Callback,
1171                                          void *Arg)
1172 {
1173     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1174     HRESULT hr;
1175     struct EnumTextureFormatsCBS cbs = { Callback, NULL, Arg };
1176     TRACE("(%p)->(%p,%p): Relay\n", This, Callback, Arg);
1177
1178     hr = IWineD3DDevice_EnumTextureFormats(This->wineD3DDevice,
1179                                            EnumTextureFormatsCB,
1180                                            &cbs);
1181     return hr_ddraw_from_wined3d(hr);
1182 }
1183
1184 static HRESULT WINAPI
1185 Thunk_IDirect3DDeviceImpl_1_EnumTextureFormats(IDirect3DDevice *iface,
1186                                                LPD3DENUMTEXTUREFORMATSCALLBACK Callback,
1187                                                void *Arg)
1188 {
1189     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1190     TRACE_(ddraw_thunk)("(%p)->(%p,%p) thunking to IDirect3DDevice2 interface.\n", This, Callback, Arg);
1191     return IDirect3DDevice2_EnumTextureFormats(ICOM_INTERFACE(This, IDirect3DDevice2),
1192                                                Callback,
1193                                                Arg);
1194 }
1195
1196 /*****************************************************************************
1197  * IDirect3DDevice::CreateMatrix
1198  *
1199  * Creates a matrix handle. A handle is created and memory for a D3DMATRIX is
1200  * allocated for the handle.
1201  *
1202  * Version 1 only
1203  *
1204  * Params
1205  *  D3DMatHandle: Address to return the handle at
1206  *
1207  * Returns:
1208  *  D3D_OK on success
1209  *  DDERR_INVALIDPARAMS if D3DMatHandle = NULL
1210  *
1211  *****************************************************************************/
1212 static HRESULT WINAPI
1213 IDirect3DDeviceImpl_1_CreateMatrix(IDirect3DDevice *iface, D3DMATRIXHANDLE *D3DMatHandle)
1214 {
1215     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1216     D3DMATRIX *Matrix;
1217     TRACE("(%p)->(%p)\n", This, D3DMatHandle);
1218
1219     if(!D3DMatHandle)
1220         return DDERR_INVALIDPARAMS;
1221
1222     Matrix = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(D3DMATRIX));
1223     if(!Matrix)
1224     {
1225         ERR("Out of memory when allocating a D3DMATRIX\n");
1226         return DDERR_OUTOFMEMORY;
1227     }
1228     *D3DMatHandle = IDirect3DDeviceImpl_CreateHandle(This);
1229     if(!(*D3DMatHandle))
1230     {
1231         ERR("Failed to create a matrix handle\n");
1232         HeapFree(GetProcessHeap(), 0, Matrix);
1233         return DDERR_OUTOFMEMORY;
1234     }
1235     This->Handles[(DWORD) *D3DMatHandle - 1].ptr = Matrix;
1236     This->Handles[(DWORD) *D3DMatHandle - 1].type = DDrawHandle_Matrix;
1237     TRACE(" returning matrix handle %ld\n", *D3DMatHandle);
1238
1239     return D3D_OK;
1240 }
1241
1242 /*****************************************************************************
1243  * IDirect3DDevice::SetMatrix
1244  *
1245  * Sets a matrix for a matrix handle. The matrix is copied into the memory
1246  * allocated for the handle
1247  *
1248  * Version 1 only
1249  *
1250  * Params:
1251  *  D3DMatHandle: Handle to set the matrix to
1252  *  D3DMatrix: Matrix to set
1253  *
1254  * Returns:
1255  *  D3D_OK on success
1256  *  DDERR_INVALIDPARAMS if the handle of the matrix is invalid or the matrix
1257  *   to set is NULL
1258  *
1259  *****************************************************************************/
1260 static HRESULT WINAPI
1261 IDirect3DDeviceImpl_1_SetMatrix(IDirect3DDevice *iface,
1262                                 D3DMATRIXHANDLE D3DMatHandle,
1263                                 D3DMATRIX *D3DMatrix)
1264 {
1265     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1266     TRACE("(%p)->(%08lx,%p)\n", This, (DWORD) D3DMatHandle, D3DMatrix);
1267
1268     if( (!D3DMatHandle) || (!D3DMatrix) )
1269         return DDERR_INVALIDPARAMS;
1270
1271     if(D3DMatHandle > This->numHandles)
1272     {
1273         ERR("Handle %ld out of range\n", D3DMatHandle);
1274         return DDERR_INVALIDPARAMS;
1275     }
1276     else if(This->Handles[D3DMatHandle - 1].type != DDrawHandle_Matrix)
1277     {
1278         ERR("Handle %ld is not a matrix handle\n", D3DMatHandle);
1279         return DDERR_INVALIDPARAMS;
1280     }
1281
1282     if (TRACE_ON(d3d7))
1283         dump_D3DMATRIX(D3DMatrix);
1284
1285     *((D3DMATRIX *) This->Handles[D3DMatHandle - 1].ptr) = *D3DMatrix;
1286
1287     return D3D_OK;
1288 }
1289
1290 /*****************************************************************************
1291  * IDirect3DDevice::SetMatrix
1292  *
1293  * Returns the content of a D3DMATRIX handle
1294  *
1295  * Version 1 only
1296  *
1297  * Params:
1298  *  D3DMatHandle: Matrix handle to read the content from
1299  *  D3DMatrix: Address to store the content at
1300  *
1301  * Returns:
1302  *  D3D_OK on success
1303  *  DDERR_INVALIDPARAMS if D3DMatHandle is invalid or D3DMatrix is NULL
1304  *
1305  *****************************************************************************/
1306 static HRESULT WINAPI
1307 IDirect3DDeviceImpl_1_GetMatrix(IDirect3DDevice *iface,
1308                                 D3DMATRIXHANDLE D3DMatHandle,
1309                                 D3DMATRIX *D3DMatrix)
1310 {
1311     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1312     TRACE("(%p)->(%08lx,%p)\n", This, (DWORD) D3DMatHandle, D3DMatrix);
1313
1314     if(!D3DMatrix)
1315         return DDERR_INVALIDPARAMS;
1316     if(!D3DMatHandle)
1317         return DDERR_INVALIDPARAMS;
1318
1319     if(D3DMatHandle > This->numHandles)
1320     {
1321         ERR("Handle %ld out of range\n", D3DMatHandle);
1322         return DDERR_INVALIDPARAMS;
1323     }
1324     else if(This->Handles[D3DMatHandle - 1].type != DDrawHandle_Matrix)
1325     {
1326         ERR("Handle %ld is not a matrix handle\n", D3DMatHandle);
1327         return DDERR_INVALIDPARAMS;
1328     }
1329
1330     /* The handle is simply a pointer to a D3DMATRIX structure */
1331     *D3DMatrix = *((D3DMATRIX *) This->Handles[D3DMatHandle - 1].ptr);
1332
1333     return D3D_OK;
1334 }
1335
1336 /*****************************************************************************
1337  * IDirect3DDevice::DeleteMatrix
1338  *
1339  * Destroys a Matrix handle. Frees the memory and unsets the handle data
1340  *
1341  * Version 1 only
1342  *
1343  * Params:
1344  *  D3DMatHandle: Handle to destroy
1345  *
1346  * Returns:
1347  *  D3D_OK on success
1348  *  DDERR_INVALIDPARAMS if D3DMatHandle is invalid
1349  *
1350  *****************************************************************************/
1351 static HRESULT WINAPI
1352 IDirect3DDeviceImpl_1_DeleteMatrix(IDirect3DDevice *iface,
1353                                    D3DMATRIXHANDLE D3DMatHandle)
1354 {
1355     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1356     TRACE("(%p)->(%08lx)\n", This, (DWORD) D3DMatHandle);
1357
1358     if(!D3DMatHandle)
1359         return DDERR_INVALIDPARAMS;
1360
1361     if(D3DMatHandle > This->numHandles)
1362     {
1363         ERR("Handle %ld out of range\n", D3DMatHandle);
1364         return DDERR_INVALIDPARAMS;
1365     }
1366     else if(This->Handles[D3DMatHandle - 1].type != DDrawHandle_Matrix)
1367     {
1368         ERR("Handle %ld is not a matrix handle\n", D3DMatHandle);
1369         return DDERR_INVALIDPARAMS;
1370     }
1371
1372     HeapFree(GetProcessHeap(), 0, This->Handles[D3DMatHandle - 1].ptr);
1373     This->Handles[D3DMatHandle - 1].ptr = NULL;
1374     This->Handles[D3DMatHandle - 1].type = DDrawHandle_Unknown;
1375
1376     return D3D_OK;
1377 }
1378
1379 /*****************************************************************************
1380  * IDirect3DDevice7::BeginScene
1381  *
1382  * This method must be called before any rendering is performed.
1383  * IDirect3DDevice::EndScene has to be called after the scene is complete
1384  *
1385  * Version 1, 2, 3 and 7
1386  *
1387  * Returns:
1388  *  D3D_OK on success, for details see IWineD3DDevice::BeginScene
1389  *
1390  *****************************************************************************/
1391 static HRESULT WINAPI
1392 IDirect3DDeviceImpl_7_BeginScene(IDirect3DDevice7 *iface)
1393 {
1394     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1395     TRACE("(%p): Relay\n", This);
1396
1397     return IWineD3DDevice_BeginScene(This->wineD3DDevice);
1398 }
1399
1400 static HRESULT WINAPI
1401 Thunk_IDirect3DDeviceImpl_3_BeginScene(IDirect3DDevice3 *iface)
1402 {
1403     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1404     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DDevice7 interface.\n", This);
1405     return IDirect3DDevice7_BeginScene(ICOM_INTERFACE(This, IDirect3DDevice7));
1406 }
1407
1408 static HRESULT WINAPI
1409 Thunk_IDirect3DDeviceImpl_2_BeginScene(IDirect3DDevice2 *iface)
1410 {
1411     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1412     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DDevice7 interface.\n", This);
1413     return IDirect3DDevice7_BeginScene(ICOM_INTERFACE(This, IDirect3DDevice7));
1414 }
1415
1416 static HRESULT WINAPI
1417 Thunk_IDirect3DDeviceImpl_1_BeginScene(IDirect3DDevice *iface)
1418 {
1419     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1420     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DDevice7 interface.\n", This);
1421     return IDirect3DDevice7_BeginScene(ICOM_INTERFACE(This, IDirect3DDevice7));
1422 }
1423
1424 /*****************************************************************************
1425  * IDirect3DDevice7::EndScene
1426  *
1427  * Ends a scene that has been begun with IDirect3DDevice7::BeginScene.
1428  * This method must be called after rendering is finished.
1429  *
1430  * Version 1, 2, 3 and 7
1431  *
1432  * Returns:
1433  *  D3D_OK on success, for details see IWineD3DDevice::EndScene
1434  *
1435  *****************************************************************************/
1436 static HRESULT WINAPI
1437 IDirect3DDeviceImpl_7_EndScene(IDirect3DDevice7 *iface)
1438 {
1439     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1440     TRACE("(%p): Relay\n", This);
1441
1442     IWineD3DDevice_EndScene(This->wineD3DDevice);
1443     return D3D_OK;
1444 }
1445
1446 static HRESULT WINAPI
1447 Thunk_IDirect3DDeviceImpl_3_EndScene(IDirect3DDevice3 *iface)
1448 {
1449     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1450     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DDevice7 interface.\n", This);
1451     return IDirect3DDevice7_EndScene(ICOM_INTERFACE(This, IDirect3DDevice7));
1452 }
1453
1454 static HRESULT WINAPI
1455 Thunk_IDirect3DDeviceImpl_2_EndScene(IDirect3DDevice2 *iface)
1456 {
1457     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1458     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DDevice7 interface.\n", This);
1459     return IDirect3DDevice7_EndScene(ICOM_INTERFACE(This, IDirect3DDevice7));
1460 }
1461
1462 static HRESULT WINAPI
1463 Thunk_IDirect3DDeviceImpl_1_EndScene(IDirect3DDevice *iface)
1464 {
1465     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1466     TRACE_(ddraw_thunk)("(%p)->() thunking to IDirect3DDevice7 interface.\n", This);
1467     return IDirect3DDevice7_EndScene(ICOM_INTERFACE(This, IDirect3DDevice7));
1468 }
1469
1470 /*****************************************************************************
1471  * IDirect3DDevice7::GetDirect3D
1472  *
1473  * Returns the IDirect3D(= interface to the DirectDraw object) used to create
1474  * this device.
1475  *
1476  * Params:
1477  *  Direct3D7: Address to store the interface pointer at
1478  *
1479  * Returns:
1480  *  D3D_OK on success
1481  *  DDERR_INVALIDPARAMS if Direct3D7 == NULL
1482  *
1483  *****************************************************************************/
1484 static HRESULT WINAPI
1485 IDirect3DDeviceImpl_7_GetDirect3D(IDirect3DDevice7 *iface,
1486                                   IDirect3D7 **Direct3D7)
1487 {
1488     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1489     TRACE("(%p)->(%p)\n", This, Direct3D7);
1490
1491     if(!Direct3D7)
1492         return DDERR_INVALIDPARAMS;
1493
1494     *Direct3D7 = ICOM_INTERFACE(This->ddraw, IDirect3D7);
1495     IDirect3D7_AddRef(*Direct3D7);
1496
1497     TRACE(" returning interface %p\n", *Direct3D7);
1498     return D3D_OK;
1499 }
1500
1501 static HRESULT WINAPI
1502 Thunk_IDirect3DDeviceImpl_3_GetDirect3D(IDirect3DDevice3 *iface,
1503                                         IDirect3D3 **Direct3D3)
1504 {
1505     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1506     HRESULT ret;
1507     IDirect3D7 *ret_ptr;
1508
1509     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", This, Direct3D3);
1510     ret = IDirect3DDevice7_GetDirect3D(ICOM_INTERFACE(This, IDirect3DDevice7),
1511                                        &ret_ptr);
1512     if(ret != D3D_OK)
1513         return ret;
1514     *Direct3D3 = COM_INTERFACE_CAST(IDirectDrawImpl, IDirect3D7, IDirect3D3, ret_ptr);
1515     TRACE(" returning interface %p\n", *Direct3D3);
1516     return D3D_OK;
1517 }
1518
1519 static HRESULT WINAPI
1520 Thunk_IDirect3DDeviceImpl_2_GetDirect3D(IDirect3DDevice2 *iface,
1521                                         IDirect3D2 **Direct3D2)
1522 {
1523     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1524     HRESULT ret;
1525     IDirect3D7 *ret_ptr;
1526
1527     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", This, Direct3D2);
1528     ret = IDirect3DDevice7_GetDirect3D(ICOM_INTERFACE(This, IDirect3DDevice7),
1529                                        &ret_ptr);
1530     if(ret != D3D_OK)
1531         return ret;
1532     *Direct3D2 = COM_INTERFACE_CAST(IDirectDrawImpl, IDirect3D7, IDirect3D2, ret_ptr);
1533     TRACE(" returning interface %p\n", *Direct3D2);
1534     return D3D_OK;
1535 }
1536
1537 static HRESULT WINAPI
1538 Thunk_IDirect3DDeviceImpl_1_GetDirect3D(IDirect3DDevice *iface,
1539                                         IDirect3D **Direct3D)
1540 {
1541     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1542     HRESULT ret;
1543     IDirect3D7 *ret_ptr;
1544
1545     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", This, Direct3D);
1546     ret = IDirect3DDevice7_GetDirect3D(ICOM_INTERFACE(This, IDirect3DDevice7),
1547                                        &ret_ptr);
1548     if(ret != D3D_OK)
1549         return ret;
1550     *Direct3D = COM_INTERFACE_CAST(IDirectDrawImpl, IDirect3D7, IDirect3D, ret_ptr);
1551     TRACE(" returning interface %p\n", *Direct3D);
1552     return D3D_OK;
1553 }
1554
1555 /*****************************************************************************
1556  * IDirect3DDevice3::SetCurrentViewport
1557  *
1558  * Sets a Direct3DViewport as the current viewport.
1559  * For the thunks note that all viewport interface versions are equal
1560  *
1561  * Params:
1562  *  Direct3DViewport3: The viewport to set
1563  *
1564  * Version 2 and 3
1565  *
1566  * Returns:
1567  *  D3D_OK on success
1568  *  (Is a NULL viewport valid?)
1569  *
1570  *****************************************************************************/
1571 static HRESULT WINAPI
1572 IDirect3DDeviceImpl_3_SetCurrentViewport(IDirect3DDevice3 *iface,
1573                                          IDirect3DViewport3 *Direct3DViewport3)
1574 {
1575     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1576     IDirect3DViewportImpl *vp = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, Direct3DViewport3);
1577     TRACE("(%p)->(%p)\n", This, Direct3DViewport3);
1578
1579     /* Do nothing if the specified viewport is the same as the current one */
1580     if (This->current_viewport == vp )
1581       return D3D_OK;
1582
1583     /* Should check if the viewport was added or not */
1584
1585     /* Release previous viewport and AddRef the new one */
1586     if (This->current_viewport)
1587     {
1588         TRACE("ViewportImpl is at %p, interface is at %p\n", This->current_viewport, ICOM_INTERFACE(This->current_viewport, IDirect3DViewport3));
1589         IDirect3DViewport3_Release( ICOM_INTERFACE(This->current_viewport, IDirect3DViewport3) );
1590     }
1591     IDirect3DViewport3_AddRef(Direct3DViewport3);
1592
1593     /* Set this viewport as the current viewport */
1594     This->current_viewport = vp;
1595
1596     /* Activate this viewport */
1597     This->current_viewport->active_device = This;
1598     This->current_viewport->activate(This->current_viewport);
1599
1600     return D3D_OK;
1601 }
1602
1603 static HRESULT WINAPI
1604 Thunk_IDirect3DDeviceImpl_2_SetCurrentViewport(IDirect3DDevice2 *iface,
1605                                                IDirect3DViewport2 *Direct3DViewport2)
1606 {
1607     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1608     IDirect3DViewportImpl *vp = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, Direct3DViewport2);
1609     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", This, vp);
1610     return IDirect3DDevice3_SetCurrentViewport(ICOM_INTERFACE(This, IDirect3DDevice3),
1611                                                ICOM_INTERFACE(vp, IDirect3DViewport3));
1612 }
1613
1614 /*****************************************************************************
1615  * IDirect3DDevice3::GetCurrentViewport
1616  *
1617  * Returns the currently active viewport.
1618  *
1619  * Version 2 and 3
1620  *
1621  * Params:
1622  *  Direct3DViewport3: Address to return the interface pointer at
1623  *
1624  * Returns:
1625  *  D3D_OK on success
1626  *  DDERR_INVALIDPARAMS if Direct3DViewport == NULL
1627  *
1628  *****************************************************************************/
1629 static HRESULT WINAPI
1630 IDirect3DDeviceImpl_3_GetCurrentViewport(IDirect3DDevice3 *iface,
1631                                          IDirect3DViewport3 **Direct3DViewport3)
1632 {
1633     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1634     TRACE("(%p)->(%p)\n", This, Direct3DViewport3);
1635
1636     if(!Direct3DViewport3)
1637         return DDERR_INVALIDPARAMS;
1638
1639     *Direct3DViewport3 = ICOM_INTERFACE(This->current_viewport, IDirect3DViewport3);
1640
1641     /* AddRef the returned viewport */
1642     if(*Direct3DViewport3) IDirect3DViewport3_AddRef(*Direct3DViewport3);
1643
1644     TRACE(" returning interface %p\n", *Direct3DViewport3);
1645
1646     return D3D_OK;
1647 }
1648
1649 static HRESULT WINAPI
1650 Thunk_IDirect3DDeviceImpl_2_GetCurrentViewport(IDirect3DDevice2 *iface,
1651                                                IDirect3DViewport2 **Direct3DViewport2)
1652 {
1653     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1654     HRESULT hr;
1655     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", This, Direct3DViewport2);
1656     hr = IDirect3DDevice3_GetCurrentViewport(ICOM_INTERFACE(This, IDirect3DDevice3),
1657                                             (IDirect3DViewport3 **) Direct3DViewport2);
1658     if(hr != D3D_OK) return hr;
1659     *Direct3DViewport2 = (IDirect3DViewport2 *) COM_INTERFACE_CAST(IDirect3DViewportImpl, IDirect3DViewport3, IDirect3DViewport3, Direct3DViewport2);
1660     return D3D_OK;
1661 }
1662
1663 /*****************************************************************************
1664  * IDirect3DDevice7::SetRenderTarget
1665  *
1666  * Sets the render target for the Direct3DDevice.
1667  * For the thunks note that IDirectDrawSurface7 == IDirectDrawSurface4 and
1668  * IDirectDrawSurface3 == IDirectDrawSurface
1669  *
1670  * Version 2, 3 and 7
1671  *
1672  * Params:
1673  *  NewTarget: Pointer to an IDirectDrawSurface7 interface to set as the new
1674  *             render target
1675  *  Flags: Some flags
1676  *
1677  * Returns:
1678  *  D3D_OK on success, for details see IWineD3DDevice::SetRenderTarget
1679  *
1680  *****************************************************************************/
1681 static HRESULT WINAPI
1682 IDirect3DDeviceImpl_7_SetRenderTarget(IDirect3DDevice7 *iface,
1683                                       IDirectDrawSurface7 *NewTarget,
1684                                       DWORD Flags)
1685 {
1686     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1687     IDirectDrawSurfaceImpl *Target = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, NewTarget);
1688     TRACE("(%p)->(%p,%08lx): Relay\n", This, NewTarget, Flags);
1689
1690     /* Flags: Not used */
1691
1692     return IWineD3DDevice_SetRenderTarget(This->wineD3DDevice,
1693                                           0,
1694                                           Target ? Target->WineD3DSurface : NULL);
1695 }
1696
1697 static HRESULT WINAPI
1698 Thunk_IDirect3DDeviceImpl_3_SetRenderTarget(IDirect3DDevice3 *iface,
1699                                             IDirectDrawSurface4 *NewRenderTarget,
1700                                             DWORD Flags)
1701 {
1702     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1703     IDirectDrawSurfaceImpl *Target = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, NewRenderTarget);
1704     TRACE_(ddraw_thunk)("(%p)->(%p,%08lx) thunking to IDirect3DDevice7 interface.\n", This, Target, Flags);
1705     return IDirect3DDevice7_SetRenderTarget(ICOM_INTERFACE(This, IDirect3DDevice7),
1706                                             ICOM_INTERFACE(Target, IDirectDrawSurface7),
1707                                             Flags);
1708 }
1709
1710 static HRESULT WINAPI
1711 Thunk_IDirect3DDeviceImpl_2_SetRenderTarget(IDirect3DDevice2 *iface,
1712                                             IDirectDrawSurface *NewRenderTarget,
1713                                             DWORD Flags)
1714 {
1715     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1716     IDirectDrawSurfaceImpl *Target = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface3, NewRenderTarget);
1717     TRACE_(ddraw_thunk)("(%p)->(%p,%08lx) thunking to IDirect3DDevice7 interface.\n", This, Target, Flags);
1718     return IDirect3DDevice7_SetRenderTarget(ICOM_INTERFACE(This, IDirect3DDevice7),
1719                                             ICOM_INTERFACE(Target, IDirectDrawSurface7),
1720                                             Flags);
1721 }
1722
1723 /*****************************************************************************
1724  * IDirect3DDevice7::GetRenderTarget
1725  *
1726  * Returns the current render target.
1727  * This is handled locally, because the WineD3D render target's parent
1728  * is an IParent
1729  *
1730  * Version 2, 3 and 7
1731  *
1732  * Params:
1733  *  RenderTarget: Address to store the surface interface pointer
1734  *
1735  * Returns:
1736  *  D3D_OK on success
1737  *  DDERR_INVALIDPARAMS if RenderTarget == NULL
1738  *
1739  *****************************************************************************/
1740 static HRESULT WINAPI
1741 IDirect3DDeviceImpl_7_GetRenderTarget(IDirect3DDevice7 *iface,
1742                                       IDirectDrawSurface7 **RenderTarget)
1743 {
1744     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
1745     TRACE("(%p)->(%p): Relay\n", This, RenderTarget);
1746
1747     if(!RenderTarget)
1748         return DDERR_INVALIDPARAMS;
1749
1750     *RenderTarget = ICOM_INTERFACE(This->target, IDirectDrawSurface7);
1751     IDirectDrawSurface7_AddRef(*RenderTarget);
1752
1753     return D3D_OK;
1754 }
1755
1756 static HRESULT WINAPI
1757 Thunk_IDirect3DDeviceImpl_3_GetRenderTarget(IDirect3DDevice3 *iface,
1758                                             IDirectDrawSurface4 **RenderTarget)
1759 {
1760     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1761     HRESULT hr;
1762     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", This, RenderTarget);
1763     hr = IDirect3DDevice7_GetRenderTarget(ICOM_INTERFACE(This, IDirect3DDevice7),
1764                                           (IDirectDrawSurface7 **) RenderTarget);
1765     if(hr != D3D_OK) return hr;
1766     *RenderTarget = (IDirectDrawSurface4 *) COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7, IDirectDrawSurface7, RenderTarget);
1767     return D3D_OK;
1768 }
1769
1770 static HRESULT WINAPI
1771 Thunk_IDirect3DDeviceImpl_2_GetRenderTarget(IDirect3DDevice2 *iface,
1772                                             IDirectDrawSurface **RenderTarget)
1773 {
1774     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1775     HRESULT hr;
1776     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", This, RenderTarget);
1777     hr = IDirect3DDevice7_GetRenderTarget(ICOM_INTERFACE(This, IDirect3DDevice7),
1778                                           (IDirectDrawSurface7 **) RenderTarget);
1779     if(hr != D3D_OK) return hr;
1780     *RenderTarget = (IDirectDrawSurface *) COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7, IDirectDrawSurface3, RenderTarget);
1781     return D3D_OK;
1782 }
1783
1784 /*****************************************************************************
1785  * IDirect3DDevice3::Begin
1786  *
1787  * Begins a description block of vertices. This is similar to glBegin()
1788  * and glEnd(). After a call to IDirect3DDevice3::End, the vertices
1789  * described with IDirect3DDevice::Vertex are drawn.
1790  *
1791  * Version 2 and 3
1792  *
1793  * Params:
1794  *  PrimitiveType: The type of primitives to draw
1795  *  VertexTypeDesc: A flexible vertex format description of the vertices
1796  *  Flags: Some flags..
1797  *
1798  * Returns:
1799  *  D3D_OK on success
1800  *
1801  *****************************************************************************/
1802 static HRESULT WINAPI
1803 IDirect3DDeviceImpl_3_Begin(IDirect3DDevice3 *iface,
1804                             D3DPRIMITIVETYPE PrimitiveType,
1805                             DWORD VertexTypeDesc,
1806                             DWORD Flags)
1807 {
1808     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1809     TRACE("(%p)->(%d,%ld,%08lx)\n", This, PrimitiveType, VertexTypeDesc, Flags);
1810
1811     This->primitive_type = PrimitiveType;
1812     This->vertex_type = VertexTypeDesc;
1813     This->render_flags = Flags;
1814     This->vertex_size = get_flexible_vertex_size(This->vertex_type);
1815     This->nb_vertices = 0;
1816
1817     return D3D_OK;
1818 }
1819
1820 static HRESULT WINAPI
1821 Thunk_IDirect3DDeviceImpl_2_Begin(IDirect3DDevice2 *iface,
1822                                   D3DPRIMITIVETYPE d3dpt,
1823                                   D3DVERTEXTYPE dwVertexTypeDesc,
1824                                   DWORD dwFlags)
1825 {
1826     DWORD FVF;
1827     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1828     TRACE_(ddraw_thunk)("(%p/%p)->(%08x,%08x,%08lx): Thunking to IDirect3DDevice3\n", This, iface, d3dpt, dwVertexTypeDesc, dwFlags);
1829
1830     switch(dwVertexTypeDesc)
1831     {
1832         case D3DVT_VERTEX: FVF = D3DFVF_VERTEX; break;
1833         case D3DVT_LVERTEX: FVF = D3DFVF_LVERTEX; break;
1834         case D3DVT_TLVERTEX: FVF = D3DFVF_TLVERTEX; break;
1835         default:
1836             ERR("Unexpected vertex type %d\n", dwVertexTypeDesc);
1837             return DDERR_INVALIDPARAMS;  /* Should never happen */
1838     };
1839
1840     return IDirect3DDevice3_Begin(ICOM_INTERFACE(This, IDirect3DDevice3),
1841                                   d3dpt,
1842                                   FVF,
1843                                   dwFlags);
1844 }
1845
1846 /*****************************************************************************
1847  * IDirect3DDevice3::BeginIndexed
1848  *
1849  * Draws primitives based on vertices in a vertex array which are specified
1850  * by indices.
1851  *
1852  * Version 2 and 3
1853  *
1854  * Params:
1855  *  PrimitiveType: Primitive type to draw
1856  *  VertexType: A FVF description of the vertex format
1857  *  Vertices: pointer to an array containing the vertices
1858  *  NumVertices: The number of vertices in the vertex array
1859  *  Flags: Some flags ...
1860  *
1861  * Returns:
1862  *  D3D_OK, because it's a stub
1863  *
1864  *****************************************************************************/
1865 static HRESULT WINAPI
1866 IDirect3DDeviceImpl_3_BeginIndexed(IDirect3DDevice3 *iface,
1867                                    D3DPRIMITIVETYPE PrimitiveType,
1868                                    DWORD VertexType,
1869                                    void *Vertices,
1870                                    DWORD NumVertices,
1871                                    DWORD Flags)
1872 {
1873     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1874     FIXME("(%p)->(%08x,%08lx,%p,%08lx,%08lx): stub!\n", This, PrimitiveType, VertexType, Vertices, NumVertices, Flags);
1875     return D3D_OK;
1876 }
1877
1878
1879 static HRESULT WINAPI
1880 Thunk_IDirect3DDeviceImpl_2_BeginIndexed(IDirect3DDevice2 *iface,
1881                                          D3DPRIMITIVETYPE d3dptPrimitiveType,
1882                                          D3DVERTEXTYPE d3dvtVertexType,
1883                                          void *lpvVertices,
1884                                          DWORD dwNumVertices,
1885                                          DWORD dwFlags)
1886 {
1887     DWORD FVF;
1888     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1889     TRACE_(ddraw_thunk)("(%p/%p)->(%08x,%08x,%p,%08lx,%08lx): Thunking to IDirect3DDevice3\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwNumVertices, dwFlags);
1890
1891     switch(d3dvtVertexType)
1892     {
1893         case D3DVT_VERTEX: FVF = D3DFVF_VERTEX; break;
1894         case D3DVT_LVERTEX: FVF = D3DFVF_LVERTEX; break;
1895         case D3DVT_TLVERTEX: FVF = D3DFVF_TLVERTEX; break;
1896         default:
1897             ERR("Unexpected vertex type %d\n", d3dvtVertexType);
1898             return DDERR_INVALIDPARAMS;  /* Should never happen */
1899     };
1900
1901     return IDirect3DDevice3_BeginIndexed(ICOM_INTERFACE(This,IDirect3DDevice3),
1902                                          d3dptPrimitiveType,
1903                                          FVF,
1904                                          lpvVertices,
1905                                          dwNumVertices,
1906                                          dwFlags);
1907 }
1908
1909 /*****************************************************************************
1910  * IDirect3DDevice3::Vertex
1911  *
1912  * Draws a vertex as described by IDirect3DDevice3::Begin. It places all
1913  * drawn vertices in a vertex buffer. If the buffer is too small, its
1914  * size is increased.
1915  *
1916  * Version 2 and 3
1917  *
1918  * Params:
1919  *  Vertex: Pointer to the vertex
1920  *
1921  * Returns:
1922  *  D3D_OK, on success
1923  *  DDERR_INVALIDPARAMS if Vertex is NULL
1924  *
1925  *****************************************************************************/
1926 static HRESULT WINAPI
1927 IDirect3DDeviceImpl_3_Vertex(IDirect3DDevice3 *iface,
1928                              void *Vertex)
1929 {
1930     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1931     TRACE("(%p)->(%p)\n", This, Vertex);
1932
1933     if(!Vertex)
1934         return DDERR_INVALIDPARAMS;
1935
1936     if ((This->nb_vertices+1)*This->vertex_size > This->buffer_size)
1937     {
1938         BYTE *old_buffer;
1939         This->buffer_size = This->buffer_size ? This->buffer_size * 2 : This->vertex_size * 3;
1940         old_buffer = This->vertex_buffer;
1941         This->vertex_buffer = HeapAlloc(GetProcessHeap(), 0, This->buffer_size);
1942         if (old_buffer)
1943         {
1944             CopyMemory(This->vertex_buffer, old_buffer, This->nb_vertices * This->vertex_size);
1945             HeapFree(GetProcessHeap(), 0, old_buffer);
1946         }
1947     }
1948
1949     CopyMemory(This->vertex_buffer + This->nb_vertices++ * This->vertex_size, Vertex, This->vertex_size);
1950
1951     return D3D_OK;
1952 }
1953
1954 static HRESULT WINAPI
1955 Thunk_IDirect3DDeviceImpl_2_Vertex(IDirect3DDevice2 *iface,
1956                                    void *lpVertexType)
1957 {
1958     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1959     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", This, lpVertexType);
1960     return IDirect3DDevice3_Vertex(ICOM_INTERFACE(This, IDirect3DDevice3),
1961                                                   lpVertexType);
1962 }
1963
1964 /*****************************************************************************
1965  * IDirect3DDevice3::Index
1966  *
1967  * Specifies an index to a vertex to be drawn. The vertex array has to
1968  * be specified with BeginIndexed first.
1969  *
1970  * Parameters:
1971  *  VertexIndex: The index of the vertex to draw
1972  *
1973  * Returns:
1974  *  D3D_OK because it's a stub
1975  *
1976  *****************************************************************************/
1977 static HRESULT WINAPI
1978 IDirect3DDeviceImpl_3_Index(IDirect3DDevice3 *iface,
1979                             WORD VertexIndex)
1980 {
1981     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1982     FIXME("(%p)->(%04x): stub!\n", This, VertexIndex);
1983     return D3D_OK;
1984 }
1985
1986 static HRESULT WINAPI
1987 Thunk_IDirect3DDeviceImpl_2_Index(IDirect3DDevice2 *iface,
1988                                   WORD wVertexIndex)
1989 {
1990     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1991     TRACE_(ddraw_thunk)("(%p)->(%04x) thunking to IDirect3DDevice3 interface.\n", This, wVertexIndex);
1992     return IDirect3DDevice3_Index(ICOM_INTERFACE(This, IDirect3DDevice3),
1993                                   wVertexIndex);
1994 }
1995
1996 /*****************************************************************************
1997  * IDirect3DDevice3::End
1998  *
1999  * Ends a draw begun with IDirect3DDevice3::Begin or
2000  * IDirect3DDevice::BeginIndexed. The vertices specified with
2001  * IDirect3DDevice::Vertex or IDirect3DDevice::Index are drawn using
2002  * the IDirect3DDevice7::DrawPrimitive method. So far only
2003  * non-indexed mode is supported
2004  *
2005  * Version 2 and 3
2006  *
2007  * Params:
2008  *  Flags: Some flags, as usual. Don't know which are defined
2009  *
2010  * Returns:
2011  *  The return value of IDirect3DDevice7::DrawPrimitive
2012  *
2013  *****************************************************************************/
2014 static HRESULT WINAPI
2015 IDirect3DDeviceImpl_3_End(IDirect3DDevice3 *iface,
2016                           DWORD Flags)
2017 {
2018     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
2019     TRACE("(%p)->(%08lx)\n", This, Flags);
2020
2021     return IDirect3DDevice7_DrawPrimitive(ICOM_INTERFACE(This, IDirect3DDevice7),
2022                                           This->primitive_type, This->vertex_type,
2023                                           This->vertex_buffer, This->nb_vertices,
2024                                           This->render_flags);
2025 }
2026
2027 static HRESULT WINAPI
2028 Thunk_IDirect3DDeviceImpl_2_End(IDirect3DDevice2 *iface,
2029                                 DWORD dwFlags)
2030 {
2031     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
2032     TRACE_(ddraw_thunk)("(%p)->(%08lx) thunking to IDirect3DDevice3 interface.\n", This, dwFlags);
2033     return IDirect3DDevice3_End(ICOM_INTERFACE(This, IDirect3DDevice3),
2034                                 dwFlags);
2035 }
2036
2037 /*****************************************************************************
2038  * IDirect3DDevice7::GetRenderState
2039  *
2040  * Returns the value of a render state. The possible render states are
2041  * defined in include/d3dtypes.h
2042  *
2043  * Version 2, 3 and 7
2044  *
2045  * Params:
2046  *  RenderStateType: Render state to return the current setting of
2047  *  Value: Address to store the value at
2048  *
2049  * Returns:
2050  *  D3D_OK on success, for details see IWineD3DDevice::GetRenderState
2051  *  DDERR_INVALIDPARAMS if Value == NULL
2052  *
2053  *****************************************************************************/
2054 static HRESULT WINAPI
2055 IDirect3DDeviceImpl_7_GetRenderState(IDirect3DDevice7 *iface,
2056                                      D3DRENDERSTATETYPE RenderStateType,
2057                                      DWORD *Value)
2058 {
2059     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2060     TRACE("(%p)->(%08x,%p): Relay\n", This, RenderStateType, Value);
2061
2062     if(!Value)
2063         return DDERR_INVALIDPARAMS;
2064
2065     return IWineD3DDevice_GetRenderState(This->wineD3DDevice,
2066                                          RenderStateType,
2067                                          Value);
2068 }
2069
2070 static HRESULT WINAPI
2071 Thunk_IDirect3DDeviceImpl_3_GetRenderState(IDirect3DDevice3 *iface,
2072                                            D3DRENDERSTATETYPE dwRenderStateType,
2073                                            DWORD *lpdwRenderState)
2074 {
2075     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
2076     TRACE_(ddraw_thunk)("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", This, dwRenderStateType, lpdwRenderState);
2077     return IDirect3DDevice7_GetRenderState(ICOM_INTERFACE(This, IDirect3DDevice7),
2078                                            dwRenderStateType,
2079                                            lpdwRenderState);
2080 }
2081
2082 static HRESULT WINAPI
2083 Thunk_IDirect3DDeviceImpl_2_GetRenderState(IDirect3DDevice2 *iface,
2084                                            D3DRENDERSTATETYPE dwRenderStateType,
2085                                            DWORD *lpdwRenderState)
2086 {
2087     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
2088     TRACE_(ddraw_thunk)("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", This, dwRenderStateType, lpdwRenderState);
2089     return IDirect3DDevice7_GetRenderState(ICOM_INTERFACE(This, IDirect3DDevice7),
2090                                            dwRenderStateType,
2091                                            lpdwRenderState);
2092 }
2093
2094 /*****************************************************************************
2095  * IDirect3DDevice7::SetRenderState
2096  *
2097  * Sets a render state. The possible render states are defined in
2098  * include/d3dtypes.h
2099  *
2100  * Version 2, 3 and 7
2101  *
2102  * Params:
2103  *  RenderStateType: State to set
2104  *  Value: Value to assign to that state
2105  *
2106  * Returns:
2107  *  D3D_OK on success,
2108  *  for details see IWineD3DDevice::SetRenderState
2109  *
2110  *****************************************************************************/
2111 static HRESULT WINAPI
2112 IDirect3DDeviceImpl_7_SetRenderState(IDirect3DDevice7 *iface,
2113                                      D3DRENDERSTATETYPE RenderStateType,
2114                                      DWORD Value)
2115 {
2116     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2117     TRACE("(%p)->(%08x,%ld): Relay\n", This, RenderStateType, Value);
2118
2119     /* Some render states need special care */
2120     switch(RenderStateType)
2121     {
2122         case D3DRENDERSTATE_TEXTUREHANDLE:
2123         {
2124             if(Value == 0)
2125             {
2126                     return IWineD3DDevice_SetTexture(This->wineD3DDevice,
2127                                                      0,
2128                                                      NULL);
2129             }
2130
2131             if(Value > This->numHandles)
2132             {
2133                 FIXME("Specified handle %ld out of range\n", Value);
2134                 return DDERR_INVALIDPARAMS;
2135             }
2136             if(This->Handles[Value - 1].type != DDrawHandle_Texture)
2137             {
2138                 FIXME("Handle %ld isn't a texture handle\n", Value);
2139                 return DDERR_INVALIDPARAMS;
2140             }
2141             else
2142             {
2143                 IDirectDrawSurfaceImpl *surf = (IDirectDrawSurfaceImpl *) This->Handles[Value - 1].ptr;
2144                 return IWineD3DDevice_SetTexture(This->wineD3DDevice,
2145                                                  0,
2146                                                  (IWineD3DBaseTexture *) surf->wineD3DTexture);
2147             }
2148         }
2149
2150         case D3DRENDERSTATE_TEXTUREMAG:
2151         {
2152             WINED3DTEXTUREFILTERTYPE tex_mag = WINED3DTEXF_NONE;
2153
2154             switch ((D3DTEXTUREFILTER) Value)
2155             {
2156                 case D3DFILTER_NEAREST:
2157                     tex_mag = WINED3DTEXF_POINT;
2158                     break;
2159                 case D3DFILTER_LINEAR:
2160                     tex_mag = WINED3DTEXF_LINEAR;
2161                     break;
2162                 default:
2163                     ERR("Unhandled texture mag %ld !\n",Value);
2164             }
2165
2166             return IWineD3DDevice_SetSamplerState(This->wineD3DDevice,
2167                                                   0, WINED3DSAMP_MAGFILTER,
2168                                                   tex_mag);
2169         }
2170
2171         case D3DRENDERSTATE_TEXTUREMIN:
2172         {
2173             WINED3DTEXTUREFILTERTYPE tex_min = WINED3DTEXF_NONE;
2174
2175             switch ((D3DTEXTUREFILTER) Value)
2176             {
2177                 case D3DFILTER_NEAREST:
2178                     tex_min = WINED3DTEXF_POINT;
2179                     break;
2180                 case D3DFILTER_LINEAR:
2181                     tex_min = WINED3DTEXF_LINEAR;
2182                     break;
2183                 default:
2184                     ERR("Unhandled texture mag %ld !\n",Value);
2185             }
2186
2187             return IWineD3DDevice_SetSamplerState(This->wineD3DDevice,
2188                                                   0, WINED3DSAMP_MINFILTER,
2189                                                   tex_min);
2190         }
2191
2192         case D3DRENDERSTATE_TEXTUREADDRESSU:
2193         case D3DRENDERSTATE_TEXTUREADDRESSV:
2194         case D3DRENDERSTATE_TEXTUREADDRESS:
2195         {
2196             WINED3DTEXTURESTAGESTATETYPE TexStageStateType;
2197
2198             if (RenderStateType == D3DRENDERSTATE_TEXTUREADDRESS)
2199             {
2200                 TexStageStateType = WINED3DTSS_ADDRESS;
2201             }
2202             else if (RenderStateType == D3DRENDERSTATE_TEXTUREADDRESSU)
2203             {
2204                 TexStageStateType = WINED3DTSS_ADDRESSU;
2205             }
2206             else
2207             {
2208                 TexStageStateType = WINED3DTSS_ADDRESSV;
2209             }
2210
2211             return IWineD3DDevice_SetTextureStageState(This->wineD3DDevice,
2212                                                        0, TexStageStateType,
2213                                                        Value);
2214         }
2215
2216         default:
2217             return IWineD3DDevice_SetRenderState(This->wineD3DDevice,
2218                                                  RenderStateType,
2219                                                  Value);
2220     }
2221 }
2222
2223 static HRESULT WINAPI
2224 Thunk_IDirect3DDeviceImpl_3_SetRenderState(IDirect3DDevice3 *iface,
2225                                            D3DRENDERSTATETYPE RenderStateType,
2226                                            DWORD Value)
2227 {
2228     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
2229     TRACE_(ddraw_thunk)("(%p)->(%08x,%08lx) thunking to IDirect3DDevice7 interface.\n", This, RenderStateType, Value);
2230     return IDirect3DDevice7_SetRenderState(ICOM_INTERFACE(This, IDirect3DDevice7),
2231                                            RenderStateType,
2232                                            Value);
2233 }
2234
2235 static HRESULT WINAPI
2236 Thunk_IDirect3DDeviceImpl_2_SetRenderState(IDirect3DDevice2 *iface,
2237                                            D3DRENDERSTATETYPE RenderStateType,
2238                                            DWORD Value)
2239 {
2240     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
2241     TRACE_(ddraw_thunk)("(%p)->(%08x,%08lx) thunking to IDirect3DDevice7 interface.\n", This, RenderStateType, Value);
2242     return IDirect3DDevice7_SetRenderState(ICOM_INTERFACE(This, IDirect3DDevice7),
2243                                            RenderStateType,
2244                                            Value);
2245 }
2246
2247 /*****************************************************************************
2248  * Direct3DDevice3::SetLightState
2249  *
2250  * Sets a light state for Direct3DDevice3 and Direct3DDevice2. The
2251  * light states are forwarded to Direct3DDevice7 render states
2252  *
2253  * Version 2 and 3
2254  *
2255  * Params:
2256  *  LightStateType: The light state to change
2257  *  Value: The value to assign to that light state
2258  *
2259  * Returns:
2260  *  D3D_OK on success
2261  *  DDERR_INVALIDPARAMS if the parameters were incorrect
2262  *  Also check IDirect3DDevice7::SetRenderState
2263  *
2264  *****************************************************************************/
2265 static HRESULT WINAPI
2266 IDirect3DDeviceImpl_3_SetLightState(IDirect3DDevice3 *iface,
2267                                     D3DLIGHTSTATETYPE LightStateType,
2268                                     DWORD Value)
2269 {
2270     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
2271
2272     TRACE("(%p)->(%08x,%08lx)\n", This, LightStateType, Value);
2273
2274     if (!LightStateType && (LightStateType > D3DLIGHTSTATE_COLORVERTEX))
2275     {
2276         TRACE("Unexpected Light State Type\n");
2277         return DDERR_INVALIDPARAMS;
2278     }
2279
2280     if (LightStateType == D3DLIGHTSTATE_MATERIAL /* 1 */)
2281     {
2282         IDirect3DMaterialImpl *mat;
2283
2284         if(Value == 0) mat = NULL;
2285         else if(Value > This->numHandles)
2286         {
2287             ERR("Material handle out of range(%ld)\n", Value);
2288             return DDERR_INVALIDPARAMS;
2289         }
2290         else if(This->Handles[Value - 1].type != DDrawHandle_Material)
2291         {
2292             ERR("Invalid handle %ld\n", Value);
2293             return DDERR_INVALIDPARAMS;
2294         }
2295         else
2296         {
2297             mat = (IDirect3DMaterialImpl *) This->Handles[Value - 1].ptr;
2298         }
2299
2300         if (mat != NULL)
2301         {
2302             TRACE(" activating material %p.\n", mat);
2303             mat->activate(mat);
2304         }
2305         else
2306         {
2307             FIXME(" D3DLIGHTSTATE_MATERIAL called with NULL material !!!\n");
2308         }
2309         This->material = Value;
2310     }
2311     else if (LightStateType == D3DLIGHTSTATE_COLORMODEL /* 3 */)
2312     {
2313         switch (Value)
2314         {
2315             case D3DCOLOR_MONO:
2316                 ERR("DDCOLOR_MONO should not happen!\n");
2317                 break;
2318             case D3DCOLOR_RGB:
2319                 /* We are already in this mode */
2320                 TRACE("Setting color model to RGB (no-op).\n");
2321                 break;
2322             default:
2323                 ERR("Unknown color model!\n");
2324                 return DDERR_INVALIDPARAMS;
2325         }
2326     }
2327     else
2328     {
2329         D3DRENDERSTATETYPE rs;
2330         switch (LightStateType)
2331         {
2332             case D3DLIGHTSTATE_AMBIENT:       /* 2 */
2333                 rs = D3DRENDERSTATE_AMBIENT;
2334                 break;
2335             case D3DLIGHTSTATE_FOGMODE:       /* 4 */
2336                 rs = D3DRENDERSTATE_FOGVERTEXMODE;
2337                 break;
2338             case D3DLIGHTSTATE_FOGSTART:      /* 5 */
2339                 rs = D3DRENDERSTATE_FOGSTART;
2340                 break;
2341             case D3DLIGHTSTATE_FOGEND:        /* 6 */
2342                 rs = D3DRENDERSTATE_FOGEND;
2343                 break;
2344             case D3DLIGHTSTATE_FOGDENSITY:    /* 7 */
2345                 rs = D3DRENDERSTATE_FOGDENSITY;
2346                 break;
2347             case D3DLIGHTSTATE_COLORVERTEX:   /* 8 */
2348                 rs = D3DRENDERSTATE_COLORVERTEX;
2349                 break;
2350             default:
2351                 ERR("Unknown D3DLIGHTSTATETYPE %d.\n", LightStateType);
2352                 return DDERR_INVALIDPARAMS;
2353         }
2354
2355         return IDirect3DDevice7_SetRenderState(ICOM_INTERFACE(This, IDirect3DDevice7),
2356                                                rs,
2357                                                Value);
2358     }
2359
2360     return D3D_OK;
2361 }
2362
2363 static HRESULT WINAPI
2364 Thunk_IDirect3DDeviceImpl_2_SetLightState(IDirect3DDevice2 *iface,
2365                                           D3DLIGHTSTATETYPE LightStateType,
2366                                           DWORD Value)
2367 {
2368     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
2369     TRACE_(ddraw_thunk)("(%p)->(%08x,%08lx) thunking to IDirect3DDevice3 interface.\n", This, LightStateType, Value);
2370     return IDirect3DDevice3_SetLightState(ICOM_INTERFACE(This, IDirect3DDevice3),
2371                                           LightStateType,
2372                                           Value);
2373 }
2374
2375 /*****************************************************************************
2376  * IDirect3DDevice3::GetLightState
2377  *
2378  * Returns the current setting of a light state. The state is read from
2379  * the Direct3DDevice7 render state.
2380  *
2381  * Version 2 and 3
2382  *
2383  * Params:
2384  *  LightStateType: The light state to return
2385  *  Value: The address to store the light state setting at
2386  *
2387  * Returns:
2388  *  D3D_OK on success
2389  *  DDDERR_INVALIDPARAMS if the parameters were incorrect
2390  *  Also see IDirect3DDevice7::GetRenderState
2391  *
2392  *****************************************************************************/
2393 static HRESULT WINAPI
2394 IDirect3DDeviceImpl_3_GetLightState(IDirect3DDevice3 *iface,
2395                                     D3DLIGHTSTATETYPE LightStateType,
2396                                     DWORD *Value)
2397 {
2398     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
2399
2400     TRACE("(%p)->(%08x,%p)\n", This, LightStateType, Value);
2401
2402     if (!LightStateType && (LightStateType > D3DLIGHTSTATE_COLORVERTEX))
2403     {
2404         TRACE("Unexpected Light State Type\n");
2405         return DDERR_INVALIDPARAMS;
2406     }
2407
2408     if(!Value)
2409         return DDERR_INVALIDPARAMS;
2410
2411     if (LightStateType == D3DLIGHTSTATE_MATERIAL /* 1 */)
2412     {
2413         *Value = This->material;
2414     }
2415     else if (LightStateType == D3DLIGHTSTATE_COLORMODEL /* 3 */)
2416     {
2417         *Value = D3DCOLOR_RGB;
2418     }
2419     else
2420     {
2421         D3DRENDERSTATETYPE rs;
2422         switch (LightStateType)
2423         {
2424             case D3DLIGHTSTATE_AMBIENT:       /* 2 */
2425                 rs = D3DRENDERSTATE_AMBIENT;
2426                 break;
2427             case D3DLIGHTSTATE_FOGMODE:       /* 4 */
2428                 rs = D3DRENDERSTATE_FOGVERTEXMODE;
2429                 break;
2430             case D3DLIGHTSTATE_FOGSTART:      /* 5 */
2431                 rs = D3DRENDERSTATE_FOGSTART;
2432                 break;
2433             case D3DLIGHTSTATE_FOGEND:        /* 6 */
2434                 rs = D3DRENDERSTATE_FOGEND;
2435                 break;
2436             case D3DLIGHTSTATE_FOGDENSITY:    /* 7 */
2437                 rs = D3DRENDERSTATE_FOGDENSITY;
2438                 break;
2439             case D3DLIGHTSTATE_COLORVERTEX:   /* 8 */
2440                 rs = D3DRENDERSTATE_COLORVERTEX;
2441                 break;
2442             default:
2443                 ERR("Unknown D3DLIGHTSTATETYPE %d.\n", LightStateType);
2444                 return DDERR_INVALIDPARAMS;
2445         }
2446
2447         return IDirect3DDevice7_GetRenderState(ICOM_INTERFACE(This, IDirect3DDevice7),
2448                                                rs,
2449                                                Value);
2450     }
2451
2452     return D3D_OK;
2453 }
2454
2455 static HRESULT WINAPI
2456 Thunk_IDirect3DDeviceImpl_2_GetLightState(IDirect3DDevice2 *iface,
2457                                           D3DLIGHTSTATETYPE LightStateType,
2458                                           DWORD *Value)
2459 {
2460     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
2461     TRACE_(ddraw_thunk)("(%p)->(%08x,%p) thunking to IDirect3DDevice3 interface.\n", This, LightStateType, Value);
2462     return IDirect3DDevice3_GetLightState(ICOM_INTERFACE(This, IDirect3DDevice3),
2463                                           LightStateType,
2464                                           Value);
2465 }
2466
2467 /*****************************************************************************
2468  * IDirect3DDevice7::SetTransform
2469  *
2470  * Assigns a D3DMATRIX to a transform type. The transform types are defined
2471  * in include/d3dtypes.h.
2472  * The D3DTRANSFORMSTATE_WORLD (=1) is translated to D3DTS_WORLDMATRIX(0)
2473  * (=255) for wined3d, because the 1 transform state was removed in d3d8
2474  * and WineD3D already understands the replacement D3DTS_WORLDMATRIX(0)
2475  *
2476  * Version 2, 3 and 7
2477  *
2478  * Params:
2479  *  TransformStateType: transform state to set
2480  *  Matrix: Matrix to assign to the state
2481  *
2482  * Returns:
2483  *  D3D_OK on success
2484  *  DDERR_INVALIDPARAMS if Matrix == NULL
2485  *  For details see IWineD3DDevice::SetTransform
2486  *
2487  *****************************************************************************/
2488 static HRESULT WINAPI
2489 IDirect3DDeviceImpl_7_SetTransform(IDirect3DDevice7 *iface,
2490                                    D3DTRANSFORMSTATETYPE TransformStateType,
2491                                    D3DMATRIX *Matrix)
2492 {
2493     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2494     D3DTRANSFORMSTATETYPE type = TransformStateType;
2495     TRACE("(%p)->(%08x,%p): Relay\n", This, TransformStateType, Matrix);
2496
2497     if(!Matrix)
2498         return DDERR_INVALIDPARAMS;
2499
2500     /* D3DTRANSFORMSTATE_WORLD doesn't exist in WineD3D,
2501      * use D3DTS_WORLDMATRIX(0) instead
2502      * D3DTS_WORLDMATRIX(index) is (D3DTRANSFORMSTATETYPE)(index + 256)
2503      */
2504     if(TransformStateType == D3DTRANSFORMSTATE_WORLD)
2505         type = (D3DTRANSFORMSTATETYPE)(0 + 256);
2506
2507     return IWineD3DDevice_SetTransform(This->wineD3DDevice,
2508                                        type,
2509                                        Matrix);
2510 }
2511
2512 static HRESULT WINAPI
2513 Thunk_IDirect3DDeviceImpl_3_SetTransform(IDirect3DDevice3 *iface,
2514                                          D3DTRANSFORMSTATETYPE TransformStateType,
2515                                          D3DMATRIX *D3DMatrix)
2516 {
2517     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
2518     TRACE_(ddraw_thunk)("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", This, TransformStateType, D3DMatrix);
2519     return IDirect3DDevice7_SetTransform(ICOM_INTERFACE(This, IDirect3DDevice7),
2520                                          TransformStateType,
2521                                          D3DMatrix);
2522 }
2523
2524 static HRESULT WINAPI
2525 Thunk_IDirect3DDeviceImpl_2_SetTransform(IDirect3DDevice2 *iface,
2526                                          D3DTRANSFORMSTATETYPE TransformStateType,
2527                                          D3DMATRIX *D3DMatrix)
2528 {
2529     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
2530     TRACE_(ddraw_thunk)("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", This, TransformStateType, D3DMatrix);
2531     return IDirect3DDevice7_SetTransform(ICOM_INTERFACE(This, IDirect3DDevice7),
2532                                          TransformStateType,
2533                                          D3DMatrix);
2534 }
2535
2536 /*****************************************************************************
2537  * IDirect3DDevice7::GetTransform
2538  *
2539  * Returns the matrix assigned to a transform state
2540  * D3DTRANSFORMSTATE_WORLD is translated to D3DTS_WORLDMATRIX(0), see
2541  * SetTransform
2542  *
2543  * Params:
2544  *  TransformStateType: State to read the matrix from
2545  *  Matrix: Address to store the matrix at
2546  *
2547  * Returns:
2548  *  D3D_OK on success
2549  *  DDERR_INVALIDPARAMS if Matrix == NULL
2550  *  For details, see IWineD3DDevice::GetTransform
2551  *
2552  *****************************************************************************/
2553 static HRESULT WINAPI
2554 IDirect3DDeviceImpl_7_GetTransform(IDirect3DDevice7 *iface,
2555                                    D3DTRANSFORMSTATETYPE TransformStateType,
2556                                    D3DMATRIX *Matrix)
2557 {
2558     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2559     D3DTRANSFORMSTATETYPE type = TransformStateType;
2560     TRACE("(%p)->(%08x,%p): Relay\n", This, TransformStateType, Matrix);
2561
2562     if(!Matrix)
2563         return DDERR_INVALIDPARAMS;
2564
2565     /* D3DTRANSFORMSTATE_WORLD doesn't exist in WineD3D,
2566      * use D3DTS_WORLDMATRIX(0) instead
2567      * D3DTS_WORLDMATRIX(index) is (D3DTRANSFORMSTATETYPE)(index + 256)
2568      */
2569     if(TransformStateType == D3DTRANSFORMSTATE_WORLD)
2570         type = (D3DTRANSFORMSTATETYPE)(0 + 256);
2571
2572     return IWineD3DDevice_GetTransform(This->wineD3DDevice, type, Matrix);
2573 }
2574
2575 static HRESULT WINAPI
2576 Thunk_IDirect3DDeviceImpl_3_GetTransform(IDirect3DDevice3 *iface,
2577                                          D3DTRANSFORMSTATETYPE TransformStateType,
2578                                          D3DMATRIX *D3DMatrix)
2579 {
2580     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
2581     TRACE_(ddraw_thunk)("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", This, TransformStateType, D3DMatrix);
2582     return IDirect3DDevice7_GetTransform(ICOM_INTERFACE(This, IDirect3DDevice7),
2583                                          TransformStateType,
2584                                          D3DMatrix);
2585 }
2586
2587 static HRESULT WINAPI
2588 Thunk_IDirect3DDeviceImpl_2_GetTransform(IDirect3DDevice2 *iface,
2589                                          D3DTRANSFORMSTATETYPE TransformStateType,
2590                                          D3DMATRIX *D3DMatrix)
2591 {
2592     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
2593     TRACE_(ddraw_thunk)("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", This, TransformStateType, D3DMatrix);
2594     return IDirect3DDevice7_GetTransform(ICOM_INTERFACE(This, IDirect3DDevice7),
2595                                          TransformStateType,
2596                                          D3DMatrix);
2597 }
2598
2599 /*****************************************************************************
2600  * IDirect3DDevice7::MultiplyTransform
2601  *
2602  * Multiplies the already-set transform matrix of a transform state
2603  * with another matrix. For the world matrix, see SetTransform
2604  *
2605  * Version 2, 3 and 7
2606  *
2607  * Params:
2608  *  TransformStateType: Transform state to multiply
2609  *  D3DMatrix Matrix to multiply with.
2610  *
2611  * Returns
2612  *  D3D_OK on success
2613  *  DDERR_INVALIDPARAMS if D3DMatrix is NULL
2614  *  For details, see IWineD3DDevice::MultiplyTransform
2615  *
2616  *****************************************************************************/
2617 static HRESULT WINAPI
2618 IDirect3DDeviceImpl_7_MultiplyTransform(IDirect3DDevice7 *iface,
2619                                         D3DTRANSFORMSTATETYPE TransformStateType,
2620                                         D3DMATRIX *D3DMatrix)
2621 {
2622     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2623     TRACE("(%p)->(%08x,%p): Relay\n", This, TransformStateType, D3DMatrix);
2624
2625     /* D3DTRANSFORMSTATE_WORLD doesn't exist in WineD3D,
2626      * use D3DTS_WORLDMATRIX(0) instead
2627      * D3DTS_WORLDMATRIX(index) is (D3DTRANSFORMSTATETYPE)(index + 256)
2628      */
2629     if(TransformStateType == D3DTRANSFORMSTATE_WORLD)
2630         TransformStateType = (D3DTRANSFORMSTATETYPE)(0 + 256);
2631
2632     return IWineD3DDevice_MultiplyTransform(This->wineD3DDevice,
2633                                             TransformStateType,
2634                                             D3DMatrix);
2635 }
2636
2637 static HRESULT WINAPI
2638 Thunk_IDirect3DDeviceImpl_3_MultiplyTransform(IDirect3DDevice3 *iface,
2639                                               D3DTRANSFORMSTATETYPE TransformStateType,
2640                                               D3DMATRIX *D3DMatrix)
2641 {
2642     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
2643     TRACE_(ddraw_thunk)("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", This, TransformStateType, D3DMatrix);
2644     return IDirect3DDevice7_MultiplyTransform(ICOM_INTERFACE(This, IDirect3DDevice7),
2645                                               TransformStateType,
2646                                               D3DMatrix);
2647 }
2648
2649 static HRESULT WINAPI
2650 Thunk_IDirect3DDeviceImpl_2_MultiplyTransform(IDirect3DDevice2 *iface,
2651                                               D3DTRANSFORMSTATETYPE TransformStateType,
2652                                               D3DMATRIX *D3DMatrix)
2653 {
2654     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
2655     TRACE_(ddraw_thunk)("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", This, TransformStateType, D3DMatrix);
2656     return IDirect3DDevice7_MultiplyTransform(ICOM_INTERFACE(This, IDirect3DDevice7),
2657                                               TransformStateType,
2658                                               D3DMatrix);
2659 }
2660
2661 /*****************************************************************************
2662  * IDirect3DDevice7::DrawPrimitive
2663  *
2664  * Draws primitives based on vertices in an application-provided pointer
2665  *
2666  * Version 2, 3 and 7. The IDirect3DDevice2 thunk converts the fixed vertex type into
2667  * an FVF format for D3D7
2668  *
2669  * Params:
2670  *  PrimitiveType: The type of the primitives to draw
2671  *  Vertex type: Flexible vertex format vertex description
2672  *  Vertices: Pointer to the vertex array
2673  *  VertexCount: The number of vertices to draw
2674  *  Flags: As usual a few flags
2675  *
2676  * Returns:
2677  *  D3D_OK on success
2678  *  DDERR_INVALIDPARAMS if Vertices is NULL
2679  *  For details, see IWineD3DDevice::DrawPrimitiveUP
2680  *
2681  *****************************************************************************/
2682 static HRESULT WINAPI
2683 IDirect3DDeviceImpl_7_DrawPrimitive(IDirect3DDevice7 *iface,
2684                                     D3DPRIMITIVETYPE PrimitiveType,
2685                                     DWORD VertexType,
2686                                     void *Vertices,
2687                                     DWORD VertexCount,
2688                                     DWORD Flags)
2689 {
2690     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2691     UINT PrimitiveCount, stride;
2692     HRESULT hr;
2693     TRACE("(%p)->(%08x,%08lx,%p,%08lx,%08lx): Relay!\n", This, PrimitiveType, VertexType, Vertices, VertexCount, Flags);
2694
2695     if(!Vertices)
2696         return DDERR_INVALIDPARAMS;
2697
2698     /* Get the vertex count */
2699     switch(PrimitiveType)
2700     {
2701       case D3DPT_POINTLIST:
2702         PrimitiveCount = VertexCount;
2703         break;
2704
2705       case D3DPT_LINELIST:
2706         PrimitiveCount = VertexCount / 2;
2707         break;
2708
2709       case D3DPT_LINESTRIP:
2710         PrimitiveCount = VertexCount - 1;
2711         break;
2712
2713       case D3DPT_TRIANGLELIST:
2714         PrimitiveCount = VertexCount / 3;
2715         break;
2716
2717       case D3DPT_TRIANGLESTRIP:
2718         PrimitiveCount = VertexCount - 2;
2719         break;
2720
2721       case D3DPT_TRIANGLEFAN:
2722         PrimitiveCount = VertexCount - 2;
2723         break;
2724
2725       default: return DDERR_INVALIDPARAMS;
2726     }
2727
2728     /* Get the stride */
2729     stride = get_flexible_vertex_size(VertexType);
2730
2731     /* Set the FVF */
2732     hr = IWineD3DDevice_SetFVF(This->wineD3DDevice, VertexType);
2733     if(hr != D3D_OK) return hr;
2734
2735     /* This method translates to the user pointer draw of WineD3D */
2736     return IWineD3DDevice_DrawPrimitiveUP(This->wineD3DDevice,
2737                                           PrimitiveType,
2738                                           PrimitiveCount,
2739                                           Vertices,
2740                                           stride);
2741 }
2742
2743 static HRESULT WINAPI
2744 Thunk_IDirect3DDeviceImpl_3_DrawPrimitive(IDirect3DDevice3 *iface,
2745                                           D3DPRIMITIVETYPE PrimitiveType,
2746                                           DWORD VertexType,
2747                                           void *Vertices,
2748                                           DWORD VertexCount,
2749                                           DWORD Flags)
2750 {
2751     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
2752     TRACE_(ddraw_thunk)("(%p)->(%08x,%08lx,%p,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", This, PrimitiveType, VertexType, Vertices, VertexCount, Flags);
2753     return IDirect3DDevice7_DrawPrimitive(ICOM_INTERFACE(This, IDirect3DDevice7),
2754                                           PrimitiveType,
2755                                           VertexType,
2756                                           Vertices,
2757                                           VertexCount,
2758                                           Flags);
2759 }
2760
2761 static HRESULT WINAPI
2762 Thunk_IDirect3DDeviceImpl_2_DrawPrimitive(IDirect3DDevice2 *iface,
2763                                           D3DPRIMITIVETYPE PrimitiveType,
2764                                           D3DVERTEXTYPE VertexType,
2765                                           void *Vertices,
2766                                           DWORD VertexCount,
2767                                           DWORD Flags)
2768 {
2769     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
2770     DWORD FVF;
2771     TRACE_(ddraw_thunk)("(%p)->(%08x,%08x,%p,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", This, PrimitiveType, VertexType, Vertices, VertexCount, Flags);
2772
2773     switch(VertexType)
2774     {
2775         case D3DVT_VERTEX: FVF = D3DFVF_VERTEX; break;
2776         case D3DVT_LVERTEX: FVF = D3DFVF_LVERTEX; break;
2777         case D3DVT_TLVERTEX: FVF = D3DFVF_TLVERTEX; break;
2778         default:
2779             ERR("Unexpected vertex type %d\n", VertexType);
2780             return DDERR_INVALIDPARAMS;  /* Should never happen */
2781     }
2782
2783     return IDirect3DDevice7_DrawPrimitive(ICOM_INTERFACE(This, IDirect3DDevice7),
2784                                           PrimitiveType,
2785                                           FVF,
2786                                           Vertices,
2787                                           VertexCount,
2788                                           Flags);
2789 }
2790
2791 /*****************************************************************************
2792  * IDirect3DDevice7::DrawIndexedPrimitive
2793  *
2794  * Draws vertices from an application-provided pointer, based on the index
2795  * numbers in a WORD array.
2796  *
2797  * Version 2, 3 and 7. The version 7 thunk translates the vertex type into
2798  * an FVF format for D3D7
2799  *
2800  * Params:
2801  *  PrimitiveType: The primitive type to draw
2802  *  VertexType: The FVF vertex description
2803  *  Vertices: Pointer to the vertex array
2804  *  VertexCount: ?
2805  *  Indices: Pointer to the index array
2806  *  IndexCount: Number of indices = Number of vertices to draw
2807  *  Flags: As usual, some flags
2808  *
2809  * Returns:
2810  *  D3D_OK on success
2811  *  DDERR_INVALIDPARAMS if Vertices or Indices is NULL
2812  *  For details, see IWineD3DDevice::DrawIndexedPrimitiveUP
2813  *
2814  *****************************************************************************/
2815 static HRESULT WINAPI
2816 IDirect3DDeviceImpl_7_DrawIndexedPrimitive(IDirect3DDevice7 *iface,
2817                                            D3DPRIMITIVETYPE PrimitiveType,
2818                                            DWORD VertexType,
2819                                            void *Vertices,
2820                                            DWORD VertexCount,
2821                                            WORD *Indices,
2822                                            DWORD IndexCount,
2823                                            DWORD Flags)
2824 {
2825     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2826     UINT PrimitiveCount = 0;
2827     HRESULT hr;
2828     TRACE("(%p)->(%08x,%08lx,%p,%08lx,%p,%08lx,%08lx): Relay!\n", This, PrimitiveType, VertexType, Vertices, VertexCount, Indices, IndexCount, Flags);
2829     /* Get the primitive number */
2830     switch(PrimitiveType)
2831     {
2832       case D3DPT_POINTLIST:
2833         PrimitiveCount = IndexCount;
2834         break;
2835
2836       case D3DPT_LINELIST:
2837         PrimitiveCount = IndexCount / 2;
2838         break;
2839
2840       case D3DPT_LINESTRIP:
2841         PrimitiveCount = IndexCount - 1;
2842         break;
2843
2844       case D3DPT_TRIANGLELIST:
2845         PrimitiveCount = IndexCount / 3;
2846         break;
2847
2848       case D3DPT_TRIANGLESTRIP:
2849         PrimitiveCount = IndexCount - 2;
2850         break;
2851
2852       case D3DPT_TRIANGLEFAN:
2853         PrimitiveCount = IndexCount - 2;
2854         break;
2855
2856       default: return DDERR_INVALIDPARAMS;
2857     }
2858
2859     /* Set the D3DDevice's FVF */
2860     hr = IWineD3DDevice_SetFVF(This->wineD3DDevice, VertexType);
2861     if(FAILED(hr))
2862     {
2863         ERR(" (%p) Setting the FVF failed, hr = %lx!\n", This, hr);
2864         return hr;
2865     }
2866
2867     return IWineD3DDevice_DrawIndexedPrimitiveUP(This->wineD3DDevice,
2868                                                  PrimitiveType,
2869                                                  0 /* MinVertexIndex */,
2870                                                  VertexCount /* UINT NumVertexIndex */,
2871                                                  PrimitiveCount,
2872                                                  Indices,
2873                                                  WINED3DFMT_INDEX16,
2874                                                  Vertices,
2875                                                  get_flexible_vertex_size(VertexType));
2876 }
2877
2878 static HRESULT WINAPI
2879 Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitive(IDirect3DDevice3 *iface,
2880                                                  D3DPRIMITIVETYPE PrimitiveType,
2881                                                  DWORD VertexType,
2882                                                  void *Vertices,
2883                                                  DWORD VertexCount,
2884                                                  WORD *Indices,
2885                                                  DWORD IndexCount,
2886                                                  DWORD Flags)
2887 {
2888     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
2889     TRACE_(ddraw_thunk)("(%p)->(%08x,%08lx,%p,%08lx,%p,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", This, PrimitiveType, VertexType, Vertices, VertexCount, Indices, IndexCount, Flags);
2890     return IDirect3DDevice7_DrawIndexedPrimitive(ICOM_INTERFACE(This, IDirect3DDevice7),
2891                                                  PrimitiveType,
2892                                                  VertexType,
2893                                                  Vertices,
2894                                                  VertexCount,
2895                                                  Indices,
2896                                                  IndexCount,
2897                                                  Flags);
2898 }
2899
2900 static HRESULT WINAPI
2901 Thunk_IDirect3DDeviceImpl_2_DrawIndexedPrimitive(IDirect3DDevice2 *iface,
2902                                                  D3DPRIMITIVETYPE PrimitiveType,
2903                                                  D3DVERTEXTYPE VertexType,
2904                                                  void *Vertices,
2905                                                  DWORD VertexCount,
2906                                                  WORD *Indices,
2907                                                  DWORD IndexCount,
2908                                                  DWORD Flags)
2909 {
2910     DWORD FVF;
2911     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
2912     TRACE_(ddraw_thunk)("(%p)->(%08x,%08x,%p,%08lx,%p,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", This, PrimitiveType, VertexType, Vertices, VertexCount, Indices, IndexCount, Flags);
2913
2914     switch(VertexType)
2915     {
2916         case D3DVT_VERTEX: FVF = D3DFVF_VERTEX; break;
2917         case D3DVT_LVERTEX: FVF = D3DFVF_LVERTEX; break;
2918         case D3DVT_TLVERTEX: FVF = D3DFVF_TLVERTEX; break;
2919         default:
2920             ERR("Unexpected vertex type %d\n", VertexType);
2921             return DDERR_INVALIDPARAMS;  /* Should never happen */
2922     }
2923
2924     return IDirect3DDevice7_DrawIndexedPrimitive(ICOM_INTERFACE(This, IDirect3DDevice7),
2925                                                  PrimitiveType,
2926                                                  FVF,
2927                                                  Vertices,
2928                                                  VertexCount,
2929                                                  Indices,
2930                                                  IndexCount,
2931                                                  Flags);
2932 }
2933
2934 /*****************************************************************************
2935  * IDirect3DDevice7::SetClipStatus
2936  *
2937  * Sets the clip status. This defines things as clipping conditions and
2938  * the extents of the clipping region.
2939  *
2940  * Version 2, 3 and 7
2941  *
2942  * Params:
2943  *  ClipStatus:
2944  *
2945  * Returns:
2946  *  D3D_OK because it's a stub
2947  *  (DDERR_INVALIDPARAMS if ClipStatus == NULL)
2948  *
2949  *****************************************************************************/
2950 static HRESULT WINAPI
2951 IDirect3DDeviceImpl_7_SetClipStatus(IDirect3DDevice7 *iface,
2952                                     D3DCLIPSTATUS *ClipStatus)
2953 {
2954     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
2955     FIXME("(%p)->(%p): Stub!\n", This, ClipStatus);
2956
2957     /* D3DCLIPSTATUS and WINED3DCLIPSTATUS are different. I don't know how to convert them
2958      * Perhaps this needs a new data type and an additional IWineD3DDevice method
2959      */
2960     /* return IWineD3DDevice_SetClipStatus(This->wineD3DDevice, ClipStatus);*/
2961     return D3D_OK;
2962 }
2963
2964 static HRESULT WINAPI
2965 Thunk_IDirect3DDeviceImpl_3_SetClipStatus(IDirect3DDevice3 *iface,
2966                                           D3DCLIPSTATUS *ClipStatus)
2967 {
2968     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
2969     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", This, ClipStatus);
2970     return IDirect3DDevice7_SetClipStatus(ICOM_INTERFACE(This, IDirect3DDevice7),
2971                                           ClipStatus);
2972 }
2973
2974 static HRESULT WINAPI
2975 Thunk_IDirect3DDeviceImpl_2_SetClipStatus(IDirect3DDevice2 *iface,
2976                                           D3DCLIPSTATUS *ClipStatus)
2977 {
2978     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
2979     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", This, ClipStatus);
2980     return IDirect3DDevice7_SetClipStatus(ICOM_INTERFACE(This, IDirect3DDevice7),
2981                                           ClipStatus);
2982 }
2983
2984 /*****************************************************************************
2985  * IDirect3DDevice7::GetClipStatus
2986  *
2987  * Returns the clip status
2988  *
2989  * Params:
2990  *  ClipStatus: Address to write the clip status to
2991  *
2992  * Returns:
2993  *  D3D_OK because it's a stub
2994  *
2995  *****************************************************************************/
2996 static HRESULT WINAPI
2997 IDirect3DDeviceImpl_7_GetClipStatus(IDirect3DDevice7 *iface,
2998                                     D3DCLIPSTATUS *ClipStatus)
2999 {
3000     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3001     FIXME("(%p)->(%p): Stub!\n", This, ClipStatus);
3002
3003     /* D3DCLIPSTATUS and WINED3DCLIPSTATUS are different. I don't know how to convert them */
3004     /* return IWineD3DDevice_GetClipStatus(This->wineD3DDevice, ClipStatus);*/
3005     return D3D_OK;
3006 }
3007
3008 static HRESULT WINAPI
3009 Thunk_IDirect3DDeviceImpl_3_GetClipStatus(IDirect3DDevice3 *iface,
3010                                           D3DCLIPSTATUS *ClipStatus)
3011 {
3012     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
3013     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", This, ClipStatus);
3014     return IDirect3DDevice7_GetClipStatus(ICOM_INTERFACE(This, IDirect3DDevice7),
3015                                           ClipStatus);
3016 }
3017
3018 static HRESULT WINAPI
3019 Thunk_IDirect3DDeviceImpl_2_GetClipStatus(IDirect3DDevice2 *iface,
3020                                           D3DCLIPSTATUS *ClipStatus)
3021 {
3022     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
3023     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", This, ClipStatus);
3024     return IDirect3DDevice7_GetClipStatus(ICOM_INTERFACE(This, IDirect3DDevice7),
3025                                           ClipStatus);
3026 }
3027
3028 /*****************************************************************************
3029  * IDirect3DDevice::DrawPrimitiveStrided
3030  *
3031  * Draws vertices described by a D3DDRAWPRIMITIVESTRIDEDDATA structure.
3032  *
3033  * Version 3 and 7
3034  *
3035  * Params:
3036  *  PrimitiveType: The primitive type to draw
3037  *  VertexType: The FVF description of the vertices to draw (for the stride??)
3038  *  D3DDrawPrimStrideData: A D3DDRAWPRIMITIVESTRIDEDDATA structure describing
3039  *                         the vertex data locations
3040  *  VertexCount: The number of vertices to draw
3041  *  Flags: Some flags
3042  *
3043  * Returns:
3044  *  D3D_OK, because it's a stub
3045  *  (DDERR_INVALIDPARAMS if D3DDrawPrimStrideData is NULL)
3046  *  (For details, see IWineD3DDevice::DrawPrimitiveStrided)
3047  *
3048  *****************************************************************************/
3049 static HRESULT WINAPI
3050 IDirect3DDeviceImpl_7_DrawPrimitiveStrided(IDirect3DDevice7 *iface,
3051                                            D3DPRIMITIVETYPE PrimitiveType,
3052                                            DWORD VertexType,
3053                                            D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData,
3054                                            DWORD VertexCount,
3055                                            DWORD Flags)
3056 {
3057     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3058     WineDirect3DVertexStridedData WineD3DStrided;
3059     int i;
3060     UINT PrimitiveCount;
3061
3062     TRACE("(%p)->(%08x,%08lx,%p,%08lx,%08lx): stub!\n", This, PrimitiveType, VertexType, D3DDrawPrimStrideData, VertexCount, Flags);
3063
3064     /* Get the strided data right. the wined3d structure is a bit bigger
3065      * Watch out: The contents of the strided data are determined by the fvf,
3066      * not by the members set in D3DDrawPrimStrideData. So it's valid
3067      * to have diffuse.lpvData set to 0xdeadbeef if the diffuse flag is
3068      * not set in the fvf.
3069      */
3070     if(VertexType & D3DFVF_POSITION_MASK)
3071     {
3072         memset(&WineD3DStrided, 0, sizeof(WineD3DStrided));
3073         WineD3DStrided.u.s.position.lpData = D3DDrawPrimStrideData->position.lpvData;
3074         WineD3DStrided.u.s.position.dwStride = D3DDrawPrimStrideData->position.dwStride;
3075         WineD3DStrided.u.s.position.dwType = WINED3DDECLTYPE_FLOAT3;
3076         if (VertexType & D3DFVF_XYZRHW)
3077         {
3078             WineD3DStrided.u.s.position.dwType = WINED3DDECLTYPE_FLOAT4;
3079             WineD3DStrided.u.s.position_transformed = TRUE;
3080         } else
3081             WineD3DStrided.u.s.position_transformed = FALSE;
3082     }
3083
3084     if(VertexType & D3DFVF_NORMAL)
3085     {
3086         WineD3DStrided.u.s.normal.lpData = D3DDrawPrimStrideData->normal.lpvData;
3087         WineD3DStrided.u.s.normal.dwStride = D3DDrawPrimStrideData->normal.dwStride;
3088         WineD3DStrided.u.s.normal.dwType = WINED3DDECLTYPE_FLOAT3;
3089     }
3090
3091     if(VertexType & D3DFVF_DIFFUSE)
3092     {
3093         WineD3DStrided.u.s.diffuse.lpData = D3DDrawPrimStrideData->diffuse.lpvData;
3094         WineD3DStrided.u.s.diffuse.dwStride = D3DDrawPrimStrideData->diffuse.dwStride;
3095         WineD3DStrided.u.s.diffuse.dwType = WINED3DDECLTYPE_SHORT4;
3096     }
3097
3098     if(VertexType & D3DFVF_SPECULAR)
3099     {
3100         WineD3DStrided.u.s.specular.lpData = D3DDrawPrimStrideData->specular.lpvData;
3101         WineD3DStrided.u.s.specular.dwStride = D3DDrawPrimStrideData->specular.dwStride;
3102         WineD3DStrided.u.s.specular.dwType = WINED3DDECLTYPE_SHORT4;
3103     }
3104
3105     for( i = 0; i < GET_TEXCOUNT_FROM_FVF(VertexType); i++)
3106     {
3107         WineD3DStrided.u.s.texCoords[i].lpData = D3DDrawPrimStrideData->textureCoords[i].lpvData;
3108         WineD3DStrided.u.s.texCoords[i].dwStride = D3DDrawPrimStrideData->textureCoords[i].dwStride;
3109         switch(GET_TEXCOORD_SIZE_FROM_FVF(VertexType, i))
3110         {
3111             case 1: WineD3DStrided.u.s.texCoords[i].dwType = WINED3DDECLTYPE_FLOAT1; break;
3112             case 2: WineD3DStrided.u.s.texCoords[i].dwType = WINED3DDECLTYPE_FLOAT2; break;
3113             case 3: WineD3DStrided.u.s.texCoords[i].dwType = WINED3DDECLTYPE_FLOAT3; break;
3114             case 4: WineD3DStrided.u.s.texCoords[i].dwType = WINED3DDECLTYPE_FLOAT4; break;
3115             default: ERR("Unexpected texture coordinate size %ld\n",
3116                          GET_TEXCOORD_SIZE_FROM_FVF(VertexType, i));
3117         }
3118     }
3119
3120     /* Get the primitive count */
3121     switch(PrimitiveType)
3122     {
3123         case D3DPT_POINTLIST:
3124           PrimitiveCount = VertexCount;
3125           break;
3126
3127         case D3DPT_LINELIST:
3128           PrimitiveCount = VertexCount / 2;
3129           break;
3130
3131         case D3DPT_LINESTRIP:
3132           PrimitiveCount = VertexCount - 1;
3133           break;
3134
3135         case D3DPT_TRIANGLELIST:
3136           PrimitiveCount = VertexCount / 3;
3137           break;
3138
3139         case D3DPT_TRIANGLESTRIP:
3140           PrimitiveCount = VertexCount - 2;
3141           break;
3142
3143         case D3DPT_TRIANGLEFAN:
3144           PrimitiveCount = VertexCount - 2;
3145           break;
3146
3147         default: return DDERR_INVALIDPARAMS;
3148     }
3149
3150     IWineD3DDevice_SetFVF(This->wineD3DDevice,
3151                           VertexType);
3152
3153     return IWineD3DDevice_DrawPrimitiveStrided(This->wineD3DDevice,
3154                                                PrimitiveType,
3155                                                PrimitiveCount,
3156                                                &WineD3DStrided);
3157 }
3158
3159 static HRESULT WINAPI
3160 Thunk_IDirect3DDeviceImpl_3_DrawPrimitiveStrided(IDirect3DDevice3 *iface,
3161                                                  D3DPRIMITIVETYPE PrimitiveType,
3162                                                  DWORD VertexType,
3163                                                  D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData,
3164                                                  DWORD VertexCount,
3165                                                  DWORD Flags)
3166 {
3167     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
3168     TRACE_(ddraw_thunk)("(%p)->(%08x,%08lx,%p,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", This, PrimitiveType, VertexType, D3DDrawPrimStrideData, VertexCount, Flags);
3169     return IDirect3DDevice7_DrawPrimitiveStrided(ICOM_INTERFACE(This, IDirect3DDevice7),
3170                                                  PrimitiveType,
3171                                                  VertexType,
3172                                                  D3DDrawPrimStrideData,
3173                                                  VertexCount,
3174                                                  Flags);
3175 }
3176
3177 /*****************************************************************************
3178  * IDirect3DDevice7::DrawIndexedPrimitiveStrided
3179  *
3180  * Draws primitives specified by strided data locations based on indices
3181  *
3182  * Version 3 and 7
3183  *
3184  * Params:
3185  *  PrimitiveType:
3186  *
3187  * Returns:
3188  *  D3D_OK, because it's a stub
3189  *  (DDERR_INVALIDPARAMS if D3DDrawPrimStrideData is NULL)
3190  *  (DDERR_INVALIDPARAMS if Indices is NULL)
3191  *  (For more details, see IWineD3DDevice::DrawIndexedPrimitiveStrided)
3192  *
3193  *****************************************************************************/
3194 static HRESULT WINAPI
3195 IDirect3DDeviceImpl_7_DrawIndexedPrimitiveStrided(IDirect3DDevice7 *iface,
3196                                                   D3DPRIMITIVETYPE PrimitiveType,
3197                                                   DWORD VertexType,
3198                                                   D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData,
3199                                                   DWORD VertexCount,
3200                                                   WORD *Indices,
3201                                                   DWORD IndexCount,
3202                                                   DWORD Flags)
3203 {
3204     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3205     FIXME("(%p)->(%08x,%08lx,%p,%08lx,%p,%08lx,%08lx): stub!\n", This, PrimitiveType, VertexType, D3DDrawPrimStrideData, VertexCount, Indices, IndexCount, Flags);
3206
3207     /* I'll implement it as soon as I find a app to test it.
3208      * This needs an additional method in IWineD3DDevice.
3209      */
3210     return D3D_OK;
3211 }
3212
3213 static HRESULT WINAPI
3214 Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitiveStrided(IDirect3DDevice3 *iface,
3215                                                         D3DPRIMITIVETYPE PrimitiveType,
3216                                                         DWORD VertexType,
3217                                                         D3DDRAWPRIMITIVESTRIDEDDATA *D3DDrawPrimStrideData,
3218                                                         DWORD VertexCount,
3219                                                         WORD *Indices,
3220                                                         DWORD IndexCount,
3221                                                         DWORD Flags)
3222 {
3223     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
3224     TRACE_(ddraw_thunk)("(%p)->(%08x,%08lx,%p,%08lx,%p,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", iface, PrimitiveType, VertexType, D3DDrawPrimStrideData, VertexCount, Indices, IndexCount, Flags);
3225     return IDirect3DDevice7_DrawIndexedPrimitiveStrided(ICOM_INTERFACE(This, IDirect3DDevice7),
3226                                                         PrimitiveType,
3227                                                         VertexType,
3228                                                         D3DDrawPrimStrideData,
3229                                                         VertexCount,
3230                                                         Indices,
3231                                                         IndexCount,
3232                                                         Flags);
3233 }
3234
3235 /*****************************************************************************
3236  * IDirect3DDevice7::DrawPrimitiveVB
3237  *
3238  * Draws primitives from a vertex buffer to the screen.
3239  *
3240  * Version 3 and 7
3241  *
3242  * Params:
3243  *  PrimitiveType: Type of primitive to be rendered.
3244  *  D3DVertexBuf: Source Vertex Buffer
3245  *  StartVertex: Index of the first vertex from the buffer to be rendered
3246  *  NumVertices: Number of vertices to be rendered
3247  *  Flags: Can be D3DDP_WAIT to wait until rendering has finished
3248  *
3249  * Return values
3250  *  D3D_OK on success
3251  *  DDERR_INVALIDPARAMS if D3DVertexBuf is NULL
3252  *
3253  *****************************************************************************/
3254 static HRESULT WINAPI
3255 IDirect3DDeviceImpl_7_DrawPrimitiveVB(IDirect3DDevice7 *iface,
3256                                       D3DPRIMITIVETYPE PrimitiveType,
3257                                       IDirect3DVertexBuffer7 *D3DVertexBuf,
3258                                       DWORD StartVertex,
3259                                       DWORD NumVertices,
3260                                       DWORD Flags)
3261 {
3262     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3263     IDirect3DVertexBufferImpl *vb = ICOM_OBJECT(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, D3DVertexBuf);
3264     UINT PrimitiveCount;
3265     HRESULT hr;
3266     DWORD stride;
3267     WINED3DVERTEXBUFFER_DESC Desc;
3268
3269     TRACE("(%p)->(%08x,%p,%08lx,%08lx,%08lx)\n", This, PrimitiveType, D3DVertexBuf, StartVertex, NumVertices, Flags);
3270
3271     /* Sanity checks */
3272     if(!vb)
3273     {
3274         ERR("(%p) No Vertex buffer specified\n", This);
3275         return DDERR_INVALIDPARAMS;
3276     }
3277
3278     /* Get the primitive count */
3279     switch(PrimitiveType)
3280     {
3281         case D3DPT_POINTLIST:
3282           PrimitiveCount = NumVertices;
3283           break;
3284
3285         case D3DPT_LINELIST:
3286           PrimitiveCount = NumVertices / 2;
3287           break;
3288
3289         case D3DPT_LINESTRIP:
3290           PrimitiveCount = NumVertices - 1;
3291           break;
3292
3293         case D3DPT_TRIANGLELIST:
3294           PrimitiveCount = NumVertices / 3;
3295           break;
3296
3297         case D3DPT_TRIANGLESTRIP:
3298           PrimitiveCount = NumVertices - 2;
3299           break;
3300
3301         case D3DPT_TRIANGLEFAN:
3302           PrimitiveCount = NumVertices - 2;
3303           break;
3304
3305         default: return DDERR_INVALIDPARAMS;
3306     }
3307
3308     /* Get the FVF of the vertex buffer, and its stride */
3309     hr = IWineD3DVertexBuffer_GetDesc(vb->wineD3DVertexBuffer,
3310                                       &Desc);
3311     if(hr != D3D_OK)
3312     {
3313         ERR("(%p) IWineD3DVertexBuffer::GetDesc failed with hr = %08lx\n", This, hr);
3314         return hr;
3315     }
3316     stride = get_flexible_vertex_size(Desc.FVF);
3317
3318     hr = IWineD3DDevice_SetFVF(This->wineD3DDevice, Desc.FVF);
3319     if(FAILED(hr))
3320     {
3321         ERR(" (%p) Setting the FVF failed, hr = %lx!\n", This, hr);
3322         return hr;
3323     }
3324
3325     /* Set the vertex stream source */
3326     hr = IWineD3DDevice_SetStreamSource(This->wineD3DDevice,
3327                                         0 /* StreamNumber */,
3328                                         vb->wineD3DVertexBuffer,
3329                                         0 /* StartVertex - we pass this to DrawPrimitive */,
3330                                         stride);
3331     if(hr != D3D_OK)
3332     {
3333         ERR("(%p) IDirect3DDevice::SetStreamSource failed with hr = %08lx\n", This, hr);
3334         return hr;
3335     }
3336
3337     /* Now draw the primitives */
3338     return IWineD3DDevice_DrawPrimitive(This->wineD3DDevice,
3339                                         PrimitiveType,
3340                                         StartVertex,
3341                                         PrimitiveCount);
3342 }
3343
3344 static HRESULT WINAPI
3345 Thunk_IDirect3DDeviceImpl_3_DrawPrimitiveVB(IDirect3DDevice3 *iface,
3346                                             D3DPRIMITIVETYPE PrimitiveType,
3347                                             IDirect3DVertexBuffer *D3DVertexBuf,
3348                                             DWORD StartVertex,
3349                                             DWORD NumVertices,
3350                                             DWORD Flags)
3351 {
3352     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
3353     IDirect3DVertexBufferImpl *vb = ICOM_OBJECT(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, D3DVertexBuf);
3354     TRACE_(ddraw_thunk)("(%p)->(%08x,%p,%08lx,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", This,  PrimitiveType, vb, StartVertex, NumVertices, Flags);
3355     return IDirect3DDevice7_DrawPrimitiveVB(ICOM_INTERFACE(This, IDirect3DDevice7),
3356                                             PrimitiveType,
3357                                             ICOM_INTERFACE(vb, IDirect3DVertexBuffer7),
3358                                             StartVertex,
3359                                             NumVertices,
3360                                             Flags);
3361 }
3362
3363
3364 /*****************************************************************************
3365  * IDirect3DDevice7::DrawIndexedPrimitiveVB
3366  *
3367  * Draws primitives from a vertex buffer to the screen
3368  *
3369  * Params:
3370  *  PrimitiveType: Type of primitive to be rendered.
3371  *  D3DVertexBuf: Source Vertex Buffer
3372  *  StartVertex: Index of the first vertex from the buffer to be rendered
3373  *  NumVertices: Number of vertices to be rendered
3374  *  Indices: Array of DWORDs used to index into the Vertices
3375  *  IndexCount: Number of indices in Indices
3376  *  Flags: Can be D3DDP_WAIT to wait until rendering has finished
3377  *
3378  * Return values
3379  *
3380  *****************************************************************************/
3381 static HRESULT WINAPI
3382 IDirect3DDeviceImpl_7_DrawIndexedPrimitiveVB(IDirect3DDevice7 *iface,
3383                                              D3DPRIMITIVETYPE PrimitiveType,
3384                                              IDirect3DVertexBuffer7 *D3DVertexBuf,
3385                                              DWORD StartVertex,
3386                                              DWORD NumVertices,
3387                                              WORD *Indices,
3388                                              DWORD IndexCount,
3389                                              DWORD Flags)
3390 {
3391     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3392     IDirect3DVertexBufferImpl *vb = ICOM_OBJECT(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, D3DVertexBuf);
3393     DWORD stride;
3394     UINT PrimitiveCount;
3395     WORD *LockedIndices;
3396     HRESULT hr;
3397     WINED3DVERTEXBUFFER_DESC Desc;
3398
3399     TRACE("(%p)->(%08x,%p,%ld,%ld,%p,%ld,%08lx)\n", This, PrimitiveType, vb, StartVertex, NumVertices, Indices, IndexCount, Flags);
3400
3401     /* Steps:
3402      * 1) Calculate some things: Vertex count -> Primitive count, stride, ...
3403      * 2) Upload the Indices to the index buffer
3404      * 3) Set the index source
3405      * 4) Set the Vertex Buffer as the Stream source
3406      * 5) Call IWineD3DDevice::DrawIndexedPrimitive
3407      */
3408
3409     /* Get the primitive count */
3410     switch(PrimitiveType)
3411     {
3412         case D3DPT_POINTLIST:
3413           PrimitiveCount = IndexCount;
3414           break;
3415
3416         case D3DPT_LINELIST:
3417           PrimitiveCount = IndexCount / 2;
3418           break;
3419
3420         case D3DPT_LINESTRIP:
3421           PrimitiveCount = IndexCount - 1;
3422           break;
3423
3424         case D3DPT_TRIANGLELIST:
3425           PrimitiveCount = IndexCount / 3;
3426           break;
3427
3428         case D3DPT_TRIANGLESTRIP:
3429           PrimitiveCount = IndexCount - 2;
3430           break;
3431
3432         case D3DPT_TRIANGLEFAN:
3433           PrimitiveCount = IndexCount - 2;
3434           break;
3435
3436         default: return DDERR_INVALIDPARAMS;
3437     }
3438
3439     /* Get the FVF of the vertex buffer, and its stride */
3440     hr = IWineD3DVertexBuffer_GetDesc(vb->wineD3DVertexBuffer,
3441                                       &Desc);
3442     if(hr != D3D_OK)
3443     {
3444         ERR("(%p) IWineD3DVertexBuffer::GetDesc failed with hr = %08lx\n", This, hr);
3445         return hr;
3446     }
3447     stride = get_flexible_vertex_size(Desc.FVF);
3448     TRACE("Vertex buffer FVF = %08lx, stride=%ld\n", Desc.FVF, stride);
3449
3450     hr = IWineD3DDevice_SetFVF(This->wineD3DDevice, Desc.FVF);
3451     if(FAILED(hr))
3452     {
3453         ERR(" (%p) Setting the FVF failed, hr = %lx!\n", This, hr);
3454         return hr;
3455     }
3456
3457     /* copy the index stream into the index buffer.
3458      * A new IWineD3DDevice method could be created
3459      * which takes an user pointer containing the indices
3460      * or a SetData-Method for the index buffer, which
3461      * overrides the index buffer data with our pointer.
3462      */
3463     hr = IWineD3DIndexBuffer_Lock(This->indexbuffer,
3464                                   0 /* OffSetToLock */,
3465                                   0 /* SizeToLock - doesn't matter */,
3466                                   (BYTE **) &LockedIndices,
3467                                   0 /* Flags */);
3468     assert(IndexCount < 0x100000);
3469     if(hr != D3D_OK)
3470     {
3471         ERR("(%p) IWineD3DIndexBuffer::Lock failed with hr = %08lx\n", This, hr);
3472         return hr;
3473     }
3474     memcpy(LockedIndices, Indices, IndexCount * sizeof(WORD));
3475     hr = IWineD3DIndexBuffer_Unlock(This->indexbuffer);
3476     if(hr != D3D_OK)
3477     {
3478         ERR("(%p) IWineD3DIndexBuffer::Unlock failed with hr = %08lx\n", This, hr);
3479         return hr;
3480     }
3481
3482     /* Set the index stream */
3483     hr = IWineD3DDevice_SetIndices(This->wineD3DDevice,
3484                                    This->indexbuffer,
3485                                    0);
3486
3487     /* Set the vertex stream source */
3488     hr = IWineD3DDevice_SetStreamSource(This->wineD3DDevice,
3489                                         0 /* StreamNumber */,
3490                                         vb->wineD3DVertexBuffer,
3491                                         0 /* offset, we pass this to DrawIndexedPrimitive */,
3492                                         stride);
3493     if(hr != D3D_OK)
3494     {
3495         ERR("(%p) IDirect3DDevice::SetStreamSource failed with hr = %08lx\n", This, hr);
3496         return hr;
3497     }
3498
3499
3500     hr = IWineD3DDevice_DrawIndexedPrimitive(This->wineD3DDevice,
3501                                              PrimitiveType,
3502                                              StartVertex,
3503                                              0 /* minIndex */,
3504                                              NumVertices,
3505                                              0 /* StartIndex */,
3506                                              PrimitiveCount);
3507
3508     return D3D_OK;
3509 }
3510
3511 static HRESULT WINAPI
3512 Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitiveVB(IDirect3DDevice3 *iface,
3513                                                    D3DPRIMITIVETYPE PrimitiveType,
3514                                                    IDirect3DVertexBuffer *D3DVertexBuf,
3515                                                    WORD *Indices,
3516                                                    DWORD IndexCount,
3517                                                    DWORD Flags)
3518 {
3519     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
3520     IDirect3DVertexBufferImpl *VB = ICOM_OBJECT(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, D3DVertexBuf);
3521     TRACE_(ddraw_thunk)("(%p)->(%08x,%p,%p,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", This, PrimitiveType, VB, Indices, IndexCount, Flags);
3522
3523     return IDirect3DDevice7_DrawIndexedPrimitiveVB(ICOM_INTERFACE(This, IDirect3DDevice7),
3524                                                    PrimitiveType,
3525                                                    ICOM_INTERFACE(VB, IDirect3DVertexBuffer7),
3526                                                    0,
3527                                                    IndexCount,
3528                                                    Indices,
3529                                                    IndexCount,
3530                                                    Flags);
3531 }
3532
3533 /*****************************************************************************
3534  * IDirect3DDevice7::ComputeSphereVisibility
3535  *
3536  * Calculates the visibility of spheres in the current viewport. The spheres
3537  * are passed in the Centers and Radii arrays, the results are passed back
3538  * in the ReturnValues array. Return values are either completely visible,
3539  * partially visible or completely invisible.
3540  * The return value consist of a combination of D3DCLIP_* flags, or it's
3541  * 0 if the sphere is completely visible(according to the SDK, not checked)
3542  *
3543  * Sounds like an overdose of math ;)
3544  *
3545  * Version 3 and 7
3546  *
3547  * Params:
3548  *  Centers: Array containing the sphere centers
3549  *  Radii: Array containing the sphere radii
3550  *  NumSpheres: The number of centers and radii in the arrays
3551  *  Flags: Some flags
3552  *  ReturnValues: Array to write the results to
3553  *
3554  * Returns:
3555  *  D3D_OK because it's a stub
3556  *  (DDERR_INVALIDPARAMS if Centers, Radii or ReturnValues are NULL)
3557  *  (D3DERR_INVALIDMATRIX if the combined world, view and proj matrix
3558  *  is singular)
3559  *
3560  *****************************************************************************/
3561 static HRESULT WINAPI
3562 IDirect3DDeviceImpl_7_ComputeSphereVisibility(IDirect3DDevice7 *iface,
3563                                               D3DVECTOR *Centers,
3564                                               D3DVALUE *Radii,
3565                                               DWORD NumSpheres,
3566                                               DWORD Flags,
3567                                               DWORD *ReturnValues)
3568 {
3569     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3570     FIXME("(%p)->(%p,%p,%08lx,%08lx,%p): stub!\n", This, Centers, Radii, NumSpheres, Flags, ReturnValues);
3571
3572     /* the DirectX 7 sdk says that the visibility is computed by
3573      * back-transforming the viewing frustum to model space
3574      * using the inverse of the combined world, view and projection
3575      * matrix. If the matrix can't be reversed, D3DERR_INVALIDMATRIX
3576      * is returned.
3577      *
3578      * Basic implementation idea:
3579      * 1) Check if the center is in the viewing frustum
3580      * 2) Cut the sphere with the planes of the viewing
3581      *    frustum
3582      *
3583      * ->Center inside the frustum, no intersections:
3584      *    Fully visible
3585      * ->Center outside the frustum, no intersections:
3586      *    Not visible
3587      * ->Some intersections: Partially visible
3588      *
3589      * Implement this call in WineD3D. Either implement the
3590      * matrix and vector stuff in WineD3D, or use some external
3591      * math library.
3592      */
3593
3594     return D3D_OK;
3595 }
3596
3597 static HRESULT WINAPI
3598 Thunk_IDirect3DDeviceImpl_3_ComputeSphereVisibility(IDirect3DDevice3 *iface,
3599                                                     D3DVECTOR *Centers,
3600                                                     D3DVALUE *Radii,
3601                                                     DWORD NumSpheres,
3602                                                     DWORD Flags,
3603                                                     DWORD *ReturnValues)
3604 {
3605     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
3606     TRACE_(ddraw_thunk)("(%p)->(%p,%p,%08lx,%08lx,%p) thunking to IDirect3DDevice7 interface.\n", This, Centers, Radii, NumSpheres, Flags, ReturnValues);
3607     return IDirect3DDevice7_ComputeSphereVisibility(ICOM_INTERFACE(This, IDirect3DDevice7),
3608                                                     Centers,
3609                                                     Radii,
3610                                                     NumSpheres,
3611                                                     Flags,
3612                                                     ReturnValues);
3613 }
3614
3615 /*****************************************************************************
3616  * IDirect3DDevice7::GetTexture
3617  *
3618  * Returns the texture interface handle assigned to a texture stage.
3619  * The returned texture is AddRefed. This is taken from old ddraw,
3620  * not checked in Windows.
3621  *
3622  * Version 3 and 7
3623  *
3624  * Params:
3625  *  Stage: Texture stage to read the texture from
3626  *  Texture: Address to store the interface pointer at
3627  *
3628  * Returns:
3629  *  D3D_OK on success
3630  *  DDERR_INVALIDPARAMS if Texture is NULL
3631  *  For details, see IWineD3DDevice::GetTexture
3632  *
3633  *****************************************************************************/
3634 static HRESULT WINAPI
3635 IDirect3DDeviceImpl_7_GetTexture(IDirect3DDevice7 *iface,
3636                                  DWORD Stage,
3637                                  IDirectDrawSurface7 **Texture)
3638 {
3639     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3640     IWineD3DBaseTexture *Surf;
3641     HRESULT hr;
3642     TRACE("(%p)->(%ld,%p): Relay\n", This, Stage, Texture);
3643
3644     if(!Texture)
3645     {
3646         TRACE("Texture == NULL, failing with DDERR_INVALIDPARAMS\n");
3647         return DDERR_INVALIDPARAMS;
3648     }
3649
3650     hr = IWineD3DDevice_GetTexture(This->wineD3DDevice, Stage, (IWineD3DBaseTexture **) &Surf);
3651     if( (hr != D3D_OK) || (!Surf) )
3652     {
3653         *Texture = NULL;
3654         return hr;
3655     }
3656
3657     /* GetParent AddRef()s, which is perfectly OK.
3658      * We have passed the IDirectDrawSurface7 interface to WineD3D, so that's OK too.
3659      */
3660     return IWineD3DBaseTexture_GetParent(Surf,
3661                                          (IUnknown **) Texture);
3662 }
3663
3664 static HRESULT WINAPI
3665 Thunk_IDirect3DDeviceImpl_3_GetTexture(IDirect3DDevice3 *iface,
3666                                        DWORD Stage,
3667                                        IDirect3DTexture2 **Texture2)
3668 {
3669     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
3670     HRESULT ret;
3671     IDirectDrawSurface7 *ret_val;
3672
3673     TRACE_(ddraw_thunk)("(%p)->(%ld,%p) thunking to IDirect3DDevice7 interface.\n", This, Stage, Texture2);
3674     ret = IDirect3DDevice7_GetTexture(ICOM_INTERFACE(This, IDirect3DDevice7),
3675                                       Stage,
3676                                       &ret_val);
3677
3678     *Texture2 = COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7, IDirect3DTexture2, ret_val);
3679
3680     TRACE_(ddraw_thunk)(" returning interface %p.\n", *Texture2);
3681
3682     return ret;
3683 }
3684
3685 /*****************************************************************************
3686  * IDirect3DDevice7::SetTexture
3687  *
3688  * Assigns a texture to a texture stage. Is the texture AddRef-ed?
3689  *
3690  * Version 3 and 7
3691  *
3692  * Params:
3693  *  Stage: The stage to assign the texture to
3694  *  Texture: Interface pointer to the texture surface
3695  *
3696  * Returns
3697  * D3D_OK on success
3698  * For details, see IWineD3DDevice::SetTexture
3699  *
3700  *****************************************************************************/
3701 static HRESULT WINAPI
3702 IDirect3DDeviceImpl_7_SetTexture(IDirect3DDevice7 *iface,
3703                                  DWORD Stage,
3704                                  IDirectDrawSurface7 *Texture)
3705 {
3706     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3707     IDirectDrawSurfaceImpl *surf = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, Texture);
3708     TRACE("(%p)->(%08lx,%p): Relay!\n", This, Stage, surf);
3709
3710     /* Texture may be NULL here */
3711     return IWineD3DDevice_SetTexture(This->wineD3DDevice,
3712                                      Stage,
3713                                      surf ? (IWineD3DBaseTexture * ) surf->wineD3DTexture : NULL);
3714 }
3715
3716 static HRESULT WINAPI
3717 Thunk_IDirect3DDeviceImpl_3_SetTexture(IDirect3DDevice3 *iface,
3718                                        DWORD Stage,
3719                                        IDirect3DTexture2 *Texture2)
3720 {
3721     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
3722     IDirectDrawSurfaceImpl *tex = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirect3DTexture2, Texture2);
3723     TRACE_(ddraw_thunk)("(%p)->(%ld,%p) thunking to IDirect3DDevice7 interface.\n", This, Stage, tex);
3724     return IDirect3DDevice7_SetTexture(ICOM_INTERFACE(This, IDirect3DDevice7),
3725                                        Stage,
3726                                        ICOM_INTERFACE(tex, IDirectDrawSurface7));
3727 }
3728
3729 /*****************************************************************************
3730  * IDirect3DDevice7::GetTextureStageState
3731  *
3732  * Retrieves a state from a texture stage.
3733  *
3734  * Version 3 and 7
3735  *
3736  * Params:
3737  *  Stage: The stage to retrieve the state from
3738  *  TexStageStateType: The state type to retrieve
3739  *  State: Address to store the state's value at
3740  *
3741  * Returns:
3742  *  D3D_OK on success
3743  *  DDERR_INVALIDPARAMS if State is NULL
3744  *  For details, see IWineD3DDevice::GetTextureStageState
3745  *
3746  *****************************************************************************/
3747 static HRESULT WINAPI
3748 IDirect3DDeviceImpl_7_GetTextureStageState(IDirect3DDevice7 *iface,
3749                                            DWORD Stage,
3750                                            D3DTEXTURESTAGESTATETYPE TexStageStateType,
3751                                            DWORD *State)
3752 {
3753     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3754     TRACE("(%p)->(%08lx,%08x,%p): Relay!\n", This, Stage, TexStageStateType, State);
3755
3756     if(!State)
3757         return DDERR_INVALIDPARAMS;
3758
3759     return IWineD3DDevice_GetTextureStageState(This->wineD3DDevice,
3760                                                Stage,
3761                                                TexStageStateType,
3762                                                State);
3763 }
3764
3765 static HRESULT WINAPI
3766 Thunk_IDirect3DDeviceImpl_3_GetTextureStageState(IDirect3DDevice3 *iface,
3767                                                  DWORD Stage,
3768                                                  D3DTEXTURESTAGESTATETYPE TexStageStateType,
3769                                                  DWORD *State)
3770 {
3771     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
3772     TRACE_(ddraw_thunk)("(%p)->(%08lx,%08x,%p) thunking to IDirect3DDevice7 interface.\n", This, Stage, TexStageStateType, State);
3773     return IDirect3DDevice7_GetTextureStageState(ICOM_INTERFACE(This, IDirect3DDevice7),
3774                                                  Stage,
3775                                                  TexStageStateType,
3776                                                  State);
3777 }
3778
3779 /*****************************************************************************
3780  * IDirect3DDevice7::SetTextureStageState
3781  *
3782  * Sets a texture stage state. Some stage types need to be handled specially,
3783  * because they do not exist in WineD3D and were moved to another place
3784  *
3785  * Version 3 and 7
3786  *
3787  * Params:
3788  *  Stage: The stage to modify
3789  *  TexStageStateType: The state to change
3790  *  State: The new value for the state
3791  *
3792  * Returns:
3793  *  D3D_OK on success
3794  *  For details, see IWineD3DDevice::SetTextureStageState
3795  *
3796  *****************************************************************************/
3797 static HRESULT WINAPI
3798 IDirect3DDeviceImpl_7_SetTextureStageState(IDirect3DDevice7 *iface,
3799                                            DWORD Stage,
3800                                            D3DTEXTURESTAGESTATETYPE TexStageStateType,
3801                                            DWORD State)
3802 {
3803     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3804     TRACE("(%p)->(%08lx,%08x,%08lx): Relay!\n", This, Stage, TexStageStateType, State);
3805     switch(TexStageStateType)
3806     {
3807         /* Mipfilter is a sampler state with different values */
3808         case D3DTSS_MIPFILTER:
3809         {
3810             WINED3DTEXTUREFILTERTYPE value;
3811             switch(State)
3812             {
3813                 case D3DTFP_NONE: value = WINED3DTEXF_NONE; break;
3814                 case D3DTFP_POINT: value = WINED3DTEXF_POINT; break;
3815                 case 0: /* Unchecked */
3816                 case D3DTFP_LINEAR: value = WINED3DTEXF_LINEAR; break;
3817                 default:
3818                     ERR("Unexpected mipfilter value %ld\n", State);
3819                     value = WINED3DTEXF_NONE;
3820             }
3821             return IWineD3DDevice_SetSamplerState(This->wineD3DDevice,
3822                                                   Stage,
3823                                                   WINED3DSAMP_MIPFILTER,
3824                                                   value);
3825         }
3826
3827         /* Minfilter is a sampler state too, equal values */
3828         case D3DTSS_MINFILTER:
3829             return IWineD3DDevice_SetSamplerState(This->wineD3DDevice,
3830                                                   Stage,
3831                                                   WINED3DSAMP_MINFILTER,
3832                                                   State);
3833         /* Same for MAGFILTER */
3834         case D3DTSS_MAGFILTER:
3835             return IWineD3DDevice_SetSamplerState(This->wineD3DDevice,
3836                                                   Stage,
3837                                                   WINED3DSAMP_MAGFILTER,
3838                                                   State);
3839
3840         default:
3841
3842             return IWineD3DDevice_SetTextureStageState(This->wineD3DDevice,
3843                                                       Stage,
3844                                                       TexStageStateType,
3845                                                       State);
3846     }
3847 }
3848
3849 static HRESULT WINAPI
3850 Thunk_IDirect3DDeviceImpl_3_SetTextureStageState(IDirect3DDevice3 *iface,
3851                                                  DWORD Stage,
3852                                                  D3DTEXTURESTAGESTATETYPE TexStageStateType,
3853                                                  DWORD State)
3854 {
3855     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
3856     TRACE_(ddraw_thunk)("(%p)->(%08lx,%08x,%08lx) thunking to IDirect3DDevice7 interface.\n", This, Stage, TexStageStateType, State);
3857     return IDirect3DDevice7_SetTextureStageState(ICOM_INTERFACE(This, IDirect3DDevice7),
3858                                                  Stage,
3859                                                  TexStageStateType,
3860                                                  State);
3861 }
3862
3863 /*****************************************************************************
3864  * IDirect3DDevice7::ValidateDevice
3865  *
3866  * SDK: "Reports the device's ability to render the currently set
3867  * texture-blending operations in a single pass". Whatever that means
3868  * exactly...
3869  *
3870  * Version 3 and 7
3871  *
3872  * Params:
3873  *  NumPasses: Address to write the number of necessary passes for the
3874  *             desired effect to.
3875  *
3876  * Returns:
3877  *  D3D_OK on success
3878  *  See IWineD3DDevice::ValidateDevice for more details
3879  *
3880  *****************************************************************************/
3881 static HRESULT WINAPI
3882 IDirect3DDeviceImpl_7_ValidateDevice(IDirect3DDevice7 *iface,
3883                                      DWORD *NumPasses)
3884 {
3885     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3886     TRACE("(%p)->(%p): Relay\n", This, NumPasses);
3887
3888     return IWineD3DDevice_ValidateDevice(This->wineD3DDevice, NumPasses);
3889 }
3890
3891 static HRESULT WINAPI
3892 Thunk_IDirect3DDeviceImpl_3_ValidateDevice(IDirect3DDevice3 *iface,
3893                                            DWORD *Passes)
3894 {
3895     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
3896     TRACE_(ddraw_thunk)("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", This, Passes);
3897     return IDirect3DDevice7_ValidateDevice(ICOM_INTERFACE(This, IDirect3DDevice7),
3898                                            Passes);
3899 }
3900
3901 /*****************************************************************************
3902  * IDirect3DDevice7::Clear
3903  *
3904  * Fills the render target, the z buffer and the stencil buffer with a
3905  * clear color / value
3906  *
3907  * Version 7 only
3908  *
3909  * Params:
3910  *  Count: Number of rectangles in Rects must be 0 if Rects is NULL
3911  *  Rects: Rectangles to clear. If NULL, the whole surface is cleared
3912  *  Flags: Some flags, as usual
3913  *  Color: Clear color for the render target
3914  *  Z: Clear value for the Z buffer
3915  *  Stencil: Clear value to store in each stencil buffer entry
3916  *
3917  * Returns:
3918  *  D3D_OK on success
3919  *  For details, see IWineD3DDevice::Clear
3920  *
3921  *****************************************************************************/
3922 static HRESULT WINAPI
3923 IDirect3DDeviceImpl_7_Clear(IDirect3DDevice7 *iface,
3924                             DWORD Count,
3925                             D3DRECT *Rects,
3926                             DWORD Flags,
3927                             D3DCOLOR Color,
3928                             D3DVALUE Z,
3929                             DWORD Stencil)
3930 {
3931     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3932     TRACE("(%p)->(%08lx,%p,%08lx,%08lx,%f,%08lx): Relay\n", This, Count, Rects, Flags, (DWORD) Color, Z, Stencil);
3933
3934     return IWineD3DDevice_Clear(This->wineD3DDevice, Count, Rects, Flags, Color, Z, Stencil);
3935 }
3936
3937 /*****************************************************************************
3938  * IDirect3DDevice7::SetViewport
3939  *
3940  * Sets the current viewport.
3941  *
3942  * Version 7 only, but IDirect3DViewport uses this call for older
3943  * versions
3944  *
3945  * Params:
3946  *  Data: The new viewport to set
3947  *
3948  * Returns:
3949  *  D3D_OK on success
3950  *  DDERR_INVALIDPARAMS if Data is NULL
3951  *  For more details, see IWineDDDevice::SetViewport
3952  *
3953  *****************************************************************************/
3954 static HRESULT WINAPI
3955 IDirect3DDeviceImpl_7_SetViewport(IDirect3DDevice7 *iface,
3956                                   D3DVIEWPORT7 *Data)
3957 {
3958     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3959     TRACE("(%p)->(%p) Relay!\n", This, Data);
3960
3961     if(!Data)
3962         return DDERR_INVALIDPARAMS;
3963
3964     return IWineD3DDevice_SetViewport(This->wineD3DDevice,
3965                                       Data);
3966 }
3967
3968 /*****************************************************************************
3969  * IDirect3DDevice::GetViewport
3970  *
3971  * Returns the current viewport
3972  *
3973  * Version 7
3974  *
3975  * Params:
3976  *  Data: D3D7Viewport structure to write the viewport information to
3977  *
3978  * Returns:
3979  *  D3D_OK on success
3980  *  DDERR_INVALIDPARAMS if Data is NULL
3981  *  For more details, see IWineD3DDevice::GetViewport
3982  *
3983  *****************************************************************************/
3984 static HRESULT WINAPI
3985 IDirect3DDeviceImpl_7_GetViewport(IDirect3DDevice7 *iface,
3986                                   D3DVIEWPORT7 *Data)
3987 {
3988     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
3989     HRESULT hr;
3990     TRACE("(%p)->(%p) Relay!\n", This, Data);
3991
3992     if(!Data)
3993         return DDERR_INVALIDPARAMS;
3994
3995     hr = IWineD3DDevice_GetViewport(This->wineD3DDevice,
3996                                     Data);
3997     return hr_ddraw_from_wined3d(hr);
3998 }
3999
4000 /*****************************************************************************
4001  * IDirect3DDevice7::SetMaterial
4002  *
4003  * Sets the Material
4004  *
4005  * Version 7
4006  *
4007  * Params:
4008  *  Mat: The material to set
4009  *
4010  * Returns:
4011  *  D3D_OK on success
4012  *  DDERR_INVALIDPARAMS if Mat is NULL.
4013  *  For more details, see IWineD3DDevice::SetMaterial
4014  *
4015  *****************************************************************************/
4016 static HRESULT WINAPI
4017 IDirect3DDeviceImpl_7_SetMaterial(IDirect3DDevice7 *iface,
4018                                   D3DMATERIAL7 *Mat)
4019 {
4020     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4021     HRESULT hr;
4022     TRACE("(%p)->(%p): Relay!\n", This, Mat);
4023
4024     hr = IWineD3DDevice_SetMaterial(This->wineD3DDevice,
4025                                     Mat);
4026     return hr_ddraw_from_wined3d(hr);
4027 }
4028
4029 /*****************************************************************************
4030  * IDirect3DDevice7::GetMaterial
4031  *
4032  * Returns the current material
4033  *
4034  * Version 7
4035  *
4036  * Params:
4037  *  Mat: D3DMATERIAL7 structure to write the material parameters to
4038  *
4039  * Returns:
4040  *  D3D_OK on success
4041  *  DDERR_INVALIDPARAMS if Mat is NULL
4042  *  For more details, see IWineD3DDevice::GetMaterial
4043  *
4044  *****************************************************************************/
4045 static HRESULT WINAPI
4046 IDirect3DDeviceImpl_7_GetMaterial(IDirect3DDevice7 *iface,
4047                                   D3DMATERIAL7 *Mat)
4048 {
4049     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4050     HRESULT hr;
4051     TRACE("(%p)->(%p): Relay!\n", This, Mat);
4052
4053     hr = IWineD3DDevice_GetMaterial(This->wineD3DDevice,
4054                                     Mat);
4055     return hr_ddraw_from_wined3d(hr);
4056 }
4057
4058 /*****************************************************************************
4059  * IDirect3DDevice7::SetLight
4060  *
4061  * Assigns a light to a light index, but doesn't activate it yet.
4062  *
4063  * Version 7, IDirect3DLight uses this method for older versions
4064  *
4065  * Params:
4066  *  LightIndex: The index of the new light
4067  *  Light: A D3DLIGHT7 structure describing the light
4068  *
4069  * Returns:
4070  *  D3D_OK on success
4071  *  For more details, see IWineD3DDevice::SetLight
4072  *
4073  *****************************************************************************/
4074 static HRESULT WINAPI
4075 IDirect3DDeviceImpl_7_SetLight(IDirect3DDevice7 *iface,
4076                                DWORD LightIndex,
4077                                D3DLIGHT7 *Light)
4078 {
4079     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4080     HRESULT hr;
4081     TRACE("(%p)->(%08lx,%p): Relay!\n", This, LightIndex, Light);
4082
4083     hr = IWineD3DDevice_SetLight(This->wineD3DDevice,
4084                                  LightIndex,
4085                                  Light);
4086     return hr_ddraw_from_wined3d(hr);
4087 }
4088
4089 /*****************************************************************************
4090  * IDirect3DDevice7::GetLight
4091  *
4092  * Returns the light assigned to a light index
4093  *
4094  * Params:
4095  *  Light: Structure to write the light information to
4096  *
4097  * Returns:
4098  *  D3D_OK on success
4099  *  DDERR_INVALIDPARAMS if Light is NULL
4100  *  For details, see IWineD3DDevice::GetLight
4101  *
4102  *****************************************************************************/
4103 static HRESULT WINAPI
4104 IDirect3DDeviceImpl_7_GetLight(IDirect3DDevice7 *iface,
4105                                DWORD LightIndex,
4106                                D3DLIGHT7 *Light)
4107 {
4108     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4109     HRESULT rc;
4110     TRACE("(%p)->(%08lx,%p): Relay!\n", This, LightIndex, Light);
4111
4112     rc =  IWineD3DDevice_GetLight(This->wineD3DDevice,
4113                                   LightIndex,
4114                                   Light);
4115
4116     /* Translate the result. WineD3D returns other values than D3D7 */
4117     return hr_ddraw_from_wined3d(rc);
4118 }
4119
4120 /*****************************************************************************
4121  * IDirect3DDevice7::BeginStateBlock
4122  *
4123  * Begins recording to a stateblock
4124  *
4125  * Version 7
4126  *
4127  * Returns:
4128  *  D3D_OK on success
4129  *  For details see IWineD3DDevice::BeginStateBlock
4130  *
4131  *****************************************************************************/
4132 static HRESULT WINAPI
4133 IDirect3DDeviceImpl_7_BeginStateBlock(IDirect3DDevice7 *iface)
4134 {
4135     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4136     HRESULT hr;
4137     TRACE("(%p)->(): Relay!\n", This);
4138
4139     hr = IWineD3DDevice_BeginStateBlock(This->wineD3DDevice);
4140     return hr_ddraw_from_wined3d(hr);
4141 }
4142
4143 /*****************************************************************************
4144  * IDirect3DDevice7::EndStateBlock
4145  *
4146  * Stops recording to a state block and returns the created stateblock
4147  * handle. The d3d7 stateblock handles are the interface pointers of the
4148  * IWineD3DStateBlock interface
4149  *
4150  * Version 7
4151  *
4152  * Params:
4153  *  BlockHandle: Address to store the stateblock's handle to
4154  *
4155  * Returns:
4156  *  D3D_OK on success
4157  *  DDERR_INVALIDPARAMS if BlockHandle is NULL
4158  *  See IWineD3DDevice::EndStateBlock for more details
4159  *
4160  *****************************************************************************/
4161 static HRESULT WINAPI
4162 IDirect3DDeviceImpl_7_EndStateBlock(IDirect3DDevice7 *iface,
4163                                     DWORD *BlockHandle)
4164 {
4165     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4166     HRESULT hr;
4167     TRACE("(%p)->(%p): Relay!\n", This, BlockHandle);
4168
4169     if(!BlockHandle)
4170         return DDERR_INVALIDPARAMS;
4171
4172     hr = IWineD3DDevice_EndStateBlock(This->wineD3DDevice,
4173                                       (IWineD3DStateBlock **) BlockHandle);
4174     return hr_ddraw_from_wined3d(hr);
4175 }
4176
4177 /*****************************************************************************
4178  * IDirect3DDevice7::PreLoad
4179  *
4180  * Allows the app to signal that a texture will be used soon, to allow
4181  * the Direct3DDevice to load it to the video card in the meantime.
4182  *
4183  * Version 7
4184  *
4185  * Params:
4186  *  Texture: The texture to preload
4187  *
4188  * Returns:
4189  *  D3D_OK on success
4190  *  DDERR_INVALIDPARAMS if Texture is NULL
4191  *  See IWineD3DSurface::PreLoad for details
4192  *
4193  *****************************************************************************/
4194 static HRESULT WINAPI
4195 IDirect3DDeviceImpl_7_PreLoad(IDirect3DDevice7 *iface,
4196                               IDirectDrawSurface7 *Texture)
4197 {
4198     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4199     IDirectDrawSurfaceImpl *surf = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, Texture);
4200
4201     TRACE("(%p)->(%p): Relay!\n", This, surf);
4202
4203     if(!Texture)
4204         return DDERR_INVALIDPARAMS;
4205
4206     IWineD3DSurface_PreLoad(surf->WineD3DSurface);
4207     return D3D_OK;
4208 }
4209
4210 /*****************************************************************************
4211  * IDirect3DDevice7::ApplyStateBlock
4212  *
4213  * Activates the state stored in a state block handle.
4214  *
4215  * Params:
4216  *  BlockHandle: The stateblock handle to activate
4217  *
4218  * Returns:
4219  *  D3D_OK on success
4220  *  D3DERR_INVALIDSTATEBLOCK if BlockHandle is NULL
4221  *
4222  *****************************************************************************/
4223 static HRESULT WINAPI
4224 IDirect3DDeviceImpl_7_ApplyStateBlock(IDirect3DDevice7 *iface,
4225                                       DWORD BlockHandle)
4226 {
4227     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4228     HRESULT hr;
4229     TRACE("(%p)->(%08lx): Relay!\n", This, BlockHandle);
4230
4231     if(!BlockHandle)
4232         return D3DERR_INVALIDSTATEBLOCK;
4233
4234     hr = IWineD3DStateBlock_Apply((IWineD3DStateBlock *) BlockHandle);
4235     return hr_ddraw_from_wined3d(hr);
4236 }
4237
4238 /*****************************************************************************
4239  * IDirect3DDevice7::CaptureStateBlock
4240  *
4241  * Updates a stateblock's values to the values currently set for the device
4242  *
4243  * Version 7
4244  *
4245  * Params:
4246  *  BlockHandle: Stateblock to update
4247  *
4248  * Returns:
4249  *  D3D_OK on success
4250  *  D3DERR_INVALIDSTATEBLOCK if BlockHandle is NULL
4251  *  See IWineD3DDevice::CaptureStateBlock for more details
4252  *
4253  *****************************************************************************/
4254 static HRESULT WINAPI
4255 IDirect3DDeviceImpl_7_CaptureStateBlock(IDirect3DDevice7 *iface,
4256                                         DWORD BlockHandle)
4257 {
4258     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4259     HRESULT hr;
4260     TRACE("(%p)->(%08lx): Relay!\n", This, BlockHandle);
4261
4262     if(BlockHandle == 0)
4263         return D3DERR_INVALIDSTATEBLOCK;
4264
4265     hr = IWineD3DStateBlock_Capture((IWineD3DStateBlock *) BlockHandle);
4266     return hr_ddraw_from_wined3d(hr);
4267 }
4268
4269 /*****************************************************************************
4270  * IDirect3DDevice7::DeleteStateBlock
4271  *
4272  * Deletes a stateblock handle. This means releasing the WineD3DStateBlock
4273  *
4274  * Version 7
4275  *
4276  * Params:
4277  *  BlockHandle: Stateblock handle to delete
4278  *
4279  * Returns:
4280  *  D3D_OK on success
4281  *  D3DERR_INVALIDSTATEBLOCK if BlockHandle is 0
4282  *
4283  *****************************************************************************/
4284 static HRESULT WINAPI
4285 IDirect3DDeviceImpl_7_DeleteStateBlock(IDirect3DDevice7 *iface,
4286                                        DWORD BlockHandle)
4287 {
4288     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4289     TRACE("(%p)->(%08lx): Relay!\n", This, BlockHandle);
4290
4291     if(BlockHandle == 0)
4292         return D3DERR_INVALIDSTATEBLOCK;
4293
4294     IWineD3DStateBlock_Release((IWineD3DStateBlock *) BlockHandle);
4295
4296     return D3D_OK;
4297 }
4298
4299 /*****************************************************************************
4300  * IDirect3DDevice7::CreateStateBlock
4301  *
4302  * Creates a new state block handle.
4303  *
4304  * Version 7
4305  *
4306  * Params:
4307  *  Type: The state block type
4308  *  BlockHandle: Address to write the created handle to
4309  *
4310  * Returns:
4311  *   D3D_OK on success
4312  *   DDERR_INVALIDPARAMS if BlockHandle is NULL
4313  *
4314  *****************************************************************************/
4315 static HRESULT WINAPI
4316 IDirect3DDeviceImpl_7_CreateStateBlock(IDirect3DDevice7 *iface,
4317                                        D3DSTATEBLOCKTYPE Type,
4318                                        DWORD *BlockHandle)
4319 {
4320     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4321     HRESULT hr;
4322     TRACE("(%p)->(%08x,%p)!\n", This, Type, BlockHandle);
4323
4324     if(!BlockHandle)
4325         return DDERR_INVALIDPARAMS;
4326
4327     /* The D3DSTATEBLOCKTYPE enum is fine here */
4328     hr = IWineD3DDevice_CreateStateBlock(This->wineD3DDevice,
4329                                          Type,
4330                                          (IWineD3DStateBlock **) BlockHandle,
4331                                          NULL /* Parent, hope that works */);
4332     return hr_ddraw_from_wined3d(hr);
4333 }
4334
4335 /*****************************************************************************
4336  * IDirect3DDevice7::Load
4337  *
4338  * Loads a rectangular area from the source into the destination texture.
4339  * It can also copy the source to the faces of a cubic environment map
4340  *
4341  * Version 7
4342  *
4343  * Params:
4344  *  DestTex: Destination texture
4345  *  DestPoint: Point in the destination where the source image should be
4346  *             written to
4347  *  SrcTex: Source texture
4348  *  SrcRect: Source rectangle
4349  *  Flags: Some flags
4350  *
4351  * Returns:
4352  *  D3D_OK on success
4353  *  DDERR_INVALIDPARAMS if DestTex or SrcTex are NULL
4354  *  See IDirect3DTexture2::Load for details
4355  *
4356  *****************************************************************************/
4357 static HRESULT WINAPI
4358 IDirect3DDeviceImpl_7_Load(IDirect3DDevice7 *iface,
4359                            IDirectDrawSurface7 *DestTex,
4360                            POINT *DestPoint,
4361                            IDirectDrawSurface7 *SrcTex,
4362                            RECT *SrcRect,
4363                            DWORD Flags)
4364 {
4365     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4366     IDirectDrawSurfaceImpl *dest = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, DestTex);
4367     IDirectDrawSurfaceImpl *src = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, SrcTex);
4368     FIXME("(%p)->(%p,%p,%p,%p,%08lx): Partially Implemented!\n", This, dest, DestPoint, src, SrcRect, Flags);
4369
4370     if( (!src) || (!dest) )
4371         return DDERR_INVALIDPARAMS;
4372
4373     IDirect3DTexture2_Load(ICOM_INTERFACE(dest, IDirect3DTexture2),
4374                            ICOM_INTERFACE(src, IDirect3DTexture2));
4375     return D3D_OK;
4376 }
4377
4378 /*****************************************************************************
4379  * IDirect3DDevice7::LightEnable
4380  *
4381  * Enables or disables a light
4382  *
4383  * Version 7, IDirect3DLight uses this method too.
4384  *
4385  * Params:
4386  *  LightIndex: The index of the light to enable / disable
4387  *  Enable: Enable or disable the light
4388  *
4389  * Returns:
4390  *  D3D_OK on success
4391  *  For more details, see IWineD3DDevice::SetLightEnable
4392  *
4393  *****************************************************************************/
4394 static HRESULT WINAPI
4395 IDirect3DDeviceImpl_7_LightEnable(IDirect3DDevice7 *iface,
4396                                   DWORD LightIndex,
4397                                   BOOL Enable)
4398 {
4399     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4400     HRESULT hr;
4401     TRACE("(%p)->(%08lx,%d): Relay!\n", This, LightIndex, Enable);
4402
4403     hr = IWineD3DDevice_SetLightEnable(This->wineD3DDevice, LightIndex, Enable);
4404     return hr_ddraw_from_wined3d(hr);
4405 }
4406
4407 /*****************************************************************************
4408  * IDirect3DDevice7::GetLightEnable
4409  *
4410  * Retrieves if the light with the given index is enabled or not
4411  *
4412  * Version 7
4413  *
4414  * Params:
4415  *  LightIndex: Index of desired light
4416  *  Enable: Pointer to a BOOL which contains the result
4417  *
4418  * Returns:
4419  *  D3D_OK on success
4420  *  DDERR_INVALIDPARAMS if Enable is NULL
4421  *  See IWineD3DDevice::GetLightEnable for more details
4422  *
4423  *****************************************************************************/
4424 static HRESULT WINAPI
4425 IDirect3DDeviceImpl_7_GetLightEnable(IDirect3DDevice7 *iface,
4426                                      DWORD LightIndex,
4427                                      BOOL* Enable)
4428 {
4429     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4430     HRESULT hr;
4431     TRACE("(%p)->(%08lx,%p): Relay\n", This, LightIndex, Enable);
4432
4433     if(!Enable)
4434         return DDERR_INVALIDPARAMS;
4435
4436     hr = IWineD3DDevice_GetLightEnable(This->wineD3DDevice, LightIndex, Enable);
4437     return hr_ddraw_from_wined3d(hr);
4438 }
4439
4440 /*****************************************************************************
4441  * IDirect3DDevice7::SetClipPlane
4442  *
4443  * Sets custom clipping plane
4444  *
4445  * Version 7
4446  *
4447  * Params:
4448  *  Index: The index of the clipping plane
4449  *  PlaneEquation: An equation defining the clipping plane
4450  *
4451  * Returns:
4452  *  D3D_OK on success
4453  *  DDERR_INVALIDPARAMS if PlaneEquation is NULL
4454  *  See IWineD3DDevice::SetClipPlane for more details
4455  *
4456  *****************************************************************************/
4457 static HRESULT WINAPI
4458 IDirect3DDeviceImpl_7_SetClipPlane(IDirect3DDevice7 *iface,
4459                                    DWORD Index,
4460                                    D3DVALUE* PlaneEquation)
4461 {
4462     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4463     TRACE("(%p)->(%08lx,%p): Relay!\n", This, Index, PlaneEquation);
4464
4465     if(!PlaneEquation)
4466         return DDERR_INVALIDPARAMS;
4467
4468     return IWineD3DDevice_SetClipPlane(This->wineD3DDevice, Index, PlaneEquation);
4469 }
4470
4471 /*****************************************************************************
4472  * IDirect3DDevice7::GetClipPlane
4473  *
4474  * Returns the clipping plane with a specific index
4475  *
4476  * Params:
4477  *  Index: The index of the desired plane
4478  *  PlaneEquation: Address to store the plane equation to
4479  *
4480  * Returns:
4481  *  D3D_OK on success
4482  *  DDERR_INVALIDPARAMS if PlaneEquation is NULL
4483  *  See IWineD3DDevice::GetClipPlane for more details
4484  *
4485  *****************************************************************************/
4486 static HRESULT WINAPI
4487 IDirect3DDeviceImpl_7_GetClipPlane(IDirect3DDevice7 *iface,
4488                                    DWORD Index,
4489                                    D3DVALUE* PlaneEquation)
4490 {
4491     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4492     TRACE("(%p)->(%ld,%p): Relay!\n", This, Index, PlaneEquation);
4493
4494     if(!PlaneEquation)
4495         return DDERR_INVALIDPARAMS;
4496
4497     return IWineD3DDevice_GetClipPlane(This->wineD3DDevice, Index, PlaneEquation);
4498 }
4499
4500 /*****************************************************************************
4501  * IDirect3DDevice7::GetInfo
4502  *
4503  * Retrieves some information about the device. The DirectX sdk says that
4504  * this version returns S_FALSE for all retail builds of DirectX, that's what
4505  * this implementation does.
4506  *
4507  * Params:
4508  *  DevInfoID: Information type requested
4509  *  DevInfoStruct: Pointer to a structure to store the info to
4510  *  Size: Size of the structure
4511  *
4512  * Returns:
4513  *  S_FALSE, because it's a non-debug driver
4514  *
4515  *****************************************************************************/
4516 static HRESULT WINAPI
4517 IDirect3DDeviceImpl_7_GetInfo(IDirect3DDevice7 *iface,
4518                               DWORD DevInfoID,
4519                               void *DevInfoStruct,
4520                               DWORD Size)
4521 {
4522     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
4523     TRACE("(%p)->(%08lx,%p,%08lx)\n", This, DevInfoID, DevInfoStruct, Size);
4524
4525     if (TRACE_ON(d3d7))
4526     {
4527         TRACE(" info requested : ");
4528         switch (DevInfoID)
4529         {
4530             case D3DDEVINFOID_TEXTUREMANAGER: TRACE("D3DDEVINFOID_TEXTUREMANAGER\n"); break;
4531             case D3DDEVINFOID_D3DTEXTUREMANAGER: TRACE("D3DDEVINFOID_D3DTEXTUREMANAGER\n"); break;
4532             case D3DDEVINFOID_TEXTURING: TRACE("D3DDEVINFOID_TEXTURING\n"); break;
4533             default: ERR(" invalid flag !!!\n"); return DDERR_INVALIDPARAMS;
4534         }
4535     }
4536
4537     return S_FALSE; /* According to MSDN, this is valid for a non-debug driver */
4538 }
4539
4540 const IDirect3DDevice7Vtbl IDirect3DDevice7_Vtbl =
4541 {
4542     /*** IUnknown Methods ***/
4543     IDirect3DDeviceImpl_7_QueryInterface,
4544     IDirect3DDeviceImpl_7_AddRef,
4545     IDirect3DDeviceImpl_7_Release,
4546     /*** IDirect3DDevice7 ***/
4547     IDirect3DDeviceImpl_7_GetCaps,
4548     IDirect3DDeviceImpl_7_EnumTextureFormats,
4549     IDirect3DDeviceImpl_7_BeginScene,
4550     IDirect3DDeviceImpl_7_EndScene,
4551     IDirect3DDeviceImpl_7_GetDirect3D,
4552     IDirect3DDeviceImpl_7_SetRenderTarget,
4553     IDirect3DDeviceImpl_7_GetRenderTarget,
4554     IDirect3DDeviceImpl_7_Clear,
4555     IDirect3DDeviceImpl_7_SetTransform,
4556     IDirect3DDeviceImpl_7_GetTransform,
4557     IDirect3DDeviceImpl_7_SetViewport,
4558     IDirect3DDeviceImpl_7_MultiplyTransform,
4559     IDirect3DDeviceImpl_7_GetViewport,
4560     IDirect3DDeviceImpl_7_SetMaterial,
4561     IDirect3DDeviceImpl_7_GetMaterial,
4562     IDirect3DDeviceImpl_7_SetLight,
4563     IDirect3DDeviceImpl_7_GetLight,
4564     IDirect3DDeviceImpl_7_SetRenderState,
4565     IDirect3DDeviceImpl_7_GetRenderState,
4566     IDirect3DDeviceImpl_7_BeginStateBlock,
4567     IDirect3DDeviceImpl_7_EndStateBlock,
4568     IDirect3DDeviceImpl_7_PreLoad,
4569     IDirect3DDeviceImpl_7_DrawPrimitive,
4570     IDirect3DDeviceImpl_7_DrawIndexedPrimitive,
4571     IDirect3DDeviceImpl_7_SetClipStatus,
4572     IDirect3DDeviceImpl_7_GetClipStatus,
4573     IDirect3DDeviceImpl_7_DrawPrimitiveStrided,
4574     IDirect3DDeviceImpl_7_DrawIndexedPrimitiveStrided,
4575     IDirect3DDeviceImpl_7_DrawPrimitiveVB,
4576     IDirect3DDeviceImpl_7_DrawIndexedPrimitiveVB,
4577     IDirect3DDeviceImpl_7_ComputeSphereVisibility,
4578     IDirect3DDeviceImpl_7_GetTexture,
4579     IDirect3DDeviceImpl_7_SetTexture,
4580     IDirect3DDeviceImpl_7_GetTextureStageState,
4581     IDirect3DDeviceImpl_7_SetTextureStageState,
4582     IDirect3DDeviceImpl_7_ValidateDevice,
4583     IDirect3DDeviceImpl_7_ApplyStateBlock,
4584     IDirect3DDeviceImpl_7_CaptureStateBlock,
4585     IDirect3DDeviceImpl_7_DeleteStateBlock,
4586     IDirect3DDeviceImpl_7_CreateStateBlock,
4587     IDirect3DDeviceImpl_7_Load,
4588     IDirect3DDeviceImpl_7_LightEnable,
4589     IDirect3DDeviceImpl_7_GetLightEnable,
4590     IDirect3DDeviceImpl_7_SetClipPlane,
4591     IDirect3DDeviceImpl_7_GetClipPlane,
4592     IDirect3DDeviceImpl_7_GetInfo
4593 };
4594
4595 const IDirect3DDevice3Vtbl IDirect3DDevice3_Vtbl =
4596 {
4597     /*** IUnknown Methods ***/
4598     Thunk_IDirect3DDeviceImpl_3_QueryInterface,
4599     Thunk_IDirect3DDeviceImpl_3_AddRef,
4600     Thunk_IDirect3DDeviceImpl_3_Release,
4601     /*** IDirect3DDevice3 ***/
4602     IDirect3DDeviceImpl_3_GetCaps,
4603     IDirect3DDeviceImpl_3_GetStats,
4604     IDirect3DDeviceImpl_3_AddViewport,
4605     IDirect3DDeviceImpl_3_DeleteViewport,
4606     IDirect3DDeviceImpl_3_NextViewport,
4607     Thunk_IDirect3DDeviceImpl_3_EnumTextureFormats,
4608     Thunk_IDirect3DDeviceImpl_3_BeginScene,
4609     Thunk_IDirect3DDeviceImpl_3_EndScene,
4610     Thunk_IDirect3DDeviceImpl_3_GetDirect3D,
4611     IDirect3DDeviceImpl_3_SetCurrentViewport,
4612     IDirect3DDeviceImpl_3_GetCurrentViewport,
4613     Thunk_IDirect3DDeviceImpl_3_SetRenderTarget,
4614     Thunk_IDirect3DDeviceImpl_3_GetRenderTarget,
4615     IDirect3DDeviceImpl_3_Begin,
4616     IDirect3DDeviceImpl_3_BeginIndexed,
4617     IDirect3DDeviceImpl_3_Vertex,
4618     IDirect3DDeviceImpl_3_Index,
4619     IDirect3DDeviceImpl_3_End,
4620     Thunk_IDirect3DDeviceImpl_3_GetRenderState,
4621     Thunk_IDirect3DDeviceImpl_3_SetRenderState,
4622     IDirect3DDeviceImpl_3_GetLightState,
4623     IDirect3DDeviceImpl_3_SetLightState,
4624     Thunk_IDirect3DDeviceImpl_3_SetTransform,
4625     Thunk_IDirect3DDeviceImpl_3_GetTransform,
4626     Thunk_IDirect3DDeviceImpl_3_MultiplyTransform,
4627     Thunk_IDirect3DDeviceImpl_3_DrawPrimitive,
4628     Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitive,
4629     Thunk_IDirect3DDeviceImpl_3_SetClipStatus,
4630     Thunk_IDirect3DDeviceImpl_3_GetClipStatus,
4631     Thunk_IDirect3DDeviceImpl_3_DrawPrimitiveStrided,
4632     Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitiveStrided,
4633     Thunk_IDirect3DDeviceImpl_3_DrawPrimitiveVB,
4634     Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitiveVB,
4635     Thunk_IDirect3DDeviceImpl_3_ComputeSphereVisibility,
4636     Thunk_IDirect3DDeviceImpl_3_GetTexture,
4637     Thunk_IDirect3DDeviceImpl_3_SetTexture,
4638     Thunk_IDirect3DDeviceImpl_3_GetTextureStageState,
4639     Thunk_IDirect3DDeviceImpl_3_SetTextureStageState,
4640     Thunk_IDirect3DDeviceImpl_3_ValidateDevice
4641 };
4642
4643 const IDirect3DDevice2Vtbl IDirect3DDevice2_Vtbl =
4644 {
4645     /*** IUnknown Methods ***/
4646     Thunk_IDirect3DDeviceImpl_2_QueryInterface,
4647     Thunk_IDirect3DDeviceImpl_2_AddRef,
4648     Thunk_IDirect3DDeviceImpl_2_Release,
4649     /*** IDirect3DDevice2 ***/
4650     Thunk_IDirect3DDeviceImpl_2_GetCaps,
4651     IDirect3DDeviceImpl_2_SwapTextureHandles,
4652     Thunk_IDirect3DDeviceImpl_2_GetStats,
4653     Thunk_IDirect3DDeviceImpl_2_AddViewport,
4654     Thunk_IDirect3DDeviceImpl_2_DeleteViewport,
4655     Thunk_IDirect3DDeviceImpl_2_NextViewport,
4656     IDirect3DDeviceImpl_2_EnumTextureFormats,
4657     Thunk_IDirect3DDeviceImpl_2_BeginScene,
4658     Thunk_IDirect3DDeviceImpl_2_EndScene,
4659     Thunk_IDirect3DDeviceImpl_2_GetDirect3D,
4660     Thunk_IDirect3DDeviceImpl_2_SetCurrentViewport,
4661     Thunk_IDirect3DDeviceImpl_2_GetCurrentViewport,
4662     Thunk_IDirect3DDeviceImpl_2_SetRenderTarget,
4663     Thunk_IDirect3DDeviceImpl_2_GetRenderTarget,
4664     Thunk_IDirect3DDeviceImpl_2_Begin,
4665     Thunk_IDirect3DDeviceImpl_2_BeginIndexed,
4666     Thunk_IDirect3DDeviceImpl_2_Vertex,
4667     Thunk_IDirect3DDeviceImpl_2_Index,
4668     Thunk_IDirect3DDeviceImpl_2_End,
4669     Thunk_IDirect3DDeviceImpl_2_GetRenderState,
4670     Thunk_IDirect3DDeviceImpl_2_SetRenderState,
4671     Thunk_IDirect3DDeviceImpl_2_GetLightState,
4672     Thunk_IDirect3DDeviceImpl_2_SetLightState,
4673     Thunk_IDirect3DDeviceImpl_2_SetTransform,
4674     Thunk_IDirect3DDeviceImpl_2_GetTransform,
4675     Thunk_IDirect3DDeviceImpl_2_MultiplyTransform,
4676     Thunk_IDirect3DDeviceImpl_2_DrawPrimitive,
4677     Thunk_IDirect3DDeviceImpl_2_DrawIndexedPrimitive,
4678     Thunk_IDirect3DDeviceImpl_2_SetClipStatus,
4679     Thunk_IDirect3DDeviceImpl_2_GetClipStatus
4680 };
4681
4682 const IDirect3DDeviceVtbl IDirect3DDevice1_Vtbl =
4683 {
4684     /*** IUnknown Methods ***/
4685     Thunk_IDirect3DDeviceImpl_1_QueryInterface,
4686     Thunk_IDirect3DDeviceImpl_1_AddRef,
4687     Thunk_IDirect3DDeviceImpl_1_Release,
4688     /*** IDirect3DDevice1 ***/
4689     IDirect3DDeviceImpl_1_Initialize,
4690     Thunk_IDirect3DDeviceImpl_1_GetCaps,
4691     Thunk_IDirect3DDeviceImpl_1_SwapTextureHandles,
4692     IDirect3DDeviceImpl_1_CreateExecuteBuffer,
4693     Thunk_IDirect3DDeviceImpl_1_GetStats,
4694     IDirect3DDeviceImpl_1_Execute,
4695     Thunk_IDirect3DDeviceImpl_1_AddViewport,
4696     Thunk_IDirect3DDeviceImpl_1_DeleteViewport,
4697     Thunk_IDirect3DDeviceImpl_1_NextViewport,
4698     IDirect3DDeviceImpl_1_Pick,
4699     IDirect3DDeviceImpl_1_GetPickRecords,
4700     Thunk_IDirect3DDeviceImpl_1_EnumTextureFormats,
4701     IDirect3DDeviceImpl_1_CreateMatrix,
4702     IDirect3DDeviceImpl_1_SetMatrix,
4703     IDirect3DDeviceImpl_1_GetMatrix,
4704     IDirect3DDeviceImpl_1_DeleteMatrix,
4705     Thunk_IDirect3DDeviceImpl_1_EndScene,
4706     Thunk_IDirect3DDeviceImpl_1_BeginScene,
4707     Thunk_IDirect3DDeviceImpl_1_GetDirect3D
4708 };
4709
4710 /*****************************************************************************
4711  * IDirect3DDeviceImpl_CreateHandle
4712  *
4713  * Not called from the VTable
4714  *
4715  * Some older interface versions operate with handles, which are basically
4716  * DWORDs which identify an interface, for example
4717  * IDirect3DDevice::SetRenderState with DIRECT3DRENDERSTATE_TEXTUREHANDLE
4718  *
4719  * Those handle could be just casts to the interface pointers or vice versa,
4720  * but that is not 64 bit safe and would mean blindly derefering a DWORD
4721  * passed by the app. Instead there is a dynamic array in the device which
4722  * keeps a DWORD to pointer information and a type for the handle.
4723  *
4724  * Basically this array only grows, when a handle is freed its pointer is
4725  * just set to NULL. There will be much more reads from the array than
4726  * insertion operations, so a dynamic array is fine.
4727  *
4728  * Params:
4729  *  This: D3DDevice implementation for which this handle should be created
4730  *
4731  * Returns:
4732  *  A free handle on success
4733  *  0 on failure
4734  *
4735  *****************************************************************************/
4736 DWORD
4737 IDirect3DDeviceImpl_CreateHandle(IDirect3DDeviceImpl *This)
4738 {
4739     DWORD i;
4740     struct HandleEntry *oldHandles = This->Handles;
4741
4742     TRACE("(%p)\n", This);
4743
4744     for(i = 0; i < This->numHandles; i++)
4745     {
4746         if(This->Handles[i].ptr == NULL &&
4747            This->Handles[i].type == DDrawHandle_Unknown)
4748         {
4749             TRACE("Reusing freed handle %ld\n", i + 1);
4750             return i + 1;
4751         }
4752     }
4753
4754     TRACE("Growing the handle array\n");
4755
4756     This->numHandles++;
4757     This->Handles = HeapAlloc(GetProcessHeap(), 0, sizeof(struct HandleEntry) * This->numHandles);
4758     if(!This->Handles)
4759     {
4760         ERR("Out of memory\n");
4761         This->Handles = oldHandles;
4762         This->numHandles--;
4763         return 0;
4764     }
4765     if(oldHandles)
4766     {
4767         memcpy(This->Handles, oldHandles, (This->numHandles - 1) * sizeof(struct HandleEntry));
4768         HeapFree(GetProcessHeap(), 0, oldHandles);
4769     }
4770
4771     TRACE("Returning %ld\n", This->numHandles);
4772     return This->numHandles;
4773 }