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

   1 /* Direct3D Device
   2  * Copyright (c) 1998 Lionel ULMER
   3  *
   4  * This file contains all the common stuff for D3D devices.
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24 #include <string.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winerror.h"
  29 #include "objbase.h"
  30 #include "wingdi.h"
  31 #include "ddraw.h"
  32 #include "d3d.h"
  33 #include "wine/debug.h"
  34
  35 #include "d3d_private.h"
  36 #include "main.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  39
  40 DWORD InitRenderStateTab[] = {
  41     D3DRENDERSTATE_TEXTUREHANDLE,           (DWORD)NULL,
  42     D3DRENDERSTATE_ANTIALIAS,               D3DANTIALIAS_NONE,
  43     /* FIXME: D3DRENDERSTATE_TEXTUREADDRESS */
  44     D3DRENDERSTATE_TEXTUREPERSPECTIVE,      TRUE,
  45     /* FIXME: D3DRENDERSTATE_WRAPU */
  46     /* FIXME: D3DRENDERSTATE_WRAPV */
  47     D3DRENDERSTATE_ZENABLE,                 D3DZB_TRUE, /* This needs to be set differently according to the Z buffer status */
  48     D3DRENDERSTATE_FILLMODE,                D3DFILL_SOLID,
  49     D3DRENDERSTATE_SHADEMODE,               D3DSHADE_GOURAUD,
  50     D3DRENDERSTATE_LINEPATTERN,             0,
  51     D3DRENDERSTATE_MONOENABLE,              FALSE,
  52     D3DRENDERSTATE_ROP2,                    R2_COPYPEN,
  53     D3DRENDERSTATE_PLANEMASK,               0xFFFFFFFF,
  54     D3DRENDERSTATE_ZWRITEENABLE,            TRUE,
  55     D3DRENDERSTATE_ALPHATESTENABLE,         FALSE,
  56     D3DRENDERSTATE_LASTPIXEL,               TRUE,
  57     D3DRENDERSTATE_TEXTUREMAG,              D3DFILTER_NEAREST,
  58     D3DRENDERSTATE_TEXTUREMIN,              D3DFILTER_NEAREST,
  59     D3DRENDERSTATE_SRCBLEND,                D3DBLEND_ONE,
  60     D3DRENDERSTATE_DESTBLEND,               D3DBLEND_ZERO,
  61     D3DRENDERSTATE_TEXTUREMAPBLEND,         D3DTBLEND_MODULATE,
  62     D3DRENDERSTATE_CULLMODE,                D3DCULL_CCW,
  63     D3DRENDERSTATE_ZFUNC,                   D3DCMP_LESSEQUAL,
  64     D3DRENDERSTATE_ALPHAREF,                0,
  65     D3DRENDERSTATE_ALPHAFUNC,               D3DCMP_ALWAYS,
  66     D3DRENDERSTATE_DITHERENABLE,            FALSE,
  67     D3DRENDERSTATE_ALPHABLENDENABLE,        FALSE,
  68     D3DRENDERSTATE_FOGENABLE,               FALSE,
  69     D3DRENDERSTATE_SPECULARENABLE,          FALSE,
  70     D3DRENDERSTATE_ZVISIBLE,                FALSE,
  71     D3DRENDERSTATE_SUBPIXEL,                FALSE,
  72     D3DRENDERSTATE_SUBPIXELX,               FALSE,
  73     D3DRENDERSTATE_STIPPLEDALPHA,           FALSE,
  74     D3DRENDERSTATE_FOGCOLOR,                D3DRGBA(0,0,0,0),
  75     D3DRENDERSTATE_FOGTABLEMODE,            D3DFOG_NONE,
  76     /* FIXME: D3DRENDERSTATE_FOGTABLESTART (same as D3DRENDERSTATE_FOGSTART) */
  77     /* FIXME: D3DRENDERSTATE_FOGTABLEEND (same as D3DRENDERSTATE_FOGEND) */
  78     D3DRENDERSTATE_FOGTABLEDENSITY,         0x3F80000, /* 1.0f (same as D3DRENDERSTATE_FOGDENSITY) */
  79     /* FIXME: D3DRENDERSTATE_STIPPLEENABLE */
  80     D3DRENDERSTATE_EDGEANTIALIAS,           FALSE,
  81     D3DRENDERSTATE_COLORKEYENABLE,          FALSE,
  82     /* FIXME: D3DRENDERSTATE_BORDERCOLOR */
  83     D3DRENDERSTATE_TEXTUREADDRESSU,         D3DTADDRESS_WRAP,
  84     D3DRENDERSTATE_TEXTUREADDRESSV,         D3DTADDRESS_WRAP,
  85     D3DRENDERSTATE_MIPMAPLODBIAS,           0x00000000, /* 0.0f */
  86     D3DRENDERSTATE_ZBIAS,                   0,
  87     D3DRENDERSTATE_RANGEFOGENABLE,          FALSE,
  88     /* FIXME: D3DRENDERSTATE_ANISOTROPY */
  89     /* FIXME: D3DRENDERSTATE_FLUSHBATCH */
  90     /* FIXME: D3DRENDERSTATE_TRANSLUCENTSORTINDEPENDENT */
  91     D3DRENDERSTATE_STENCILENABLE,           FALSE,
  92     D3DRENDERSTATE_STENCILFAIL,             D3DSTENCILOP_KEEP,
  93     D3DRENDERSTATE_STENCILZFAIL,            D3DSTENCILOP_KEEP,
  94     D3DRENDERSTATE_STENCILPASS,             D3DSTENCILOP_KEEP,
  95     D3DRENDERSTATE_STENCILFUNC,             D3DCMP_ALWAYS,
  96     D3DRENDERSTATE_STENCILREF,              0,
  97     D3DRENDERSTATE_STENCILMASK,             0xFFFFFFFF,
  98     D3DRENDERSTATE_STENCILWRITEMASK,        0xFFFFFFFF,
  99     /* FIXME: D3DRENDERSTATE_TEXTUREFACTOR */
 100     /* FIXME: D3DRENDERSTATE_STIPPLEPATTERN00..31 */
 101     D3DRENDERSTATE_WRAP0,                   0,
 102     D3DRENDERSTATE_WRAP1,                   0,
 103     D3DRENDERSTATE_WRAP2,                   0,
 104     D3DRENDERSTATE_WRAP3,                   0,
 105     D3DRENDERSTATE_WRAP4,                   0,
 106     D3DRENDERSTATE_WRAP5,                   0,
 107     D3DRENDERSTATE_WRAP6,                   0,
 108     D3DRENDERSTATE_WRAP7,                   0,
 109     D3DRENDERSTATE_CLIPPING,                FALSE,
 110     D3DRENDERSTATE_LIGHTING,                TRUE,
 111     D3DRENDERSTATE_EXTENTS,                 FALSE,
 112     D3DRENDERSTATE_AMBIENT,                 D3DRGBA(0,0,0,0),
 113     D3DRENDERSTATE_FOGVERTEXMODE,           D3DFOG_NONE,
 114     D3DRENDERSTATE_COLORVERTEX,             TRUE,
 115     D3DRENDERSTATE_LOCALVIEWER,             TRUE,
 116     D3DRENDERSTATE_NORMALIZENORMALS,        FALSE,
 117     /* FIXME: D3DRENDER_STATE_COLORKEYBLENDENABLE */
 118     D3DRENDERSTATE_DIFFUSEMATERIALSOURCE,   D3DMCS_COLOR1,
 119     D3DRENDERSTATE_SPECULARMATERIALSOURCE,  D3DMCS_COLOR2,
 120     D3DRENDERSTATE_AMBIENTMATERIALSOURCE,   D3DMCS_COLOR2,
 121     D3DRENDERSTATE_EMISSIVEMATERIALSOURCE,  D3DMCS_MATERIAL,
 122     D3DRENDERSTATE_VERTEXBLEND,             D3DVBLEND_DISABLE,
 123     D3DRENDERSTATE_CLIPPLANEENABLE,         0
 124 };
 125
 126 DWORD InitLightStateTab[] = {
 127     D3DLIGHTSTATE_MATERIAL,           (DWORD)NULL,
 128     D3DLIGHTSTATE_AMBIENT,            D3DRGBA(0,0,0,0),
 129     D3DLIGHTSTATE_COLORMODEL,         D3DCOLOR_RGB,
 130     D3DLIGHTSTATE_FOGMODE,            D3DFOG_NONE,
 131     D3DLIGHTSTATE_FOGSTART,           0x3F80000, /* 1.0f */
 132     D3DLIGHTSTATE_FOGEND,             0x42C8000, /* 100.0f */
 133     D3DLIGHTSTATE_FOGDENSITY,         0x3F80000  /* 1.0f */
 134     /* FIXME: D3DLIGHTSTATE_COLORVERTEX */
 135 };
 136
 137 DWORD InitTextureStageStateTab[] = {
 138     D3DTSS_COLOROP,          D3DTOP_DISABLE, /* Note, it's manually set for stage 0 */
 139     D3DTSS_COLORARG1,        D3DTA_TEXTURE,
 140     D3DTSS_COLORARG2,        D3DTA_CURRENT,
 141     D3DTSS_ALPHAOP,          D3DTOP_DISABLE, /* Note, it's manually set for stage 0 */
 142     D3DTSS_ALPHAARG1,        D3DTA_TEXTURE,
 143     D3DTSS_ALPHAARG2,        D3DTA_CURRENT,
 144     /* FIXME: D3DTSS_BUMPENVMAT00,01,10,11 */
 145     /* D3DTSS_TEXCOORDINDEX is set manually */
 146     D3DTSS_ADDRESS,          D3DTADDRESS_WRAP,
 147     D3DTSS_ADDRESSU,         D3DTADDRESS_WRAP,
 148     D3DTSS_ADDRESSV,         D3DTADDRESS_WRAP,
 149     D3DTSS_BORDERCOLOR,      0x00000000,
 150     D3DTSS_MAGFILTER,        D3DTFG_POINT,
 151     D3DTSS_MINFILTER,        D3DTFN_POINT,
 152     D3DTSS_MIPFILTER,        D3DTFP_NONE,
 153     D3DTSS_MIPMAPLODBIAS,    0x00000000, /* 0.0f */
 154     D3DTSS_MAXMIPLEVEL,      0,
 155     /* D3DTSS_MAXANISOTROPY,    1, */ /* This is to prevent warnings :-) */
 156     /* FIXME: D3DTSS_BUMPENVLSCALE */
 157     /* FIXME: D3DTSS_NUMPENVLOFFSET */
 158     /* FIXME: D3DTSS_TEXTURETRANSFORMFLAGS */
 159 };
 160
 161
 162 void InitDefaultStateBlock(STATEBLOCK* lpStateBlock, int version)
 163 {
 164     int i, j;
 165     TRACE("(%p,%d)\n", lpStateBlock, version);
 166     memset(lpStateBlock, 0, sizeof(STATEBLOCK));
 167
 168     /* Initialize render states */
 169     for (i = 0; i < sizeof(InitRenderStateTab) / sizeof(InitRenderStateTab[0]); i += 2)
 170     {
 171         lpStateBlock->render_state[InitRenderStateTab[i] - 1] = InitRenderStateTab[i + 1];
 172         lpStateBlock->set_flags.render_state[InitRenderStateTab[i] - 1] = TRUE;
 173     }
 174
 175     /* Initialize texture stages states */
 176     for (i = 0; i < MAX_TEXTURES; i++)
 177     {
 178        for (j = 0; j < sizeof(InitTextureStageStateTab) / sizeof(InitTextureStageStateTab[0]); j += 2)
 179        {
 180            lpStateBlock->texture_stage_state[i][InitTextureStageStateTab[j] - 1] = InitTextureStageStateTab[j + 1];
 181            lpStateBlock->set_flags.texture_stage_state[i][InitTextureStageStateTab[j] - 1] = TRUE;
 182        }
 183        /* Map texture coords 0 to stage 0, 1 to stage 1, etc... */
 184        lpStateBlock->texture_stage_state[i][D3DTSS_TEXCOORDINDEX - 1] = i;
 185        lpStateBlock->set_flags.texture_stage_state[i][D3DTSS_TEXCOORDINDEX - 1] = TRUE;
 186     }
 187
 188     /* The first texture is particular, update it consequently */
 189     lpStateBlock->texture_stage_state[0][D3DTSS_COLOROP - 1] = D3DTOP_MODULATE;
 190     lpStateBlock->texture_stage_state[0][D3DTSS_ALPHAOP - 1] = D3DTOP_SELECTARG1;
 191     lpStateBlock->texture_stage_state[0][D3DTSS_COLORARG2 - 1] = D3DTA_DIFFUSE;
 192     lpStateBlock->texture_stage_state[0][D3DTSS_ALPHAARG2 - 1] = D3DTA_DIFFUSE;
 193
 194     /* Updates for particular versions */
 195     if ((version == 1) || (version==2))
 196        lpStateBlock->render_state[D3DRENDERSTATE_SPECULARENABLE - 1] = TRUE;
 197 }
 198
 199 HRESULT WINAPI
 200 Main_IDirect3DDeviceImpl_7_3T_2T_1T_QueryInterface(LPDIRECT3DDEVICE7 iface,
 201                                                    REFIID riid,
 202                                                    LPVOID* obp)
 203 {
 204     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 205     TRACE("(%p/%p)->(%s,%p)\n", This, iface, debugstr_guid(riid), obp);
 206
 207     *obp = NULL;
 208
 209     if ( IsEqualGUID( &IID_IUnknown,  riid ) ) {
 210         IDirect3DDevice7_AddRef(ICOM_INTERFACE(This, IDirect3DDevice7));
 211         *obp = iface;
 212         TRACE("  Creating IUnknown interface at %p.\n", *obp);
 213         return S_OK;
 214     }
 215     if ( IsEqualGUID( &IID_IDirect3DDevice, riid ) ) {
 216         IDirect3DDevice7_AddRef(ICOM_INTERFACE(This, IDirect3DDevice7));
 217         *obp = ICOM_INTERFACE(This, IDirect3DDevice);
 218         TRACE("  Creating IDirect3DDevice interface %p\n", *obp);
 219         return S_OK;
 220     }
 221     if ( IsEqualGUID( &IID_IDirect3DDevice2, riid ) ) {
 222         IDirect3DDevice7_AddRef(ICOM_INTERFACE(This, IDirect3DDevice7));
 223         *obp = ICOM_INTERFACE(This, IDirect3DDevice2);
 224         TRACE("  Creating IDirect3DDevice2 interface %p\n", *obp);
 225         return S_OK;
 226     }
 227     if ( IsEqualGUID( &IID_IDirect3DDevice3, riid ) ) {
 228         IDirect3DDevice7_AddRef(ICOM_INTERFACE(This, IDirect3DDevice7));
 229         *obp = ICOM_INTERFACE(This, IDirect3DDevice3);
 230         TRACE("  Creating IDirect3DDevice3 interface %p\n", *obp);
 231         return S_OK;
 232     }
 233     if ( IsEqualGUID( &IID_IDirect3DDevice7, riid ) ) {
 234         IDirect3DDevice7_AddRef(ICOM_INTERFACE(This, IDirect3DDevice7));
 235         *obp = ICOM_INTERFACE(This, IDirect3DDevice7);
 236         TRACE("  Creating IDirect3DDevice7 interface %p\n", *obp);
 237         return S_OK;
 238     }
 239     if ( IsEqualGUID( &IID_IDirectDrawSurface, riid ) ||
 240          IsEqualGUID( &IID_IDirectDrawSurface2, riid ) ||
 241          IsEqualGUID( &IID_IDirectDrawSurface3, riid ) ) {
 242         IDirectDrawSurface7_AddRef(ICOM_INTERFACE(This->surface, IDirectDrawSurface7));
 243         *obp = ICOM_INTERFACE(This->surface, IDirectDrawSurface3);
 244         TRACE("  Return IDirectDrawSurface3 interface %p\n", *obp);
 245         return S_OK;
 246     }
 247     if ( IsEqualGUID( &IID_IDirectDrawSurface4, riid ) ||
 248          IsEqualGUID( &IID_IDirectDrawSurface7, riid ) ) {
 249         IDirectDrawSurface7_AddRef(ICOM_INTERFACE(This->surface, IDirectDrawSurface7));
 250         *obp = ICOM_INTERFACE(This->surface, IDirectDrawSurface7);
 251         TRACE("  Return IDirectDrawSurface7 interface %p\n", *obp);
 252         return S_OK;
 253     }
 254     FIXME("(%p): interface for IID %s NOT found!\n", This, debugstr_guid(riid));
 255     return OLE_E_ENUM_NOMORE;
 256 }
 257
 258 ULONG WINAPI
 259 Main_IDirect3DDeviceImpl_7_3T_2T_1T_AddRef(LPDIRECT3DDEVICE7 iface)
 260 {
 261     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 262     TRACE("(%p/%p)->() incrementing from %lu.\n", This, iface, This->ref);
 263     return ++(This->ref);
 264 }
 265
 266 ULONG WINAPI
 267 Main_IDirect3DDeviceImpl_7_3T_2T_1T_Release(LPDIRECT3DDEVICE7 iface)
 268 {
 269     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 270     TRACE("(%p/%p)->() decrementing from %lu.\n", This, iface, This->ref);
 271     if (!--(This->ref)) {
 272         int i;
 273         /* Release texture associated with the device */
 274         for (i = 0; i < MAX_TEXTURES; i++) {
 275             if (This->current_texture[i] != NULL)
 276                 IDirect3DTexture2_Release(ICOM_INTERFACE(This->current_texture[i], IDirect3DTexture2));
 277         }
 278
 279         HeapFree(GetProcessHeap(), 0, This);
 280         return 0;
 281     }
 282     return This->ref;
 283 }
 284
 285 HRESULT WINAPI
 286 Main_IDirect3DDeviceImpl_7_GetCaps(LPDIRECT3DDEVICE7 iface,
 287                                    LPD3DDEVICEDESC7 lpD3DHELDevDesc)
 288 {
 289     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 290     FIXME("(%p/%p)->(%p): stub!\n", This, iface, lpD3DHELDevDesc);
 291     return DD_OK;
 292 }
 293
 294 HRESULT WINAPI
 295 Main_IDirect3DDeviceImpl_7_3T_EnumTextureFormats(LPDIRECT3DDEVICE7 iface,
 296                                                  LPD3DENUMPIXELFORMATSCALLBACK lpD3DEnumPixelProc,
 297                                                  LPVOID lpArg)
 298 {
 299     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 300     FIXME("(%p/%p)->(%p,%p): stub!\n", This, iface, lpD3DEnumPixelProc, lpArg);
 301     return DD_OK;
 302 }
 303
 304 HRESULT WINAPI
 305 Main_IDirect3DDeviceImpl_7_3T_2T_1T_BeginScene(LPDIRECT3DDEVICE7 iface)
 306 {
 307     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 308     TRACE("(%p/%p)->()\n", This, iface);
 309     /* Nothing to do */
 310     return DD_OK;
 311 }
 312
 313 HRESULT WINAPI
 314 Main_IDirect3DDeviceImpl_7_3T_2T_1T_EndScene(LPDIRECT3DDEVICE7 iface)
 315 {
 316     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 317     TRACE("(%p/%p)->()\n", This, iface);
 318     /* Nothing to do */
 319     return DD_OK;
 320 }
 321
 322 HRESULT WINAPI
 323 Main_IDirect3DDeviceImpl_7_3T_2T_1T_GetDirect3D(LPDIRECT3DDEVICE7 iface,
 324                                                 LPDIRECT3D7* lplpDirect3D7)
 325 {
 326     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 327     TRACE("(%p/%p)->(%p)\n", This, iface, lplpDirect3D7);
 328
 329     *lplpDirect3D7 = ICOM_INTERFACE(This->d3d, IDirect3D7);
 330     IDirect3D7_AddRef(ICOM_INTERFACE(This->d3d, IDirect3D7));
 331
 332     TRACE(" returning interface %p\n", *lplpDirect3D7);
 333     return DD_OK;
 334 }
 335
 336 HRESULT WINAPI
 337 Main_IDirect3DDeviceImpl_7_3T_2T_SetRenderTarget(LPDIRECT3DDEVICE7 iface,
 338                                                  LPDIRECTDRAWSURFACE7 lpNewRenderTarget,
 339                                                  DWORD dwFlags)
 340 {
 341     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 342     IDirectDrawSurfaceImpl *target_impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, lpNewRenderTarget);
 343
 344     TRACE("(%p/%p)->(%p,%08lx)\n", This, iface, lpNewRenderTarget, dwFlags);
 345     if (target_impl != This->surface) {
 346         WARN(" Change of rendering target not handled yet !\n");
 347     }
 348     return DD_OK;
 349 }
 350
 351 HRESULT WINAPI
 352 Main_IDirect3DDeviceImpl_7_3T_2T_GetRenderTarget(LPDIRECT3DDEVICE7 iface,
 353                                                  LPDIRECTDRAWSURFACE7* lplpRenderTarget)
 354 {
 355     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 356     TRACE("(%p/%p)->(%p)\n", This, iface, lplpRenderTarget);
 357
 358     *lplpRenderTarget = ICOM_INTERFACE(This->surface, IDirectDrawSurface7);
 359     IDirectDrawSurface7_AddRef(ICOM_INTERFACE(This->surface, IDirectDrawSurface7));
 360
 361     TRACE(" returning surface at %p.\n", *lplpRenderTarget);
 362
 363     return DD_OK;
 364 }
 365
 366 HRESULT WINAPI
 367 Main_IDirect3DDeviceImpl_7_Clear(LPDIRECT3DDEVICE7 iface,
 368                                  DWORD dwCount,
 369                                  LPD3DRECT lpRects,
 370                                  DWORD dwFlags,
 371                                  D3DCOLOR dwColor,
 372                                  D3DVALUE dvZ,
 373                                  DWORD dwStencil)
 374 {
 375     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 376     TRACE("(%p/%p)->(%08lx,%p,%08lx,%08lx,%f,%08lx)\n", This, iface, dwCount, lpRects, dwFlags, (DWORD) dwColor, dvZ, dwStencil);
 377     return This->clear(This, dwCount, lpRects, dwFlags, dwColor, dvZ, dwStencil);
 378 }
 379
 380 HRESULT WINAPI
 381 Main_IDirect3DDeviceImpl_7_3T_2T_SetTransform(LPDIRECT3DDEVICE7 iface,
 382                                               D3DTRANSFORMSTATETYPE dtstTransformStateType,
 383                                               LPD3DMATRIX lpD3DMatrix)
 384 {
 385     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 386     DWORD matrix_changed = 0x00000000;
 387
 388     TRACE("(%p/%p)->(%08x,%p)\n", This, iface, dtstTransformStateType, lpD3DMatrix);
 389
 390     switch (dtstTransformStateType) {
 391         case D3DTRANSFORMSTATE_WORLD: {
 392             if (TRACE_ON(ddraw)) {
 393                 TRACE(" D3DTRANSFORMSTATE_WORLD :\n"); dump_D3DMATRIX(lpD3DMatrix);
 394             }
 395             memcpy(This->world_mat, lpD3DMatrix, 16 * sizeof(float));
 396             matrix_changed = WORLDMAT_CHANGED;
 397         } break;
 398
 399         case D3DTRANSFORMSTATE_VIEW: {
 400             if (TRACE_ON(ddraw)) {
 401                 TRACE(" D3DTRANSFORMSTATE_VIEW :\n");  dump_D3DMATRIX(lpD3DMatrix);
 402             }
 403             memcpy(This->view_mat, lpD3DMatrix, 16 * sizeof(float));
 404             matrix_changed = VIEWMAT_CHANGED;
 405         } break;
 406
 407         case D3DTRANSFORMSTATE_PROJECTION: {
 408             if (TRACE_ON(ddraw)) {
 409                 TRACE(" D3DTRANSFORMSTATE_PROJECTION :\n");  dump_D3DMATRIX(lpD3DMatrix);
 410             }
 411             memcpy(This->proj_mat, lpD3DMatrix, 16 * sizeof(float));
 412             matrix_changed = PROJMAT_CHANGED;
 413         } break;
 414
 415         case D3DTRANSFORMSTATE_TEXTURE0:
 416         case D3DTRANSFORMSTATE_TEXTURE1:
 417         case D3DTRANSFORMSTATE_TEXTURE2:
 418         case D3DTRANSFORMSTATE_TEXTURE3:
 419         case D3DTRANSFORMSTATE_TEXTURE4:
 420         case D3DTRANSFORMSTATE_TEXTURE5:
 421         case D3DTRANSFORMSTATE_TEXTURE6:
 422         case D3DTRANSFORMSTATE_TEXTURE7: {
 423             DWORD mat_num = dtstTransformStateType - D3DTRANSFORMSTATE_TEXTURE0;
 424             if (TRACE_ON(ddraw)) {
 425                 TRACE(" D3DTRANSFORMSTATE_TEXTURE%ld :\n", mat_num);  dump_D3DMATRIX(lpD3DMatrix);
 426             }
 427             memcpy(This->tex_mat[mat_num], lpD3DMatrix, 16 * sizeof(float));
 428             matrix_changed = TEXMAT0_CHANGED << mat_num;
 429         } break;
 430
 431         default:
 432             ERR("Unknown transform type %08x !!!\n", dtstTransformStateType);
 433             break;
 434     }
 435
 436     if (matrix_changed != 0x00000000) This->matrices_updated(This, matrix_changed);
 437
 438     return DD_OK;
 439 }
 440
 441 HRESULT WINAPI
 442 Main_IDirect3DDeviceImpl_7_3T_2T_GetTransform(LPDIRECT3DDEVICE7 iface,
 443                                               D3DTRANSFORMSTATETYPE dtstTransformStateType,
 444                                               LPD3DMATRIX lpD3DMatrix)
 445 {
 446     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 447     TRACE("(%p/%p)->(%08x,%p)\n", This, iface, dtstTransformStateType, lpD3DMatrix);
 448
 449     switch (dtstTransformStateType) {
 450         case D3DTRANSFORMSTATE_WORLD: {
 451             memcpy(lpD3DMatrix, This->world_mat, 16 * sizeof(D3DVALUE));
 452             if (TRACE_ON(ddraw)) {
 453                 TRACE(" returning D3DTRANSFORMSTATE_WORLD :\n");
 454                 dump_D3DMATRIX(lpD3DMatrix);
 455             }
 456         } break;
 457
 458         case D3DTRANSFORMSTATE_VIEW: {
 459             memcpy(lpD3DMatrix, This->view_mat, 16 * sizeof(D3DVALUE));
 460             if (TRACE_ON(ddraw)) {
 461                 TRACE(" returning D3DTRANSFORMSTATE_VIEW :\n");
 462                 dump_D3DMATRIX(lpD3DMatrix);
 463             }
 464         } break;
 465
 466         case D3DTRANSFORMSTATE_PROJECTION: {
 467             memcpy(lpD3DMatrix, This->proj_mat, 16 * sizeof(D3DVALUE));
 468             if (TRACE_ON(ddraw)) {
 469                 TRACE(" returning D3DTRANSFORMSTATE_PROJECTION :\n");
 470                 dump_D3DMATRIX(lpD3DMatrix);
 471             }
 472         } break;
 473
 474         case D3DTRANSFORMSTATE_TEXTURE0:
 475         case D3DTRANSFORMSTATE_TEXTURE1:
 476         case D3DTRANSFORMSTATE_TEXTURE2:
 477         case D3DTRANSFORMSTATE_TEXTURE3:
 478         case D3DTRANSFORMSTATE_TEXTURE4:
 479         case D3DTRANSFORMSTATE_TEXTURE5:
 480         case D3DTRANSFORMSTATE_TEXTURE6:
 481         case D3DTRANSFORMSTATE_TEXTURE7: {
 482             DWORD mat_num = dtstTransformStateType - D3DTRANSFORMSTATE_TEXTURE0;
 483             memcpy(lpD3DMatrix, This->tex_mat[mat_num], 16 * sizeof(D3DVALUE));
 484             if (TRACE_ON(ddraw)) {
 485                 TRACE(" returning D3DTRANSFORMSTATE_TEXTURE%ld :\n", mat_num);
 486                 dump_D3DMATRIX(lpD3DMatrix);
 487             }
 488         } break;
 489
 490         default:
 491             ERR("Unknown transform type %08x !!!\n", dtstTransformStateType);
 492             return DDERR_INVALIDPARAMS;
 493     }
 494
 495     return DD_OK;
 496 }
 497
 498 HRESULT WINAPI
 499 Main_IDirect3DDeviceImpl_7_3T_2T_MultiplyTransform(LPDIRECT3DDEVICE7 iface,
 500                                                    D3DTRANSFORMSTATETYPE dtstTransformStateType,
 501                                                    LPD3DMATRIX lpD3DMatrix)
 502 {
 503     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 504     LPD3DMATRIX mat;
 505     DWORD matrix_changed = 0x00000000;
 506
 507     TRACE("(%p/%p)->(%08x,%p)\n", This, iface, dtstTransformStateType, lpD3DMatrix);
 508
 509     if (TRACE_ON(ddraw)) {
 510         TRACE(" Multiplying by :\n"); dump_D3DMATRIX(lpD3DMatrix);
 511     }
 512
 513     switch (dtstTransformStateType) {
 514         case D3DTRANSFORMSTATE_WORLD: {
 515             if (TRACE_ON(ddraw)) {
 516                 TRACE(" Resulting D3DTRANSFORMSTATE_WORLD matrix is :\n");
 517             }
 518             mat = This->world_mat;
 519             matrix_changed = WORLDMAT_CHANGED;
 520         } break;
 521
 522         case D3DTRANSFORMSTATE_VIEW: {
 523             if (TRACE_ON(ddraw)) {
 524                 TRACE(" Resulting D3DTRANSFORMSTATE_VIEW matrix is :\n");
 525             }
 526             mat = This->view_mat;
 527             matrix_changed = VIEWMAT_CHANGED;
 528         } break;
 529
 530         case D3DTRANSFORMSTATE_PROJECTION: {
 531             if (TRACE_ON(ddraw)) {
 532                 TRACE(" Resulting D3DTRANSFORMSTATE_PROJECTION matrix is :\n");
 533             }
 534             mat = This->proj_mat;
 535             matrix_changed = PROJMAT_CHANGED;
 536         } break;
 537
 538         case D3DTRANSFORMSTATE_TEXTURE0:
 539         case D3DTRANSFORMSTATE_TEXTURE1:
 540         case D3DTRANSFORMSTATE_TEXTURE2:
 541         case D3DTRANSFORMSTATE_TEXTURE3:
 542         case D3DTRANSFORMSTATE_TEXTURE4:
 543         case D3DTRANSFORMSTATE_TEXTURE5:
 544         case D3DTRANSFORMSTATE_TEXTURE6:
 545         case D3DTRANSFORMSTATE_TEXTURE7: {
 546             DWORD mat_num = dtstTransformStateType - D3DTRANSFORMSTATE_TEXTURE0;
 547             if (TRACE_ON(ddraw)) {
 548                 TRACE(" Resulting D3DTRANSFORMSTATE_TEXTURE%ld matrix is :\n", mat_num);
 549             }
 550             mat = This->tex_mat[mat_num];
 551             matrix_changed = TEXMAT0_CHANGED << mat_num;
 552         } break;
 553
 554         default:
 555             ERR("Unknown transform type %08x !!!\n", dtstTransformStateType);
 556             return DDERR_INVALIDPARAMS;
 557     }
 558
 559     multiply_matrix(mat,mat,lpD3DMatrix);
 560
 561     if (TRACE_ON(ddraw)) {
 562         dump_D3DMATRIX(mat);
 563     }
 564
 565     if (matrix_changed != 0x00000000) This->matrices_updated(This, matrix_changed);
 566
 567     return DD_OK;
 568 }
 569
 570 HRESULT WINAPI
 571 Main_IDirect3DDeviceImpl_7_GetViewport(LPDIRECT3DDEVICE7 iface,
 572                                        LPD3DVIEWPORT7 lpData)
 573 {
 574     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 575     TRACE("(%p/%p)->(%p)\n", This, iface, lpData);
 576
 577     *lpData = This->active_viewport;
 578
 579     if (TRACE_ON(ddraw)) {
 580         TRACE(" returning viewport : \n");
 581         TRACE("    - dwX = %ld   dwY = %ld\n",
 582               lpData->dwX, lpData->dwY);
 583         TRACE("    - dwWidth = %ld   dwHeight = %ld\n",
 584               lpData->dwWidth, lpData->dwHeight);
 585         TRACE("    - dvMinZ = %f   dvMaxZ = %f\n",
 586               lpData->dvMinZ, lpData->dvMaxZ);
 587     }
 588
 589     return DD_OK;
 590 }
 591
 592 HRESULT WINAPI
 593 Main_IDirect3DDeviceImpl_7_SetMaterial(LPDIRECT3DDEVICE7 iface,
 594                                        LPD3DMATERIAL7 lpMat)
 595 {
 596     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 597     FIXME("(%p/%p)->(%p): stub!\n", This, iface, lpMat);
 598     return DD_OK;
 599 }
 600
 601 HRESULT WINAPI
 602 Main_IDirect3DDeviceImpl_7_GetMaterial(LPDIRECT3DDEVICE7 iface,
 603                                        LPD3DMATERIAL7 lpMat)
 604 {
 605     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 606     TRACE("(%p/%p)->(%p)\n", This, iface, lpMat);
 607
 608     *lpMat = This->current_material;
 609
 610     if (TRACE_ON(ddraw)) {
 611         TRACE(" returning material : \n");
 612         dump_D3DMATERIAL7(lpMat);
 613     }
 614
 615     return DD_OK;
 616 }
 617
 618 HRESULT WINAPI
 619 Main_IDirect3DDeviceImpl_7_SetLight(LPDIRECT3DDEVICE7 iface,
 620                                     DWORD dwLightIndex,
 621                                     LPD3DLIGHT7 lpLight)
 622 {
 623     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 624     FIXME("(%p/%p)->(%08lx,%p): stub!\n", This, iface, dwLightIndex, lpLight);
 625     return DD_OK;
 626 }
 627
 628 HRESULT WINAPI
 629 Main_IDirect3DDeviceImpl_7_GetLight(LPDIRECT3DDEVICE7 iface,
 630                                     DWORD dwLightIndex,
 631                                     LPD3DLIGHT7 lpLight)
 632 {
 633     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 634     TRACE("(%p/%p)->(%08lx,%p)\n", This, iface, dwLightIndex, lpLight);
 635
 636     if (dwLightIndex > MAX_LIGHTS) return DDERR_INVALIDPARAMS;
 637     *lpLight = This->light_parameters[dwLightIndex];
 638
 639     if (TRACE_ON(ddraw)) {
 640         TRACE(" returning light : \n");
 641         dump_D3DLIGHT7(lpLight);
 642     }
 643
 644     return DD_OK;
 645 }
 646
 647 HRESULT WINAPI
 648 Main_IDirect3DDeviceImpl_7_3T_2T_SetRenderState(LPDIRECT3DDEVICE7 iface,
 649                                                 D3DRENDERSTATETYPE dwRenderStateType,
 650                                                 DWORD dwRenderState)
 651 {
 652     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 653     FIXME("(%p/%p)->(%08x,%08lx): stub!\n", This, iface, dwRenderStateType, dwRenderState);
 654     return DD_OK;
 655 }
 656
 657 HRESULT WINAPI
 658 Main_IDirect3DDeviceImpl_7_3T_2T_GetRenderState(LPDIRECT3DDEVICE7 iface,
 659                                                 D3DRENDERSTATETYPE dwRenderStateType,
 660                                                 LPDWORD lpdwRenderState)
 661 {
 662     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 663     FIXME("(%p/%p)->(%08x,%p): stub!\n", This, iface, dwRenderStateType, lpdwRenderState);
 664     return DD_OK;
 665 }
 666
 667 HRESULT WINAPI
 668 Main_IDirect3DDeviceImpl_7_BeginStateBlock(LPDIRECT3DDEVICE7 iface)
 669 {
 670     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 671     FIXME("(%p/%p)->(): stub!\n", This, iface);
 672     return DD_OK;
 673 }
 674
 675 HRESULT WINAPI
 676 Main_IDirect3DDeviceImpl_7_EndStateBlock(LPDIRECT3DDEVICE7 iface,
 677                                          LPDWORD lpdwBlockHandle)
 678 {
 679     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 680     FIXME("(%p/%p)->(%p): stub!\n", This, iface, lpdwBlockHandle);
 681     return DD_OK;
 682 }
 683
 684 HRESULT WINAPI
 685 Main_IDirect3DDeviceImpl_7_PreLoad(LPDIRECT3DDEVICE7 iface,
 686                                    LPDIRECTDRAWSURFACE7 lpddsTexture)
 687 {
 688     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 689     FIXME("(%p/%p)->(%p): stub!\n", This, iface, lpddsTexture);
 690     return DD_OK;
 691 }
 692
 693 HRESULT WINAPI
 694 Main_IDirect3DDeviceImpl_7_3T_DrawPrimitive(LPDIRECT3DDEVICE7 iface,
 695                                             D3DPRIMITIVETYPE d3dptPrimitiveType,
 696                                             DWORD d3dvtVertexType,
 697                                             LPVOID lpvVertices,
 698                                             DWORD dwVertexCount,
 699                                             DWORD dwFlags)
 700 {
 701     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 702     FIXME("(%p/%p)->(%08x,%08lx,%p,%08lx,%08lx): stub!\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwFlags);
 703     return DD_OK;
 704 }
 705
 706 HRESULT WINAPI
 707 Main_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitive(LPDIRECT3DDEVICE7 iface,
 708                                                    D3DPRIMITIVETYPE d3dptPrimitiveType,
 709                                                    DWORD d3dvtVertexType,
 710                                                    LPVOID lpvVertices,
 711                                                    DWORD dwVertexCount,
 712                                                    LPWORD dwIndices,
 713                                                    DWORD dwIndexCount,
 714                                                    DWORD dwFlags)
 715 {
 716     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 717     FIXME("(%p/%p)->(%08x,%08lx,%p,%08lx,%p,%08lx,%08lx): stub!\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwIndices, dwIndexCount, dwFlags);
 718     return DD_OK;
 719 }
 720
 721 HRESULT WINAPI
 722 Main_IDirect3DDeviceImpl_7_3T_2T_SetClipStatus(LPDIRECT3DDEVICE7 iface,
 723                                                LPD3DCLIPSTATUS lpD3DClipStatus)
 724 {
 725     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 726     FIXME("(%p/%p)->(%p): stub!\n", This, iface, lpD3DClipStatus);
 727     return DD_OK;
 728 }
 729
 730 HRESULT WINAPI
 731 Main_IDirect3DDeviceImpl_7_3T_2T_GetClipStatus(LPDIRECT3DDEVICE7 iface,
 732                                                LPD3DCLIPSTATUS lpD3DClipStatus)
 733 {
 734     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 735     FIXME("(%p/%p)->(%p): stub!\n", This, iface, lpD3DClipStatus);
 736     return DD_OK;
 737 }
 738
 739 HRESULT WINAPI
 740 Main_IDirect3DDeviceImpl_7_3T_DrawPrimitiveStrided(LPDIRECT3DDEVICE7 iface,
 741                                                    D3DPRIMITIVETYPE d3dptPrimitiveType,
 742                                                    DWORD dwVertexType,
 743                                                    LPD3DDRAWPRIMITIVESTRIDEDDATA lpD3DDrawPrimStrideData,
 744                                                    DWORD dwVertexCount,
 745                                                    DWORD dwFlags)
 746 {
 747     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 748     FIXME("(%p/%p)->(%08x,%08lx,%p,%08lx,%08lx): stub!\n", This, iface, d3dptPrimitiveType, dwVertexType, lpD3DDrawPrimStrideData, dwVertexCount, dwFlags);
 749     return DD_OK;
 750 }
 751
 752 HRESULT WINAPI
 753 Main_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitiveStrided(LPDIRECT3DDEVICE7 iface,
 754                                                           D3DPRIMITIVETYPE d3dptPrimitiveType,
 755                                                           DWORD dwVertexType,
 756                                                           LPD3DDRAWPRIMITIVESTRIDEDDATA lpD3DDrawPrimStrideData,
 757                                                           DWORD dwVertexCount,
 758                                                           LPWORD lpIndex,
 759                                                           DWORD dwIndexCount,
 760                                                           DWORD dwFlags)
 761 {
 762     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 763     FIXME("(%p/%p)->(%08x,%08lx,%p,%08lx,%p,%08lx,%08lx): stub!\n", This, iface, d3dptPrimitiveType, dwVertexType, lpD3DDrawPrimStrideData, dwVertexCount, lpIndex, dwIndexCount, dwFlags);
 764     return DD_OK;
 765 }
 766
 767 HRESULT WINAPI
 768 Main_IDirect3DDeviceImpl_7_3T_DrawPrimitiveVB(LPDIRECT3DDEVICE7 iface,
 769                                               D3DPRIMITIVETYPE d3dptPrimitiveType,
 770                                               LPDIRECT3DVERTEXBUFFER7 lpD3DVertexBuf,
 771                                               DWORD dwStartVertex,
 772                                               DWORD dwNumVertices,
 773                                               DWORD dwFlags)
 774 {
 775     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 776     FIXME("(%p/%p)->(%08x,%p,%08lx,%08lx,%08lx): stub!\n", This, iface, d3dptPrimitiveType, lpD3DVertexBuf, dwStartVertex, dwNumVertices, dwFlags);
 777     return DD_OK;
 778 }
 779
 780 HRESULT WINAPI
 781 Main_IDirect3DDeviceImpl_7_3T_DrawIndexedPrimitiveVB(LPDIRECT3DDEVICE7 iface,
 782                                                      D3DPRIMITIVETYPE d3dptPrimitiveType,
 783                                                      LPDIRECT3DVERTEXBUFFER7 lpD3DVertexBuf,
 784                                                      DWORD dwStartVertex,
 785                                                      DWORD dwNumVertices,
 786                                                      LPWORD lpwIndices,
 787                                                      DWORD dwIndexCount,
 788                                                      DWORD dwFlags)
 789 {
 790     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 791     FIXME("(%p/%p)->(%08x,%p,%08lx,%08lx,%p,%08lx,%08lx): stub!\n", This, iface, d3dptPrimitiveType, lpD3DVertexBuf, dwStartVertex, dwNumVertices, lpwIndices, dwIndexCount, dwFlags);
 792     return DD_OK;
 793 }
 794
 795 HRESULT WINAPI
 796 Main_IDirect3DDeviceImpl_7_3T_ComputeSphereVisibility(LPDIRECT3DDEVICE7 iface,
 797                                                       LPD3DVECTOR lpCenters,
 798                                                       LPD3DVALUE lpRadii,
 799                                                       DWORD dwNumSpheres,
 800                                                       DWORD dwFlags,
 801                                                       LPDWORD lpdwReturnValues)
 802 {
 803     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 804     FIXME("(%p/%p)->(%p,%p,%08lx,%08lx,%p): stub!\n", This, iface, lpCenters, lpRadii, dwNumSpheres, dwFlags, lpdwReturnValues);
 805     return DD_OK;
 806 }
 807
 808 HRESULT WINAPI
 809 Main_IDirect3DDeviceImpl_7_3T_GetTexture(LPDIRECT3DDEVICE7 iface,
 810                                          DWORD dwStage,
 811                                          LPDIRECTDRAWSURFACE7* lpTexture)
 812 {
 813     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 814     TRACE("(%p/%p)->(%08lx,%p)\n", This, iface, dwStage, lpTexture);
 815
 816     if (This->current_texture[dwStage] != NULL) {
 817         *lpTexture = ICOM_INTERFACE(This->current_texture[dwStage], IDirectDrawSurface7);
 818         IDirectDrawSurface7_AddRef(*lpTexture);
 819     } else {
 820         *lpTexture = NULL;
 821     }
 822
 823     TRACE(" returning interface at %p (for implementation at %p).\n", *lpTexture, This->current_texture[dwStage]);
 824
 825     return DD_OK;
 826 }
 827
 828 HRESULT WINAPI
 829 Main_IDirect3DDeviceImpl_7_3T_SetTexture(LPDIRECT3DDEVICE7 iface,
 830                                          DWORD dwStage,
 831                                          LPDIRECTDRAWSURFACE7 lpTexture)
 832 {
 833     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 834     FIXME("(%p/%p)->(%08lx,%p): stub!\n", This, iface, dwStage, lpTexture);
 835     return DD_OK;
 836 }
 837
 838 HRESULT WINAPI
 839 Main_IDirect3DDeviceImpl_7_3T_GetTextureStageState(LPDIRECT3DDEVICE7 iface,
 840                                                    DWORD dwStage,
 841                                                    D3DTEXTURESTAGESTATETYPE d3dTexStageStateType,
 842                                                    LPDWORD lpdwState)
 843 {
 844     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 845     TRACE("(%p/%p)->(%08lx,%08x,%p)\n", This, iface, dwStage, d3dTexStageStateType, lpdwState);
 846     if (lpdwState && (dwStage < 8) && d3dTexStageStateType && (d3dTexStageStateType <= HIGHEST_TEXTURE_STAGE_STATE) ) {
 847         *lpdwState = This->state_block.texture_stage_state[dwStage][d3dTexStageStateType-1];
 848         return DD_OK;
 849     }
 850     return DDERR_INVALIDPARAMS;
 851 }
 852
 853 HRESULT WINAPI
 854 Main_IDirect3DDeviceImpl_7_3T_SetTextureStageState(LPDIRECT3DDEVICE7 iface,
 855                                                    DWORD dwStage,
 856                                                    D3DTEXTURESTAGESTATETYPE d3dTexStageStateType,
 857                                                    DWORD dwState)
 858 {
 859     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 860     FIXME("(%p/%p)->(%08lx,%08x,%08lx): stub!\n", This, iface, dwStage, d3dTexStageStateType, dwState);
 861     return DD_OK;
 862 }
 863
 864 HRESULT WINAPI
 865 Main_IDirect3DDeviceImpl_7_3T_ValidateDevice(LPDIRECT3DDEVICE7 iface,
 866                                              LPDWORD lpdwPasses)
 867 {
 868     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 869     FIXME("(%p/%p)->(%p): semi-stub!\n", This, iface, lpdwPasses);
 870
 871     /* For the moment, we have a VERY good hardware which does everything in one pass :-) */
 872     *lpdwPasses = 1;
 873
 874     return DD_OK;
 875 }
 876
 877 HRESULT WINAPI
 878 Main_IDirect3DDeviceImpl_7_ApplyStateBlock(LPDIRECT3DDEVICE7 iface,
 879                                            DWORD dwBlockHandle)
 880 {
 881     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 882     FIXME("(%p/%p)->(%08lx): stub!\n", This, iface, dwBlockHandle);
 883     return DD_OK;
 884 }
 885
 886 HRESULT WINAPI
 887 Main_IDirect3DDeviceImpl_7_CaptureStateBlock(LPDIRECT3DDEVICE7 iface,
 888                                              DWORD dwBlockHandle)
 889 {
 890     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 891     FIXME("(%p/%p)->(%08lx): stub!\n", This, iface, dwBlockHandle);
 892     return DD_OK;
 893 }
 894
 895 HRESULT WINAPI
 896 Main_IDirect3DDeviceImpl_7_DeleteStateBlock(LPDIRECT3DDEVICE7 iface,
 897                                             DWORD dwBlockHandle)
 898 {
 899     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 900     FIXME("(%p/%p)->(%08lx): stub!\n", This, iface, dwBlockHandle);
 901     return DD_OK;
 902 }
 903
 904 HRESULT WINAPI
 905 Main_IDirect3DDeviceImpl_7_CreateStateBlock(LPDIRECT3DDEVICE7 iface,
 906                                             D3DSTATEBLOCKTYPE d3dsbType,
 907                                             LPDWORD lpdwBlockHandle)
 908 {
 909     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 910     FIXME("(%p/%p)->(%08x,%p): stub!\n", This, iface, d3dsbType, lpdwBlockHandle);
 911     return DD_OK;
 912 }
 913
 914 HRESULT WINAPI
 915 Main_IDirect3DDeviceImpl_7_Load(LPDIRECT3DDEVICE7 iface,
 916                                 LPDIRECTDRAWSURFACE7 lpDestTex,
 917                                 LPPOINT lpDestPoint,
 918                                 LPDIRECTDRAWSURFACE7 lpSrcTex,
 919                                 LPRECT lprcSrcRect,
 920                                 DWORD dwFlags)
 921 {
 922     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 923     FIXME("(%p/%p)->(%p,%p,%p,%p,%08lx): Partially Implemented!\n", This, iface, lpDestTex, lpDestPoint, lpSrcTex, lprcSrcRect, dwFlags);
 924     IDirect3DTexture2_Load(COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7, IDirect3DTexture2, lpDestTex),
 925                            COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7, IDirect3DTexture2, lpSrcTex));
 926     return DD_OK;
 927 }
 928
 929 HRESULT WINAPI
 930 Main_IDirect3DDeviceImpl_7_LightEnable(LPDIRECT3DDEVICE7 iface,
 931                                        DWORD dwLightIndex,
 932                                        BOOL bEnable)
 933 {
 934     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 935     FIXME("(%p/%p)->(%08lx,%d): stub!\n", This, iface, dwLightIndex, bEnable);
 936     return DD_OK;
 937 }
 938
 939 HRESULT WINAPI
 940 Main_IDirect3DDeviceImpl_7_GetLightEnable(LPDIRECT3DDEVICE7 iface,
 941                                           DWORD dwLightIndex,
 942                                           BOOL* pbEnable)
 943 {
 944     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 945     TRACE("(%p/%p)->(%08lx,%p)\n", This, iface, dwLightIndex, pbEnable);
 946
 947     if (dwLightIndex > MAX_LIGHTS) *pbEnable = 0;
 948     else *pbEnable = ((0x00000001 << dwLightIndex) & This->active_lights) != 0;
 949
 950     TRACE(" returning %d.\n", *pbEnable);
 951
 952     return DD_OK;
 953 }
 954
 955 HRESULT WINAPI
 956 Main_IDirect3DDeviceImpl_7_SetClipPlane(LPDIRECT3DDEVICE7 iface,
 957                                         DWORD dwIndex,
 958                                         D3DVALUE* pPlaneEquation)
 959 {
 960     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 961     FIXME("(%p/%p)->(%08lx,%p): stub!\n", This, iface, dwIndex, pPlaneEquation);
 962     return DD_OK;
 963 }
 964
 965 HRESULT  WINAPI
 966 Main_IDirect3DDeviceImpl_7_GetClipPlane(LPDIRECT3DDEVICE7 iface, DWORD dwIndex, D3DVALUE* pPlaneEquation)
 967 {
 968     ICOM_THIS(IDirect3DDeviceImpl,iface);
 969
 970     TRACE("(%p)->(%ld,%p)\n", This, dwIndex, pPlaneEquation);
 971
 972     if (dwIndex>=This->max_clipping_planes) {
 973         return DDERR_INVALIDPARAMS;
 974     }
 975
 976     memcpy( pPlaneEquation, This->clipping_planes[dwIndex].plane, sizeof(D3DVALUE[4]));
 977
 978     return D3D_OK;
 979 }
 980
 981 HRESULT WINAPI
 982 Main_IDirect3DDeviceImpl_7_GetInfo(LPDIRECT3DDEVICE7 iface,
 983                                    DWORD dwDevInfoID,
 984                                    LPVOID pDevInfoStruct,
 985                                    DWORD dwSize)
 986 {
 987     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice7, iface);
 988     TRACE("(%p/%p)->(%08lx,%p,%08lx)\n", This, iface, dwDevInfoID, pDevInfoStruct, dwSize);
 989
 990     if (TRACE_ON(ddraw)) {
 991         TRACE(" info requested : ");
 992         switch (dwDevInfoID) {
 993             case D3DDEVINFOID_TEXTUREMANAGER: TRACE("D3DDEVINFOID_TEXTUREMANAGER\n"); break;
 994             case D3DDEVINFOID_D3DTEXTUREMANAGER: TRACE("D3DDEVINFOID_D3DTEXTUREMANAGER\n"); break;
 995             case D3DDEVINFOID_TEXTURING: TRACE("D3DDEVINFOID_TEXTURING\n"); break;
 996             default: ERR(" invalid flag !!!\n"); return DDERR_INVALIDPARAMS;
 997         }
 998     }
 999
