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

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