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