1000     return S_FALSE; /* According to MSDN, this is valid for a non-debug driver */
1001 }
1002
1003 HRESULT WINAPI
1004 Main_IDirect3DDeviceImpl_3_2T_1T_GetCaps(LPDIRECT3DDEVICE3 iface,
1005                                          LPD3DDEVICEDESC lpD3DHWDevDesc,
1006                                          LPD3DDEVICEDESC lpD3DHELDevDesc)
1007 {
1008     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1009     FIXME("(%p/%p)->(%p,%p): stub!\n", This, iface, lpD3DHWDevDesc, lpD3DHELDevDesc);
1010     return DD_OK;
1011 }
1012
1013 HRESULT WINAPI
1014 Main_IDirect3DDeviceImpl_3_2T_1T_GetStats(LPDIRECT3DDEVICE3 iface,
1015                                           LPD3DSTATS lpD3DStats)
1016 {
1017     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1018     FIXME("(%p/%p)->(%p): stub!\n", This, iface, lpD3DStats);
1019     return DD_OK;
1020 }
1021
1022 HRESULT WINAPI
1023 Main_IDirect3DDeviceImpl_3_2T_1T_AddViewport(LPDIRECT3DDEVICE3 iface,
1024                                              LPDIRECT3DVIEWPORT3 lpDirect3DViewport3)
1025 {
1026     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1027     IDirect3DViewportImpl *lpDirect3DViewportImpl = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, lpDirect3DViewport3);
1028
1029     TRACE("(%p/%p)->(%p)\n", This, iface, lpDirect3DViewport3);
1030
1031     lpDirect3DViewportImpl->next = This->viewport_list;
1032     This->viewport_list = lpDirect3DViewportImpl;
1033
1034     return DD_OK;
1035 }
1036
1037 HRESULT WINAPI
1038 Main_IDirect3DDeviceImpl_3_2T_1T_DeleteViewport(LPDIRECT3DDEVICE3 iface,
1039                                                 LPDIRECT3DVIEWPORT3 lpDirect3DViewport3)
1040 {
1041     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1042     IDirect3DViewportImpl *lpDirect3DViewportImpl = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, lpDirect3DViewport3);
1043     IDirect3DViewportImpl *cur_viewport, *prev_viewport = NULL;
1044
1045     TRACE("(%p/%p)->(%p)\n", This, iface, lpDirect3DViewport3);
1046
1047     cur_viewport = This->viewport_list;
1048     while (cur_viewport != NULL) {
1049         if (cur_viewport == lpDirect3DViewportImpl) {
1050             if (prev_viewport == NULL) This->viewport_list = cur_viewport->next;
1051             else prev_viewport->next = cur_viewport->next;
1052             /* TODO : add desactivate of the viewport and all associated lights... */
1053             return DD_OK;
1054         }
1055         prev_viewport = cur_viewport;
1056         cur_viewport = cur_viewport->next;
1057     }
1058
1059     return DDERR_INVALIDPARAMS;
1060 }
1061
1062 HRESULT WINAPI
1063 Main_IDirect3DDeviceImpl_3_2T_1T_NextViewport(LPDIRECT3DDEVICE3 iface,
1064                                               LPDIRECT3DVIEWPORT3 lpDirect3DViewport3,
1065                                               LPDIRECT3DVIEWPORT3* lplpDirect3DViewport3,
1066                                               DWORD dwFlags)
1067 {
1068     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1069     IDirect3DViewportImpl *res = NULL;
1070
1071     TRACE("(%p/%p)->(%p,%p,%08lx)\n", This, iface, lpDirect3DViewport3, lplpDirect3DViewport3, dwFlags);
1072
1073     switch (dwFlags) {
1074         case D3DNEXT_NEXT: {
1075             IDirect3DViewportImpl *lpDirect3DViewportImpl = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, lpDirect3DViewport3);
1076             res = lpDirect3DViewportImpl->next;
1077         } break;
1078         case D3DNEXT_HEAD: {
1079             res = This->viewport_list;
1080         } break;
1081         case D3DNEXT_TAIL: {
1082             IDirect3DViewportImpl *cur_viewport = This->viewport_list;
1083             if (cur_viewport != NULL) {
1084                 while (cur_viewport->next != NULL) cur_viewport = cur_viewport->next;
1085             }
1086             res = cur_viewport;
1087         } break;
1088         default:
1089             *lplpDirect3DViewport3 = NULL;
1090             return DDERR_INVALIDPARAMS;
1091     }
1092     *lplpDirect3DViewport3 = ICOM_INTERFACE(res, IDirect3DViewport3);
1093     return DD_OK;
1094 }
1095
1096 HRESULT WINAPI
1097 Main_IDirect3DDeviceImpl_3_2T_SetCurrentViewport(LPDIRECT3DDEVICE3 iface,
1098                                                  LPDIRECT3DVIEWPORT3 lpDirect3DViewport3)
1099 {
1100     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1101     TRACE("(%p/%p)->(%p)\n", This, iface, lpDirect3DViewport3);
1102
1103     /* Do nothing if the specified viewport is the same as the current one */
1104     if (This->current_viewport == ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, lpDirect3DViewport3))
1105       return DD_OK;
1106
1107     /* Should check if the viewport was added or not */
1108
1109     /* Release previous viewport and AddRef the new one */
1110     if (This->current_viewport)
1111       IDirect3DViewport3_Release(ICOM_INTERFACE(This->current_viewport, IDirect3DViewport3));
1112     IDirect3DViewport3_AddRef(lpDirect3DViewport3);
1113
1114     /* Set this viewport as the current viewport */
1115     This->current_viewport = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, lpDirect3DViewport3);
1116
1117     /* Activate this viewport */
1118     This->current_viewport->active_device = This;
1119     This->current_viewport->activate(This->current_viewport);
1120
1121     return DD_OK;
1122 }
1123
1124 HRESULT WINAPI
1125 Main_IDirect3DDeviceImpl_3_2T_GetCurrentViewport(LPDIRECT3DDEVICE3 iface,
1126                                                  LPDIRECT3DVIEWPORT3* lplpDirect3DViewport3)
1127 {
1128     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1129     TRACE("(%p/%p)->(%p)\n", This, iface, lplpDirect3DViewport3);
1130
1131     *lplpDirect3DViewport3 = ICOM_INTERFACE(This->current_viewport, IDirect3DViewport3);
1132
1133     /* AddRef the returned viewport */
1134     IDirect3DViewport3_AddRef(*lplpDirect3DViewport3);
1135
1136     TRACE(" returning interface %p\n", *lplpDirect3DViewport3);
1137
1138     return DD_OK;
1139 }
1140
1141 HRESULT WINAPI
1142 Main_IDirect3DDeviceImpl_3_Begin(LPDIRECT3DDEVICE3 iface,
1143                                  D3DPRIMITIVETYPE d3dptPrimitiveType,
1144                                  DWORD dwVertexTypeDesc,
1145                                  DWORD dwFlags)
1146 {
1147     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1148     FIXME("(%p/%p)->(%08x,%08lx,%08lx): stub!\n", This, iface, d3dptPrimitiveType, dwVertexTypeDesc, dwFlags);
1149     return DD_OK;
1150 }
1151
1152 HRESULT WINAPI
1153 Main_IDirect3DDeviceImpl_3_BeginIndexed(LPDIRECT3DDEVICE3 iface,
1154                                         D3DPRIMITIVETYPE d3dptPrimitiveType,
1155                                         DWORD d3dvtVertexType,
1156                                         LPVOID lpvVertices,
1157                                         DWORD dwNumVertices,
1158                                         DWORD dwFlags)
1159 {
1160     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1161     FIXME("(%p/%p)->(%08x,%08lx,%p,%08lx,%08lx): stub!\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwNumVertices, dwFlags);
1162     return DD_OK;
1163 }
1164
1165 HRESULT WINAPI
1166 Main_IDirect3DDeviceImpl_3_2T_Vertex(LPDIRECT3DDEVICE3 iface,
1167                                      LPVOID lpVertexType)
1168 {
1169     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1170     FIXME("(%p/%p)->(%p): stub!\n", This, iface, lpVertexType);
1171     return DD_OK;
1172 }
1173
1174 HRESULT WINAPI
1175 Main_IDirect3DDeviceImpl_3_2T_Index(LPDIRECT3DDEVICE3 iface,
1176                                     WORD wVertexIndex)
1177 {
1178     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1179     FIXME("(%p/%p)->(%04x): stub!\n", This, iface, wVertexIndex);
1180     return DD_OK;
1181 }
1182
1183 HRESULT WINAPI
1184 Main_IDirect3DDeviceImpl_3_2T_End(LPDIRECT3DDEVICE3 iface,
1185                                   DWORD dwFlags)
1186 {
1187     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1188     FIXME("(%p/%p)->(%08lx): stub!\n", This, iface, dwFlags);
1189     return DD_OK;
1190 }
1191
1192 HRESULT WINAPI
1193 Main_IDirect3DDeviceImpl_3_2T_GetLightState(LPDIRECT3DDEVICE3 iface,
1194                                             D3DLIGHTSTATETYPE dwLightStateType,
1195                                             LPDWORD lpdwLightState)
1196 {
1197     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1198     FIXME("(%p/%p)->(%08x,%p): stub !\n", This, iface, dwLightStateType, lpdwLightState);
1199     return DD_OK;
1200 }
1201
1202 HRESULT WINAPI
1203 Main_IDirect3DDeviceImpl_3_2T_SetLightState(LPDIRECT3DDEVICE3 iface,
1204                                             D3DLIGHTSTATETYPE dwLightStateType,
1205                                             DWORD dwLightState)
1206 {
1207     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice3, iface);
1208     FIXME("(%p/%p)->(%08x,%08lx): stub!\n", This, iface, dwLightStateType, dwLightState);
1209     return DD_OK;
1210 }
1211
1212 HRESULT WINAPI
1213 Main_IDirect3DDeviceImpl_2_1T_SwapTextureHandles(LPDIRECT3DDEVICE2 iface,
1214                                                  LPDIRECT3DTEXTURE2 lpD3DTex1,
1215                                                  LPDIRECT3DTEXTURE2 lpD3DTex2)
1216 {
1217     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1218     IDirectDrawSurfaceImpl tmp,*surf1,*surf2;
1219     TRACE("(%p/%p)->(%p,%p):\n", This, iface, lpD3DTex1, lpD3DTex2);
1220
1221     surf1 = ICOM_OBJECT(IDirectDrawSurfaceImpl,IDirect3DTexture2,lpD3DTex1);
1222     surf2 = ICOM_OBJECT(IDirectDrawSurfaceImpl,IDirect3DTexture2,lpD3DTex2);
1223     tmp = *surf1;
1224     *surf1 = *surf2;
1225     *surf2 = tmp;
1226
1227     return DD_OK;
1228 }
1229
1230 HRESULT WINAPI
1231 Main_IDirect3DDeviceImpl_2_NextViewport(LPDIRECT3DDEVICE2 iface,
1232                                         LPDIRECT3DVIEWPORT2 lpDirect3DViewport2,
1233                                         LPDIRECT3DVIEWPORT2* lplpDirect3DViewport2,
1234                                         DWORD dwFlags)
1235 {
1236     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1237     FIXME("(%p/%p)->(%p,%p,%08lx): stub!\n", This, iface, lpDirect3DViewport2, lplpDirect3DViewport2, dwFlags);
1238     return DD_OK;
1239 }
1240
1241 HRESULT WINAPI
1242 Main_IDirect3DDeviceImpl_2_1T_EnumTextureFormats(LPDIRECT3DDEVICE2 iface,
1243                                                  LPD3DENUMTEXTUREFORMATSCALLBACK lpD3DEnumTextureProc,
1244                                                  LPVOID lpArg)
1245 {
1246     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1247     FIXME("(%p/%p)->(%p,%p): stub!\n", This, iface, lpD3DEnumTextureProc, lpArg);
1248     return DD_OK;
1249 }
1250
1251 HRESULT WINAPI
1252 Main_IDirect3DDeviceImpl_2_Begin(LPDIRECT3DDEVICE2 iface,
1253                                  D3DPRIMITIVETYPE d3dpt,
1254                                  D3DVERTEXTYPE dwVertexTypeDesc,
1255                                  DWORD dwFlags)
1256 {
1257     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1258     FIXME("(%p/%p)->(%08x,%08x,%08lx): stub!\n", This, iface, d3dpt, dwVertexTypeDesc, dwFlags);
1259     return DD_OK;
1260 }
1261
1262 HRESULT WINAPI
1263 Main_IDirect3DDeviceImpl_2_BeginIndexed(LPDIRECT3DDEVICE2 iface,
1264                                         D3DPRIMITIVETYPE d3dptPrimitiveType,
1265                                         D3DVERTEXTYPE d3dvtVertexType,
1266                                         LPVOID lpvVertices,
1267                                         DWORD dwNumVertices,
1268                                         DWORD dwFlags)
1269 {
1270     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1271     FIXME("(%p/%p)->(%08x,%08x,%p,%08lx,%08lx): stub!\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwNumVertices, dwFlags);
1272     return DD_OK;
1273 }
1274
1275 HRESULT WINAPI
1276 Main_IDirect3DDeviceImpl_2_DrawPrimitive(LPDIRECT3DDEVICE2 iface,
1277                                          D3DPRIMITIVETYPE d3dptPrimitiveType,
1278                                          D3DVERTEXTYPE d3dvtVertexType,
1279                                          LPVOID lpvVertices,
1280                                          DWORD dwVertexCount,
1281                                          DWORD dwFlags)
1282 {
1283     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1284     FIXME("(%p/%p)->(%08x,%08x,%p,%08lx,%08lx): stub!\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwFlags);
1285     return DD_OK;
1286 }
1287
1288 HRESULT WINAPI
1289 Main_IDirect3DDeviceImpl_2_DrawIndexedPrimitive(LPDIRECT3DDEVICE2 iface,
1290                                                 D3DPRIMITIVETYPE d3dptPrimitiveType,
1291                                                 D3DVERTEXTYPE d3dvtVertexType,
1292                                                 LPVOID lpvVertices,
1293                                                 DWORD dwVertexCount,
1294                                                 LPWORD dwIndices,
1295                                                 DWORD dwIndexCount,
1296                                                 DWORD dwFlags)
1297 {
1298     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice2, iface);
1299     FIXME("(%p/%p)->(%08x,%08x,%p,%08lx,%p,%08lx,%08lx): stub!\n", This, iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwIndices, dwIndexCount, dwFlags);
1300     return DD_OK;
1301 }
1302
1303 HRESULT WINAPI
1304 Main_IDirect3DDeviceImpl_1_Initialize(LPDIRECT3DDEVICE iface,
1305                                       LPDIRECT3D lpDirect3D,
1306                                       LPGUID lpGUID,
1307                                       LPD3DDEVICEDESC lpD3DDVDesc)
1308 {
1309     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1310     FIXME("(%p/%p)->(%p,%p,%p): stub!\n", This, iface, lpDirect3D, lpGUID, lpD3DDVDesc);
1311     return DD_OK;
1312 }
1313
1314 HRESULT WINAPI
1315 Main_IDirect3DDeviceImpl_1_CreateExecuteBuffer(LPDIRECT3DDEVICE iface,
1316                                                LPD3DEXECUTEBUFFERDESC lpDesc,
1317                                                LPDIRECT3DEXECUTEBUFFER* lplpDirect3DExecuteBuffer,
1318                                                IUnknown* pUnkOuter)
1319 {
1320     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1321     FIXME("(%p/%p)->(%p,%p,%p): stub!\n", This, iface, lpDesc, lplpDirect3DExecuteBuffer, pUnkOuter);
1322     return DD_OK;
1323 }
1324
1325 HRESULT WINAPI
1326 Main_IDirect3DDeviceImpl_1_Execute(LPDIRECT3DDEVICE iface,
1327                                    LPDIRECT3DEXECUTEBUFFER lpDirect3DExecuteBuffer,
1328                                    LPDIRECT3DVIEWPORT lpDirect3DViewport,
1329                                    DWORD dwFlags)
1330 {
1331     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1332     IDirect3DExecuteBufferImpl *lpDirect3DExecuteBufferImpl = ICOM_OBJECT(IDirect3DExecuteBufferImpl, IDirect3DExecuteBuffer, lpDirect3DExecuteBuffer);
1333     IDirect3DViewportImpl *lpDirect3DViewportImpl = ICOM_OBJECT(IDirect3DViewportImpl, IDirect3DViewport3, lpDirect3DViewport);
1334
1335     TRACE("(%p/%p)->(%p,%p,%08lx)\n", This, iface, lpDirect3DExecuteBuffer, lpDirect3DViewport, dwFlags);
1336
1337     /* Put this as the default context */
1338
1339     /* Execute... */
1340     lpDirect3DExecuteBufferImpl->execute(lpDirect3DExecuteBufferImpl, This, lpDirect3DViewportImpl);
1341
1342     return DD_OK;
1343 }
1344
1345 HRESULT WINAPI
1346 Main_IDirect3DDeviceImpl_1_NextViewport(LPDIRECT3DDEVICE iface,
1347                                         LPDIRECT3DVIEWPORT lpDirect3DViewport,
1348                                         LPDIRECT3DVIEWPORT* lplpDirect3DViewport,
1349                                         DWORD dwFlags)
1350 {
1351     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1352     FIXME("(%p/%p)->(%p,%p,%08lx): stub!\n", This, iface, lpDirect3DViewport, lplpDirect3DViewport, dwFlags);
1353     return DD_OK;
1354 }
1355
1356 HRESULT WINAPI
1357 Main_IDirect3DDeviceImpl_1_Pick(LPDIRECT3DDEVICE iface,
1358                                 LPDIRECT3DEXECUTEBUFFER lpDirect3DExecuteBuffer,
1359                                 LPDIRECT3DVIEWPORT lpDirect3DViewport,
1360                                 DWORD dwFlags,
1361                                 LPD3DRECT lpRect)
1362 {
1363     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1364     FIXME("(%p/%p)->(%p,%p,%08lx,%p): stub!\n", This, iface, lpDirect3DExecuteBuffer, lpDirect3DViewport, dwFlags, lpRect);
1365     return DD_OK;
1366 }
1367
1368 HRESULT WINAPI
1369 Main_IDirect3DDeviceImpl_1_GetPickRecords(LPDIRECT3DDEVICE iface,
1370                                           LPDWORD lpCount,
1371                                           LPD3DPICKRECORD lpD3DPickRec)
1372 {
1373     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1374     FIXME("(%p/%p)->(%p,%p): stub!\n", This, iface, lpCount, lpD3DPickRec);
1375     return DD_OK;
1376 }
1377
1378 HRESULT WINAPI
1379 Main_IDirect3DDeviceImpl_1_CreateMatrix(LPDIRECT3DDEVICE iface,
1380                                         LPD3DMATRIXHANDLE lpD3DMatHandle)
1381 {
1382     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1383     TRACE("(%p/%p)->(%p)\n", This, iface, lpD3DMatHandle);
1384
1385     *lpD3DMatHandle = (D3DMATRIXHANDLE) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(D3DMATRIX));
1386     TRACE(" returning matrix handle %p\n", (void *) *lpD3DMatHandle);
1387
1388     return DD_OK;
1389 }
1390
1391 HRESULT WINAPI
1392 Main_IDirect3DDeviceImpl_1_SetMatrix(LPDIRECT3DDEVICE iface,
1393                                      D3DMATRIXHANDLE D3DMatHandle,
1394                                      LPD3DMATRIX lpD3DMatrix)
1395 {
1396     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1397     TRACE("(%p/%p)->(%08lx,%p)\n", This, iface, (DWORD) D3DMatHandle, lpD3DMatrix);
1398
1399     if (TRACE_ON(ddraw)) {
1400         dump_D3DMATRIX(lpD3DMatrix);
1401     }
1402     *((D3DMATRIX *) D3DMatHandle) = *lpD3DMatrix;
1403
1404     return DD_OK;
1405 }
1406
1407 HRESULT WINAPI
1408 Main_IDirect3DDeviceImpl_1_GetMatrix(LPDIRECT3DDEVICE iface,
1409                                      D3DMATRIXHANDLE D3DMatHandle,
1410                                      LPD3DMATRIX lpD3DMatrix)
1411 {
1412     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1413     TRACE("(%p/%p)->(%08lx,%p)\n", This, iface, (DWORD) D3DMatHandle, lpD3DMatrix);
1414
1415     *lpD3DMatrix = *((D3DMATRIX *) D3DMatHandle);
1416
1417     return DD_OK;
1418 }
1419
1420 HRESULT WINAPI
1421 Main_IDirect3DDeviceImpl_1_DeleteMatrix(LPDIRECT3DDEVICE iface,
1422                                         D3DMATRIXHANDLE D3DMatHandle)
1423 {
1424     ICOM_THIS_FROM(IDirect3DDeviceImpl, IDirect3DDevice, iface);
1425     TRACE("(%p/%p)->(%08lx)\n", This, iface, (DWORD) D3DMatHandle);
1426
1427     HeapFree(GetProcessHeap(), 0, (void *) D3DMatHandle);
1428
1429     return DD_OK;
1430 }
1431
1432 HRESULT WINAPI
1433 Thunk_IDirect3DDeviceImpl_3_QueryInterface(LPDIRECT3DDEVICE3 iface,
1434                                            REFIID riid,
1435                                            LPVOID* obp)
1436 {
1437     TRACE("(%p)->(%s,%p) thunking to IDirect3DDevice7 interface.\n", iface, debugstr_guid(riid), obp);
1438     return IDirect3DDevice7_QueryInterface(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1439                                            riid,
1440                                            obp);
1441 }
1442
1443 HRESULT WINAPI
1444 Thunk_IDirect3DDeviceImpl_2_QueryInterface(LPDIRECT3DDEVICE2 iface,
1445                                            REFIID riid,
1446                                            LPVOID* obp)
1447 {
1448     TRACE("(%p)->(%s,%p) thunking to IDirect3DDevice7 interface.\n", iface, debugstr_guid(riid), obp);
1449     return IDirect3DDevice7_QueryInterface(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface),
1450                                            riid,
1451                                            obp);
1452 }
1453
1454 HRESULT WINAPI
1455 Thunk_IDirect3DDeviceImpl_1_QueryInterface(LPDIRECT3DDEVICE iface,
1456                                            REFIID riid,
1457                                            LPVOID* obp)
1458 {
1459     TRACE("(%p)->(%s,%p) thunking to IDirect3DDevice7 interface.\n", iface, debugstr_guid(riid), obp);
1460     return IDirect3DDevice7_QueryInterface(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice7, iface),
1461                                            riid,
1462                                            obp);
1463 }
1464
1465 ULONG WINAPI
1466 Thunk_IDirect3DDeviceImpl_3_AddRef(LPDIRECT3DDEVICE3 iface)
1467 {
1468     TRACE("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
1469     return IDirect3DDevice7_AddRef(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface));
1470 }
1471
1472 ULONG WINAPI
1473 Thunk_IDirect3DDeviceImpl_2_AddRef(LPDIRECT3DDEVICE2 iface)
1474 {
1475     TRACE("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
1476     return IDirect3DDevice7_AddRef(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface));
1477 }
1478
1479 ULONG WINAPI
1480 Thunk_IDirect3DDeviceImpl_1_AddRef(LPDIRECT3DDEVICE iface)
1481 {
1482     TRACE("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
1483     return IDirect3DDevice7_AddRef(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice7, iface));
1484 }
1485
1486 ULONG WINAPI
1487 Thunk_IDirect3DDeviceImpl_3_Release(LPDIRECT3DDEVICE3 iface)
1488 {
1489     TRACE("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
1490     return IDirect3DDevice7_Release(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface));
1491 }
1492
1493 ULONG WINAPI
1494 Thunk_IDirect3DDeviceImpl_2_Release(LPDIRECT3DDEVICE2 iface)
1495 {
1496     TRACE("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
1497     return IDirect3DDevice7_Release(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface));
1498 }
1499
1500 ULONG WINAPI
1501 Thunk_IDirect3DDeviceImpl_1_Release(LPDIRECT3DDEVICE iface)
1502 {
1503     TRACE("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
1504     return IDirect3DDevice7_Release(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice7, iface));
1505 }
1506
1507 HRESULT WINAPI
1508 Thunk_IDirect3DDeviceImpl_2_AddViewport(LPDIRECT3DDEVICE2 iface,
1509                                         LPDIRECT3DVIEWPORT2 lpDirect3DViewport2)
1510 {
1511     TRACE("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", iface, lpDirect3DViewport2);
1512     return IDirect3DDevice3_AddViewport(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice3, iface),
1513                                         (LPDIRECT3DVIEWPORT3) lpDirect3DViewport2 /* No need to cast here as all interfaces are equivalent */);
1514 }
1515
1516 HRESULT WINAPI
1517 Thunk_IDirect3DDeviceImpl_1_AddViewport(LPDIRECT3DDEVICE iface,
1518                                         LPDIRECT3DVIEWPORT lpDirect3DViewport)
1519 {
1520     TRACE("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", iface, lpDirect3DViewport);
1521     return IDirect3DDevice3_AddViewport(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice3, iface),
1522                                         (LPDIRECT3DVIEWPORT3) lpDirect3DViewport /* No need to cast here as all interfaces are equivalent */);
1523 }
1524
1525 HRESULT WINAPI
1526 Thunk_IDirect3DDeviceImpl_2_DeleteViewport(LPDIRECT3DDEVICE2 iface,
1527                                            LPDIRECT3DVIEWPORT2 lpDirect3DViewport2)
1528 {
1529     TRACE("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", iface, lpDirect3DViewport2);
1530     return IDirect3DDevice3_DeleteViewport(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice3, iface),
1531                                            (LPDIRECT3DVIEWPORT3) lpDirect3DViewport2 /* No need to cast here as all interfaces are equivalent */);
1532 }
1533
1534 HRESULT WINAPI
1535 Thunk_IDirect3DDeviceImpl_1_DeleteViewport(LPDIRECT3DDEVICE iface,
1536                                            LPDIRECT3DVIEWPORT lpDirect3DViewport)
1537 {
1538     TRACE("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", iface, lpDirect3DViewport);
1539     return IDirect3DDevice3_DeleteViewport(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice3, iface),
1540                                            (LPDIRECT3DVIEWPORT3) lpDirect3DViewport /* No need to cast here as all interfaces are equivalent */);
1541 }
1542
1543 HRESULT WINAPI
1544 Thunk_IDirect3DDeviceImpl_2_NextViewport(LPDIRECT3DDEVICE3 iface,
1545                                          LPDIRECT3DVIEWPORT2 lpDirect3DViewport2,
1546                                          LPDIRECT3DVIEWPORT2* lplpDirect3DViewport2,
1547                                          DWORD dwFlags)
1548 {
1549     TRACE("(%p)->(%p,%p,%08lx) thunking to IDirect3DDevice3 interface.\n", iface, lpDirect3DViewport2, lplpDirect3DViewport2, dwFlags);
1550     return IDirect3DDevice3_NextViewport(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice3, iface),
1551                                          (LPDIRECT3DVIEWPORT3) lpDirect3DViewport2 /* No need to cast here as all interfaces are equivalent */,
1552                                          (LPDIRECT3DVIEWPORT3*) lplpDirect3DViewport2,
1553                                          dwFlags);
1554 }
1555
1556 HRESULT WINAPI
1557 Thunk_IDirect3DDeviceImpl_1_NextViewport(LPDIRECT3DDEVICE3 iface,
1558                                          LPDIRECT3DVIEWPORT lpDirect3DViewport,
1559                                          LPDIRECT3DVIEWPORT* lplpDirect3DViewport,
1560                                          DWORD dwFlags)
1561 {
1562     TRACE("(%p)->(%p,%p,%08lx) thunking to IDirect3DDevice3 interface.\n", iface, lpDirect3DViewport, lplpDirect3DViewport, dwFlags);
1563     return IDirect3DDevice3_NextViewport(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice3, iface),
1564                                          (LPDIRECT3DVIEWPORT3) lpDirect3DViewport /* No need to cast here as all interfaces are equivalent */,
1565                                          (LPDIRECT3DVIEWPORT3*) lplpDirect3DViewport,
1566                                          dwFlags);
1567 }
1568
1569 HRESULT WINAPI
1570 Thunk_IDirect3DDeviceImpl_3_GetDirect3D(LPDIRECT3DDEVICE3 iface,
1571                                         LPDIRECT3D3* lplpDirect3D3)
1572 {
1573     HRESULT ret;
1574     LPDIRECT3D7 ret_ptr;
1575
1576     TRACE("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", iface, lplpDirect3D3);
1577     ret = IDirect3DDevice7_GetDirect3D(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1578                                        &ret_ptr);
1579     *lplpDirect3D3 = COM_INTERFACE_CAST(IDirectDrawImpl, IDirect3D7, IDirect3D3, ret_ptr);
1580     TRACE(" returning interface %p\n", *lplpDirect3D3);
1581     return ret;
1582 }
1583
1584 HRESULT WINAPI
1585 Thunk_IDirect3DDeviceImpl_2_GetDirect3D(LPDIRECT3DDEVICE2 iface,
1586                                         LPDIRECT3D2* lplpDirect3D2)
1587 {
1588     HRESULT ret;
1589     LPDIRECT3D7 ret_ptr;
1590
1591     TRACE("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", iface, lplpDirect3D2);
1592     ret = IDirect3DDevice7_GetDirect3D(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface),
1593                                        &ret_ptr);
1594     *lplpDirect3D2 = COM_INTERFACE_CAST(IDirectDrawImpl, IDirect3D7, IDirect3D2, ret_ptr);
1595     TRACE(" returning interface %p\n", *lplpDirect3D2);
1596     return ret;
1597 }
1598
1599 HRESULT WINAPI
1600 Thunk_IDirect3DDeviceImpl_1_GetDirect3D(LPDIRECT3DDEVICE iface,
1601                                         LPDIRECT3D* lplpDirect3D)
1602 {
1603     HRESULT ret;
1604     LPDIRECT3D7 ret_ptr;
1605
1606     TRACE("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", iface, lplpDirect3D);
1607     ret = IDirect3DDevice7_GetDirect3D(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice7, iface),
1608                                        &ret_ptr);
1609     *lplpDirect3D = COM_INTERFACE_CAST(IDirectDrawImpl, IDirect3D7, IDirect3D, ret_ptr);
1610     TRACE(" returning interface %p\n", *lplpDirect3D);
1611     return ret;
1612 }
1613
1614 HRESULT WINAPI
1615 Thunk_IDirect3DDeviceImpl_2_SetCurrentViewport(LPDIRECT3DDEVICE2 iface,
1616                                                LPDIRECT3DVIEWPORT2 lpDirect3DViewport2)
1617 {
1618     TRACE("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", iface, lpDirect3DViewport2);
1619     return IDirect3DDevice3_SetCurrentViewport(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice3, iface),
1620                                                (LPDIRECT3DVIEWPORT3) lpDirect3DViewport2 /* No need to cast here as all interfaces are equivalent */);
1621 }
1622
1623 HRESULT WINAPI
1624 Thunk_IDirect3DDeviceImpl_2_GetCurrentViewport(LPDIRECT3DDEVICE2 iface,
1625                                                LPDIRECT3DVIEWPORT2* lplpDirect3DViewport2)
1626 {
1627     TRACE("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", iface, lplpDirect3DViewport2);
1628     return IDirect3DDevice3_GetCurrentViewport(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice3, iface),
1629                                                (LPDIRECT3DVIEWPORT3*) lplpDirect3DViewport2 /* No need to cast here as all interfaces are equivalent */);
1630 }
1631
1632 HRESULT WINAPI
1633 Thunk_IDirect3DDeviceImpl_3_EnumTextureFormats(LPDIRECT3DDEVICE3 iface,
1634                                                LPD3DENUMPIXELFORMATSCALLBACK lpD3DEnumPixelProc,
1635                                                LPVOID lpArg)
1636 {
1637     TRACE("(%p)->(%p,%p) thunking to IDirect3DDevice7 interface.\n", iface, lpD3DEnumPixelProc, lpArg);
1638     return IDirect3DDevice7_EnumTextureFormats(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1639                                                lpD3DEnumPixelProc,
1640                                                lpArg);
1641 }
1642
1643 HRESULT WINAPI
1644 Thunk_IDirect3DDeviceImpl_3_BeginScene(LPDIRECT3DDEVICE3 iface)
1645 {
1646     TRACE("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
1647     return IDirect3DDevice7_BeginScene(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface));
1648 }
1649
1650 HRESULT WINAPI
1651 Thunk_IDirect3DDeviceImpl_2_BeginScene(LPDIRECT3DDEVICE2 iface)
1652 {
1653     TRACE("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
1654     return IDirect3DDevice7_BeginScene(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface));
1655 }
1656
1657 HRESULT WINAPI
1658 Thunk_IDirect3DDeviceImpl_1_BeginScene(LPDIRECT3DDEVICE iface)
1659 {
1660     TRACE("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
1661     return IDirect3DDevice7_BeginScene(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice7, iface));
1662 }
1663
1664 HRESULT WINAPI
1665 Thunk_IDirect3DDeviceImpl_3_EndScene(LPDIRECT3DDEVICE3 iface)
1666 {
1667     TRACE("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
1668     return IDirect3DDevice7_EndScene(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface));
1669 }
1670
1671 HRESULT WINAPI
1672 Thunk_IDirect3DDeviceImpl_2_EndScene(LPDIRECT3DDEVICE2 iface)
1673 {
1674     TRACE("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
1675     return IDirect3DDevice7_EndScene(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface));
1676 }
1677
1678 HRESULT WINAPI
1679 Thunk_IDirect3DDeviceImpl_1_EndScene(LPDIRECT3DDEVICE iface)
1680 {
1681     TRACE("(%p)->() thunking to IDirect3DDevice7 interface.\n", iface);
1682     return IDirect3DDevice7_EndScene(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice7, iface));
1683 }
1684
1685 HRESULT WINAPI
1686 Thunk_IDirect3DDeviceImpl_3_SetTransform(LPDIRECT3DDEVICE3 iface,
1687                                          D3DTRANSFORMSTATETYPE dtstTransformStateType,
1688                                          LPD3DMATRIX lpD3DMatrix)
1689 {
1690     TRACE("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", iface, dtstTransformStateType, lpD3DMatrix);
1691     return IDirect3DDevice7_SetTransform(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1692                                          dtstTransformStateType,
1693                                          lpD3DMatrix);
1694 }
1695
1696 HRESULT WINAPI
1697 Thunk_IDirect3DDeviceImpl_2_SetTransform(LPDIRECT3DDEVICE2 iface,
1698                                          D3DTRANSFORMSTATETYPE dtstTransformStateType,
1699                                          LPD3DMATRIX lpD3DMatrix)
1700 {
1701     TRACE("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", iface, dtstTransformStateType, lpD3DMatrix);
1702     return IDirect3DDevice7_SetTransform(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface),
1703                                          dtstTransformStateType,
1704                                          lpD3DMatrix);
1705 }
1706
1707 HRESULT WINAPI
1708 Thunk_IDirect3DDeviceImpl_3_GetTransform(LPDIRECT3DDEVICE3 iface,
1709                                          D3DTRANSFORMSTATETYPE dtstTransformStateType,
1710                                          LPD3DMATRIX lpD3DMatrix)
1711 {
1712     TRACE("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", iface, dtstTransformStateType, lpD3DMatrix);
1713     return IDirect3DDevice7_GetTransform(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1714                                          dtstTransformStateType,
1715                                          lpD3DMatrix);
1716 }
1717
1718 HRESULT WINAPI
1719 Thunk_IDirect3DDeviceImpl_2_GetTransform(LPDIRECT3DDEVICE2 iface,
1720                                          D3DTRANSFORMSTATETYPE dtstTransformStateType,
1721                                          LPD3DMATRIX lpD3DMatrix)
1722 {
1723     TRACE("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", iface, dtstTransformStateType, lpD3DMatrix);
1724     return IDirect3DDevice7_GetTransform(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface),
1725                                          dtstTransformStateType,
1726                                          lpD3DMatrix);
1727 }
1728
1729 HRESULT WINAPI
1730 Thunk_IDirect3DDeviceImpl_3_MultiplyTransform(LPDIRECT3DDEVICE3 iface,
1731                                               D3DTRANSFORMSTATETYPE dtstTransformStateType,
1732                                               LPD3DMATRIX lpD3DMatrix)
1733 {
1734     TRACE("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", iface, dtstTransformStateType, lpD3DMatrix);
1735     return IDirect3DDevice7_MultiplyTransform(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1736                                               dtstTransformStateType,
1737                                               lpD3DMatrix);
1738 }
1739
1740 HRESULT WINAPI
1741 Thunk_IDirect3DDeviceImpl_2_MultiplyTransform(LPDIRECT3DDEVICE2 iface,
1742                                               D3DTRANSFORMSTATETYPE dtstTransformStateType,
1743                                               LPD3DMATRIX lpD3DMatrix)
1744 {
1745     TRACE("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", iface, dtstTransformStateType, lpD3DMatrix);
1746     return IDirect3DDevice7_MultiplyTransform(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface),
1747                                               dtstTransformStateType,
1748                                               lpD3DMatrix);
1749 }
1750
1751 HRESULT WINAPI
1752 Thunk_IDirect3DDeviceImpl_3_SetRenderState(LPDIRECT3DDEVICE3 iface,
1753                                            D3DRENDERSTATETYPE dwRenderStateType,
1754                                            DWORD dwRenderState)
1755 {
1756     TRACE("(%p)->(%08x,%08lx) thunking to IDirect3DDevice7 interface.\n", iface, dwRenderStateType, dwRenderState);
1757     return IDirect3DDevice7_SetRenderState(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1758                                            dwRenderStateType,
1759                                            dwRenderState);
1760 }
1761
1762 HRESULT WINAPI
1763 Thunk_IDirect3DDeviceImpl_2_SetRenderState(LPDIRECT3DDEVICE2 iface,
1764                                            D3DRENDERSTATETYPE dwRenderStateType,
1765                                            DWORD dwRenderState)
1766 {
1767     TRACE("(%p)->(%08x,%08lx) thunking to IDirect3DDevice7 interface.\n", iface, dwRenderStateType, dwRenderState);
1768     return IDirect3DDevice7_SetRenderState(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface),
1769                                            dwRenderStateType,
1770                                            dwRenderState);
1771 }
1772
1773 HRESULT WINAPI
1774 Thunk_IDirect3DDeviceImpl_3_GetRenderState(LPDIRECT3DDEVICE3 iface,
1775                                            D3DRENDERSTATETYPE dwRenderStateType,
1776                                            LPDWORD lpdwRenderState)
1777 {
1778     TRACE("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", iface, dwRenderStateType, lpdwRenderState);
1779     return IDirect3DDevice7_GetRenderState(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1780                                            dwRenderStateType,
1781                                            lpdwRenderState);
1782 }
1783
1784 HRESULT WINAPI
1785 Thunk_IDirect3DDeviceImpl_2_GetRenderState(LPDIRECT3DDEVICE2 iface,
1786                                            D3DRENDERSTATETYPE dwRenderStateType,
1787                                            LPDWORD lpdwRenderState)
1788 {
1789     TRACE("(%p)->(%08x,%p) thunking to IDirect3DDevice7 interface.\n", iface, dwRenderStateType, lpdwRenderState);
1790     return IDirect3DDevice7_GetRenderState(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface),
1791                                            dwRenderStateType,
1792                                            lpdwRenderState);
1793 }
1794
1795 HRESULT WINAPI
1796 Thunk_IDirect3DDeviceImpl_3_DrawPrimitive(LPDIRECT3DDEVICE3 iface,
1797                                           D3DPRIMITIVETYPE d3dptPrimitiveType,
1798                                           DWORD d3dvtVertexType,
1799                                           LPVOID lpvVertices,
1800                                           DWORD dwVertexCount,
1801                                           DWORD dwFlags)
1802 {
1803     TRACE("(%p)->(%08x,%08lx,%p,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwFlags);
1804     return IDirect3DDevice7_DrawPrimitive(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1805                                           d3dptPrimitiveType,
1806                                           d3dvtVertexType,
1807                                           lpvVertices,
1808                                           dwVertexCount,
1809                                           dwFlags);
1810 }
1811
1812 HRESULT WINAPI
1813 Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitive(LPDIRECT3DDEVICE3 iface,
1814                                                  D3DPRIMITIVETYPE d3dptPrimitiveType,
1815                                                  DWORD d3dvtVertexType,
1816                                                  LPVOID lpvVertices,
1817                                                  DWORD dwVertexCount,
1818                                                  LPWORD dwIndices,
1819                                                  DWORD dwIndexCount,
1820                                                  DWORD dwFlags)
1821 {
1822     TRACE("(%p)->(%08x,%08lx,%p,%08lx,%p,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", iface, d3dptPrimitiveType, d3dvtVertexType, lpvVertices, dwVertexCount, dwIndices, dwIndexCount, dwFlags);
1823     return IDirect3DDevice7_DrawIndexedPrimitive(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1824                                                  d3dptPrimitiveType,
1825                                                  d3dvtVertexType,
1826                                                  lpvVertices,
1827                                                  dwVertexCount,
1828                                                  dwIndices,
1829                                                  dwIndexCount,
1830                                                  dwFlags);
1831 }
1832
1833 HRESULT WINAPI
1834 Thunk_IDirect3DDeviceImpl_3_SetClipStatus(LPDIRECT3DDEVICE3 iface,
1835                                           LPD3DCLIPSTATUS lpD3DClipStatus)
1836 {
1837     TRACE("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", iface, lpD3DClipStatus);
1838     return IDirect3DDevice7_SetClipStatus(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1839                                           lpD3DClipStatus);
1840 }
1841
1842 HRESULT WINAPI
1843 Thunk_IDirect3DDeviceImpl_2_SetClipStatus(LPDIRECT3DDEVICE2 iface,
1844                                           LPD3DCLIPSTATUS lpD3DClipStatus)
1845 {
1846     TRACE("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", iface, lpD3DClipStatus);
1847     return IDirect3DDevice7_SetClipStatus(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface),
1848                                           lpD3DClipStatus);
1849 }
1850
1851 HRESULT WINAPI
1852 Thunk_IDirect3DDeviceImpl_3_GetClipStatus(LPDIRECT3DDEVICE3 iface,
1853                                           LPD3DCLIPSTATUS lpD3DClipStatus)
1854 {
1855     TRACE("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", iface, lpD3DClipStatus);
1856     return IDirect3DDevice7_GetClipStatus(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1857                                           lpD3DClipStatus);
1858 }
1859
1860 HRESULT WINAPI
1861 Thunk_IDirect3DDeviceImpl_2_GetClipStatus(LPDIRECT3DDEVICE2 iface,
1862                                           LPD3DCLIPSTATUS lpD3DClipStatus)
1863 {
1864     TRACE("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", iface, lpD3DClipStatus);
1865     return IDirect3DDevice7_GetClipStatus(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface),
1866                                           lpD3DClipStatus);
1867 }
1868
1869 HRESULT WINAPI
1870 Thunk_IDirect3DDeviceImpl_3_DrawPrimitiveStrided(LPDIRECT3DDEVICE3 iface,
1871                                                  D3DPRIMITIVETYPE d3dptPrimitiveType,
1872                                                  DWORD dwVertexType,
1873                                                  LPD3DDRAWPRIMITIVESTRIDEDDATA lpD3DDrawPrimStrideData,
1874                                                  DWORD dwVertexCount,
1875                                                  DWORD dwFlags)
1876 {
1877     TRACE("(%p)->(%08x,%08lx,%p,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", iface, d3dptPrimitiveType, dwVertexType, lpD3DDrawPrimStrideData, dwVertexCount, dwFlags);
1878     return IDirect3DDevice7_DrawPrimitiveStrided(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1879                                                  d3dptPrimitiveType,
1880                                                  dwVertexType,
1881                                                  lpD3DDrawPrimStrideData,
1882                                                  dwVertexCount,
1883                                                  dwFlags);
1884 }
1885
1886 HRESULT WINAPI
1887 Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitiveStrided(LPDIRECT3DDEVICE3 iface,
1888                                                         D3DPRIMITIVETYPE d3dptPrimitiveType,
1889                                                         DWORD dwVertexType,
1890                                                         LPD3DDRAWPRIMITIVESTRIDEDDATA lpD3DDrawPrimStrideData,
1891                                                         DWORD dwVertexCount,
1892                                                         LPWORD lpIndex,
1893                                                         DWORD dwIndexCount,
1894                                                         DWORD dwFlags)
1895 {
1896     TRACE("(%p)->(%08x,%08lx,%p,%08lx,%p,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", iface, d3dptPrimitiveType, dwVertexType, lpD3DDrawPrimStrideData, dwVertexCount, lpIndex, dwIndexCount, dwFlags);
1897     return IDirect3DDevice7_DrawIndexedPrimitiveStrided(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1898                                                         d3dptPrimitiveType,
1899                                                         dwVertexType,
1900                                                         lpD3DDrawPrimStrideData,
1901                                                         dwVertexCount,
1902                                                         lpIndex,
1903                                                         dwIndexCount,
1904                                                         dwFlags);
1905 }
1906
1907 HRESULT WINAPI
1908 Thunk_IDirect3DDeviceImpl_3_ComputeSphereVisibility(LPDIRECT3DDEVICE3 iface,
1909                                                     LPD3DVECTOR lpCenters,
1910                                                     LPD3DVALUE lpRadii,
1911                                                     DWORD dwNumSpheres,
1912                                                     DWORD dwFlags,
1913                                                     LPDWORD lpdwReturnValues)
1914 {
1915     TRACE("(%p)->(%p,%p,%08lx,%08lx,%p) thunking to IDirect3DDevice7 interface.\n", iface, lpCenters, lpRadii, dwNumSpheres, dwFlags, lpdwReturnValues);
1916     return IDirect3DDevice7_ComputeSphereVisibility(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1917                                                     lpCenters,
1918                                                     lpRadii,
1919                                                     dwNumSpheres,
1920                                                     dwFlags,
1921                                                     lpdwReturnValues);
1922 }
1923
1924 HRESULT WINAPI
1925 Thunk_IDirect3DDeviceImpl_3_GetTextureStageState(LPDIRECT3DDEVICE3 iface,
1926                                                  DWORD dwStage,
1927                                                  D3DTEXTURESTAGESTATETYPE d3dTexStageStateType,
1928                                                  LPDWORD lpdwState)
1929 {
1930     TRACE("(%p)->(%08lx,%08x,%p) thunking to IDirect3DDevice7 interface.\n", iface, dwStage, d3dTexStageStateType, lpdwState);
1931     return IDirect3DDevice7_GetTextureStageState(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1932                                                  dwStage,
1933                                                  d3dTexStageStateType,
1934                                                  lpdwState);
1935 }
1936
1937 HRESULT WINAPI
1938 Thunk_IDirect3DDeviceImpl_3_SetTextureStageState(LPDIRECT3DDEVICE3 iface,
1939                                                  DWORD dwStage,
1940                                                  D3DTEXTURESTAGESTATETYPE d3dTexStageStateType,
1941                                                  DWORD dwState)
1942 {
1943     TRACE("(%p)->(%08lx,%08x,%08lx) thunking to IDirect3DDevice7 interface.\n", iface, dwStage, d3dTexStageStateType, dwState);
1944     return IDirect3DDevice7_SetTextureStageState(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1945                                                  dwStage,
1946                                                  d3dTexStageStateType,
1947                                                  dwState);
1948 }
1949
1950 HRESULT WINAPI
1951 Thunk_IDirect3DDeviceImpl_3_ValidateDevice(LPDIRECT3DDEVICE3 iface,
1952                                            LPDWORD lpdwPasses)
1953 {
1954     TRACE("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", iface, lpdwPasses);
1955     return IDirect3DDevice7_ValidateDevice(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
1956                                            lpdwPasses);
1957 }
1958
1959 HRESULT WINAPI
1960 Thunk_IDirect3DDeviceImpl_2_GetCaps(LPDIRECT3DDEVICE2 iface,
1961                                     LPD3DDEVICEDESC lpD3DHWDevDesc,
1962                                     LPD3DDEVICEDESC lpD3DHELDevDesc)
1963 {
1964     TRACE("(%p)->(%p,%p) thunking to IDirect3DDevice3 interface.\n", iface, lpD3DHWDevDesc, lpD3DHELDevDesc);
1965     return IDirect3DDevice3_GetCaps(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice3, iface),
1966                                     lpD3DHWDevDesc,
1967                                     lpD3DHELDevDesc);
1968 }
1969
1970 HRESULT WINAPI
1971 Thunk_IDirect3DDeviceImpl_1_GetCaps(LPDIRECT3DDEVICE iface,
1972                                     LPD3DDEVICEDESC lpD3DHWDevDesc,
1973                                     LPD3DDEVICEDESC lpD3DHELDevDesc)
1974 {
1975     TRACE("(%p)->(%p,%p) thunking to IDirect3DDevice3 interface.\n", iface, lpD3DHWDevDesc, lpD3DHELDevDesc);
1976     return IDirect3DDevice3_GetCaps(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice3, iface),
1977                                     lpD3DHWDevDesc,
1978                                     lpD3DHELDevDesc);
1979 }
1980
1981 HRESULT WINAPI
1982 Thunk_IDirect3DDeviceImpl_1_SwapTextureHandles(LPDIRECT3DDEVICE iface,
1983                                               LPDIRECT3DTEXTURE lpD3DTex1,
1984                                               LPDIRECT3DTEXTURE lpD3DTex2)
1985 {
1986     TRACE("(%p)->(%p,%p) thunking to IDirect3DDevice2 interface.\n", iface, lpD3DTex1, lpD3DTex2);
1987     return IDirect3DDevice2_SwapTextureHandles(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice2, iface),
1988                                                COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture, IDirect3DTexture2, lpD3DTex1),
1989                                                COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture, IDirect3DTexture2, lpD3DTex2));
1990 }
1991
1992 HRESULT WINAPI
1993 Thunk_IDirect3DDeviceImpl_2_GetStats(LPDIRECT3DDEVICE2 iface,
1994                                      LPD3DSTATS lpD3DStats)
1995 {
1996     TRACE("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", iface, lpD3DStats);
1997     return IDirect3DDevice3_GetStats(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice3, iface),
1998                                      lpD3DStats);
1999 }
2000
2001 HRESULT WINAPI
2002 Thunk_IDirect3DDeviceImpl_1_GetStats(LPDIRECT3DDEVICE iface,
2003                                      LPD3DSTATS lpD3DStats)
2004 {
2005     TRACE("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", iface, lpD3DStats);
2006     return IDirect3DDevice3_GetStats(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice3, iface),
2007                                      lpD3DStats);
2008 }
2009
2010 HRESULT WINAPI
2011 Thunk_IDirect3DDeviceImpl_3_SetRenderTarget(LPDIRECT3DDEVICE3 iface,
2012                                             LPDIRECTDRAWSURFACE4 lpNewRenderTarget,
2013                                             DWORD dwFlags)
2014 {
2015     TRACE("(%p)->(%p,%08lx) thunking to IDirect3DDevice7 interface.\n", iface, lpNewRenderTarget, dwFlags);
2016     return IDirect3DDevice7_SetRenderTarget(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
2017                                             (LPDIRECTDRAWSURFACE7) lpNewRenderTarget /* No cast needed as DSurf4 == DSurf7 */,
2018                                             dwFlags);
2019 }
2020
2021 HRESULT WINAPI
2022 Thunk_IDirect3DDeviceImpl_3_GetRenderTarget(LPDIRECT3DDEVICE3 iface,
2023                                             LPDIRECTDRAWSURFACE4* lplpRenderTarget)
2024 {
2025     TRACE("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", iface, lplpRenderTarget);
2026     return IDirect3DDevice7_GetRenderTarget(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
2027                                             (LPDIRECTDRAWSURFACE7*) lplpRenderTarget /* No cast needed as DSurf4 == DSurf7 */);
2028 }
2029
2030 HRESULT WINAPI
2031 Thunk_IDirect3DDeviceImpl_2_SetRenderTarget(LPDIRECT3DDEVICE2 iface,
2032                                             LPDIRECTDRAWSURFACE lpNewRenderTarget,
2033                                             DWORD dwFlags)
2034 {
2035     TRACE("(%p)->(%p,%08lx) thunking to IDirect3DDevice7 interface.\n", iface, lpNewRenderTarget, dwFlags);
2036     return IDirect3DDevice7_SetRenderTarget(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface),
2037                                             COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface3, IDirectDrawSurface7, lpNewRenderTarget),
2038                                             dwFlags);
2039 }
2040
2041 HRESULT WINAPI
2042 Thunk_IDirect3DDeviceImpl_2_GetRenderTarget(LPDIRECT3DDEVICE2 iface,
2043                                             LPDIRECTDRAWSURFACE* lplpRenderTarget)
2044 {
2045     HRESULT ret;
2046     LPDIRECTDRAWSURFACE7 ret_val;
2047
2048     TRACE("(%p)->(%p) thunking to IDirect3DDevice7 interface.\n", iface, lplpRenderTarget);
2049     ret = IDirect3DDevice7_GetRenderTarget(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice7, iface),
2050                                            &ret_val);
2051     *lplpRenderTarget = (LPDIRECTDRAWSURFACE) COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7, IDirectDrawSurface3, ret_val);
2052     TRACE(" returning interface %p\n", *lplpRenderTarget);
2053     return ret;
2054 }
2055
2056 HRESULT WINAPI
2057 Thunk_IDirect3DDeviceImpl_2_Vertex(LPDIRECT3DDEVICE2 iface,
2058                                    LPVOID lpVertexType)
2059 {
2060     TRACE("(%p)->(%p) thunking to IDirect3DDevice3 interface.\n", iface, lpVertexType);
2061     return IDirect3DDevice3_Vertex(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice3, iface),
2062                                    lpVertexType);
2063 }
2064
2065 HRESULT WINAPI
2066 Thunk_IDirect3DDeviceImpl_2_Index(LPDIRECT3DDEVICE2 iface,
2067                                   WORD wVertexIndex)
2068 {
2069     TRACE("(%p)->(%04x) thunking to IDirect3DDevice3 interface.\n", iface, wVertexIndex);
2070     return IDirect3DDevice3_Index(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice3, iface),
2071                                   wVertexIndex);
2072 }
2073
2074 HRESULT WINAPI
2075 Thunk_IDirect3DDeviceImpl_2_End(LPDIRECT3DDEVICE2 iface,
2076                                 DWORD dwFlags)
2077 {
2078     TRACE("(%p)->(%08lx) thunking to IDirect3DDevice3 interface.\n", iface, dwFlags);
2079     return IDirect3DDevice3_End(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice3, iface),
2080                                 dwFlags);
2081 }
2082
2083 HRESULT WINAPI
2084 Thunk_IDirect3DDeviceImpl_2_GetLightState(LPDIRECT3DDEVICE2 iface,
2085                                           D3DLIGHTSTATETYPE dwLightStateType,
2086                                           LPDWORD lpdwLightState)
2087 {
2088     TRACE("(%p)->(%08x,%p) thunking to IDirect3DDevice3 interface.\n", iface, dwLightStateType, lpdwLightState);
2089     return IDirect3DDevice3_GetLightState(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice3, iface),
2090                                           dwLightStateType,
2091                                           lpdwLightState);
2092 }
2093
2094 HRESULT WINAPI
2095 Thunk_IDirect3DDeviceImpl_2_SetLightState(LPDIRECT3DDEVICE2 iface,
2096                                           D3DLIGHTSTATETYPE dwLightStateType,
2097                                           DWORD dwLightState)
2098 {
2099     TRACE("(%p)->(%08x,%08lx) thunking to IDirect3DDevice3 interface.\n", iface, dwLightStateType, dwLightState);
2100     return IDirect3DDevice3_SetLightState(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice2, IDirect3DDevice3, iface),
2101                                           dwLightStateType,
2102                                           dwLightState);
2103 }
2104
2105 HRESULT WINAPI
2106 Thunk_IDirect3DDeviceImpl_1_EnumTextureFormats(LPDIRECT3DDEVICE iface,
2107                                                LPD3DENUMTEXTUREFORMATSCALLBACK lpD3DEnumTextureProc,
2108                                                LPVOID lpArg)
2109 {
2110     TRACE("(%p)->(%p,%p) thunking to IDirect3DDevice2 interface.\n", iface, lpD3DEnumTextureProc, lpArg);
2111     return IDirect3DDevice2_EnumTextureFormats(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice, IDirect3DDevice2, iface),
2112                                                lpD3DEnumTextureProc,
2113                                                lpArg);
2114 }
2115
2116 HRESULT WINAPI
2117 Thunk_IDirect3DDeviceImpl_3_SetTexture(LPDIRECT3DDEVICE3 iface,
2118                                        DWORD dwStage,
2119                                        LPDIRECT3DTEXTURE2 lpTexture2)
2120 {
2121     TRACE("(%p)->(%ld,%p) thunking to IDirect3DDevice7 interface.\n", iface, dwStage, lpTexture2);
2122     return IDirect3DDevice7_SetTexture(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
2123                                        dwStage,
2124                                        COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirect3DTexture2, IDirectDrawSurface7, lpTexture2));
2125 }
2126
2127 HRESULT WINAPI
2128 Thunk_IDirect3DDeviceImpl_3_DrawPrimitiveVB(LPDIRECT3DDEVICE3 iface,
2129                                             D3DPRIMITIVETYPE d3dptPrimitiveType,
2130                                             LPDIRECT3DVERTEXBUFFER lpD3DVertexBuf,
2131                                             DWORD dwStartVertex,
2132                                             DWORD dwNumVertices,
2133                                             DWORD dwFlags)
2134 {
2135     TRACE("(%p)->(%08x,%p,%08lx,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", iface,
2136           d3dptPrimitiveType, lpD3DVertexBuf, dwStartVertex, dwNumVertices, dwFlags);
2137     return IDirect3DDevice7_DrawPrimitiveVB(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
2138                                             d3dptPrimitiveType,
2139                                             COM_INTERFACE_CAST(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, IDirect3DVertexBuffer7, lpD3DVertexBuf),
2140                                             dwStartVertex,
2141                                             dwNumVertices,
2142                                             dwFlags);
2143 }
2144
2145 HRESULT WINAPI
2146 Thunk_IDirect3DDeviceImpl_3_DrawIndexedPrimitiveVB(LPDIRECT3DDEVICE3 iface,
2147                                                    D3DPRIMITIVETYPE d3dptPrimitiveType,
2148                                                    LPDIRECT3DVERTEXBUFFER lpD3DVertexBuf,
2149                                                    LPWORD lpwIndices,
2150                                                    DWORD dwIndexCount,
2151                                                    DWORD dwFlags)
2152 {
2153     TRACE("(%p)->(%08x,%p,%p,%08lx,%08lx) thunking to IDirect3DDevice7 interface.\n", iface,
2154           d3dptPrimitiveType, lpD3DVertexBuf, lpwIndices, dwIndexCount, dwFlags);
2155     return IDirect3DDevice7_DrawIndexedPrimitiveVB(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
2156                                                    d3dptPrimitiveType,
2157                                                    COM_INTERFACE_CAST(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer, IDirect3DVertexBuffer7, lpD3DVertexBuf),
2158                                                    0,
2159                                                    dwIndexCount,
2160                                                    lpwIndices,
2161                                                    dwIndexCount,
2162                                                    dwFlags);
2163 }
2164
2165 HRESULT WINAPI
2166 Thunk_IDirect3DDeviceImpl_3_GetTexture(LPDIRECT3DDEVICE3 iface,
2167                                        DWORD dwStage,
2168                                        LPDIRECT3DTEXTURE2* lplpTexture2)
2169 {
2170     HRESULT ret;
2171     LPDIRECTDRAWSURFACE7 ret_val;
2172
2173     TRACE("(%p)->(%ld,%p) thunking to IDirect3DDevice7 interface.\n", iface, dwStage, lplpTexture2);
2174     ret = IDirect3DDevice7_GetTexture(COM_INTERFACE_CAST(IDirect3DDeviceImpl, IDirect3DDevice3, IDirect3DDevice7, iface),
2175                                       dwStage,
2176                                       &ret_val);
2177
2178     *lplpTexture2 = COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7, IDirect3DTexture2, ret_val);
2179
2180     TRACE(" returning interface %p.\n", *lplpTexture2);
2181
2182     return ret;
2183 }