git.oblomov.eu Git - wine/blob - dlls/d3d8/device.c

   1 /*
   2  * IDirect3DDevice8 implementation
   3  *
   4  * Copyright 2002-2004 Jason Edmeades
   5  * Copyright 2004 Christian Costa
   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 <math.h>
  25 #include <stdarg.h>
  26
  27 #define NONAMELESSUNION
  28 #define NONAMELESSSTRUCT
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winuser.h"
  32 #include "wingdi.h"
  33 #include "wine/debug.h"
  34
  35 #include "d3d8_private.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(d3d8);
  38
  39 /* IDirect3D IUnknown parts follow: */
  40 HRESULT WINAPI IDirect3DDevice8Impl_QueryInterface(LPDIRECT3DDEVICE8 iface,REFIID riid,LPVOID *ppobj)
  41 {
  42     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
  43
  44     if (IsEqualGUID(riid, &IID_IUnknown)
  45         || IsEqualGUID(riid, &IID_IDirect3DDevice8)) {
  46         IUnknown_AddRef(iface);
  47         *ppobj = This;
  48         return D3D_OK;
  49     }
  50
  51     WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
  52     return E_NOINTERFACE;
  53 }
  54
  55 ULONG WINAPI IDirect3DDevice8Impl_AddRef(LPDIRECT3DDEVICE8 iface) {
  56     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
  57     ULONG ref = InterlockedIncrement(&This->ref);
  58
  59     TRACE("(%p) : AddRef from %ld\n", This, ref - 1);
  60
  61     return ref;
  62 }
  63
  64 ULONG WINAPI IDirect3DDevice8Impl_Release(LPDIRECT3DDEVICE8 iface) {
  65     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
  66     ULONG ref = InterlockedDecrement(&This->ref);
  67
  68     TRACE("(%p) : ReleaseRef to %ld\n", This, ref);
  69
  70     if (ref == 0) {
  71         TRACE("Releasing wined3d device %p\n", This->WineD3DDevice);
  72         IWineD3DDevice_Release(This->WineD3DDevice);
  73         HeapFree(GetProcessHeap(), 0, This);
  74     }
  75     return ref;
  76 }
  77
  78 /* IDirect3DDevice Interface follow: */
  79 HRESULT WINAPI IDirect3DDevice8Impl_TestCooperativeLevel(LPDIRECT3DDEVICE8 iface) {
  80     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
  81
  82     TRACE("(%p) : Relay\n", This);
  83     return IWineD3DDevice_TestCooperativeLevel(This->WineD3DDevice);
  84 }
  85
  86 UINT WINAPI  IDirect3DDevice8Impl_GetAvailableTextureMem(LPDIRECT3DDEVICE8 iface) {
  87     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
  88
  89     TRACE("(%p) Relay\n", This);
  90     return IWineD3DDevice_GetAvailableTextureMem(This->WineD3DDevice);
  91 }
  92
  93 HRESULT WINAPI IDirect3DDevice8Impl_ResourceManagerDiscardBytes(LPDIRECT3DDEVICE8 iface, DWORD Bytes) {
  94     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
  95
  96     TRACE("(%p) : Relay bytes(%ld)\n", This, Bytes);
  97     return IWineD3DDevice_EvictManagedResources(This->WineD3DDevice);
  98 }
  99
 100 HRESULT WINAPI IDirect3DDevice8Impl_GetDirect3D(LPDIRECT3DDEVICE8 iface, IDirect3D8** ppD3D8) {
 101     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 102     HRESULT hr = D3D_OK;
 103     IWineD3D* pWineD3D;
 104
 105     TRACE("(%p) Relay\n", This);
 106
 107     if (NULL == ppD3D8) {
 108         return D3DERR_INVALIDCALL;
 109     }
 110     hr = IWineD3DDevice_GetDirect3D(This->WineD3DDevice, &pWineD3D);
 111     if (hr == D3D_OK && pWineD3D != NULL)
 112     {
 113         IWineD3DResource_GetParent((IWineD3DResource *)pWineD3D,(IUnknown **)ppD3D8);
 114         IWineD3DResource_Release((IWineD3DResource *)pWineD3D);
 115     } else {
 116         FIXME("Call to IWineD3DDevice_GetDirect3D failed\n");
 117         *ppD3D8 = NULL;
 118     }
 119     TRACE("(%p) returning %p\b",This , *ppD3D8);
 120     return hr;
 121 }
 122
 123 HRESULT WINAPI IDirect3DDevice8Impl_GetDeviceCaps(LPDIRECT3DDEVICE8 iface, D3DCAPS8* pCaps) {
 124     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 125     HRESULT hrc = D3D_OK;
 126     WINED3DCAPS *pWineCaps;
 127
 128     TRACE("(%p) : Relay pCaps %p\n", This, pCaps);
 129     if(NULL == pCaps){
 130         return D3DERR_INVALIDCALL;
 131     }
 132     pWineCaps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINED3DCAPS));
 133     if(pWineCaps == NULL){
 134         return D3DERR_INVALIDCALL; /* well this is what MSDN says to return */
 135     }
 136
 137     D3D8CAPSTOWINECAPS(pCaps, pWineCaps)
 138     hrc = IWineD3DDevice_GetDeviceCaps(This->WineD3DDevice, pWineCaps);
 139     HeapFree(GetProcessHeap(), 0, pWineCaps);
 140     TRACE("Returning %p %p\n", This, pCaps);
 141     return hrc;
 142 }
 143
 144 HRESULT WINAPI IDirect3DDevice8Impl_GetDisplayMode(LPDIRECT3DDEVICE8 iface, D3DDISPLAYMODE* pMode) {
 145     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 146     TRACE("(%p) Relay\n", This);
 147     return IWineD3DDevice_GetDisplayMode(This->WineD3DDevice, 0, pMode);
 148 }
 149
 150 HRESULT WINAPI IDirect3DDevice8Impl_GetCreationParameters(LPDIRECT3DDEVICE8 iface, D3DDEVICE_CREATION_PARAMETERS *pParameters) {
 151     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 152     TRACE("(%p) Relay\n", This);
 153     return IWineD3DDevice_GetCreationParameters(This->WineD3DDevice, pParameters);
 154 }
 155
 156 HRESULT WINAPI IDirect3DDevice8Impl_SetCursorProperties(LPDIRECT3DDEVICE8 iface, UINT XHotSpot, UINT YHotSpot, IDirect3DSurface8* pCursorBitmap) {
 157     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 158     IDirect3DSurface8Impl *pSurface = (IDirect3DSurface8Impl*)pCursorBitmap;
 159     TRACE("(%p) Relay\n", This);
 160     return IWineD3DDevice_SetCursorProperties(This->WineD3DDevice,XHotSpot,YHotSpot,(IWineD3DSurface*)pSurface->wineD3DSurface);
 161 }
 162
 163 void WINAPI IDirect3DDevice8Impl_SetCursorPosition(LPDIRECT3DDEVICE8 iface, UINT XScreenSpace, UINT YScreenSpace, DWORD Flags) {
 164     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 165     TRACE("(%p) Relay\n", This);
 166     return IWineD3DDevice_SetCursorPosition(This->WineD3DDevice, XScreenSpace, YScreenSpace, Flags);
 167 }
 168
 169 BOOL WINAPI IDirect3DDevice8Impl_ShowCursor(LPDIRECT3DDEVICE8 iface, BOOL bShow) {
 170     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 171     TRACE("(%p) Relay\n", This);
 172
 173     return IWineD3DDevice_ShowCursor(This->WineD3DDevice, bShow);
 174 }
 175
 176 HRESULT WINAPI IDirect3DDevice8Impl_CreateAdditionalSwapChain(LPDIRECT3DDEVICE8 iface, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain8** pSwapChain) {
 177     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 178     IDirect3DSwapChain8Impl* object;
 179     HRESULT hrc = D3D_OK;
 180     WINED3DPRESENT_PARAMETERS localParameters;
 181
 182     TRACE("(%p) Relay\n", This);
 183
 184     object = HeapAlloc(GetProcessHeap(),  HEAP_ZERO_MEMORY, sizeof(*object));
 185     if (NULL == object) {
 186         FIXME("Allocation of memory failed\n");
 187         *pSwapChain = NULL;
 188         return D3DERR_OUTOFVIDEOMEMORY;
 189     }
 190     object->ref = 1;
 191     object->lpVtbl = &Direct3DSwapChain8_Vtbl;
 192
 193     /* Allocate an associated WineD3DDevice object */
 194     localParameters.BackBufferWidth                = &pPresentationParameters->BackBufferWidth;
 195     localParameters.BackBufferHeight               = &pPresentationParameters->BackBufferHeight;
 196     localParameters.BackBufferFormat               = (WINED3DFORMAT *)&pPresentationParameters->BackBufferFormat;
 197     localParameters.BackBufferCount                = &pPresentationParameters->BackBufferCount;
 198     localParameters.MultiSampleType                = (WINED3DMULTISAMPLE_TYPE *) &pPresentationParameters->MultiSampleType;
 199     localParameters.MultiSampleQuality             = NULL; /* d3d9 only */
 200     localParameters.SwapEffect                     = (WINED3DSWAPEFFECT *) &pPresentationParameters->SwapEffect;
 201     localParameters.hDeviceWindow                  = &pPresentationParameters->hDeviceWindow;
 202     localParameters.Windowed                       = &pPresentationParameters->Windowed;
 203     localParameters.EnableAutoDepthStencil         = &pPresentationParameters->EnableAutoDepthStencil;
 204     localParameters.AutoDepthStencilFormat         = (WINED3DFORMAT *)&pPresentationParameters->AutoDepthStencilFormat;
 205     localParameters.Flags                          = &pPresentationParameters->Flags;
 206     localParameters.FullScreen_RefreshRateInHz     = &pPresentationParameters->FullScreen_RefreshRateInHz;
 207     localParameters.PresentationInterval           = &pPresentationParameters->FullScreen_PresentationInterval;
 208
 209
 210     hrc = IWineD3DDevice_CreateAdditionalSwapChain(This->WineD3DDevice, &localParameters, &object->wineD3DSwapChain, (IUnknown*)object, D3D8CB_CreateRenderTarget, D3D8CB_CreateDepthStencilSurface);
 211     if (hrc != D3D_OK) {
 212         FIXME("(%p) call to IWineD3DDevice_CreateAdditionalSwapChain failed\n", This);
 213         HeapFree(GetProcessHeap(), 0 , object);
 214         *pSwapChain = NULL;
 215     }else{
 216         *pSwapChain = (IDirect3DSwapChain8 *)object;
 217     }
 218     TRACE("(%p) returning %p\n", This, *pSwapChain);
 219     return hrc;
 220 }
 221
 222 HRESULT WINAPI IDirect3DDevice8Impl_Reset(LPDIRECT3DDEVICE8 iface, D3DPRESENT_PARAMETERS* pPresentationParameters) {
 223     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 224     WINED3DPRESENT_PARAMETERS localParameters;
 225     TRACE("(%p) Relay pPresentationParameters(%p)\n", This, pPresentationParameters);
 226 /* FINDME: FIXME: */
 227     localParameters.BackBufferWidth                = &pPresentationParameters->BackBufferWidth;
 228     localParameters.BackBufferHeight               = &pPresentationParameters->BackBufferHeight;
 229     localParameters.BackBufferFormat               = (WINED3DFORMAT *)&pPresentationParameters->BackBufferFormat;
 230     localParameters.BackBufferCount                = &pPresentationParameters->BackBufferCount;
 231     localParameters.MultiSampleType                = (WINED3DMULTISAMPLE_TYPE *) &pPresentationParameters->MultiSampleType;
 232     localParameters.MultiSampleQuality             = NULL; /* D3d9 only */
 233     localParameters.SwapEffect                     = (WINED3DSWAPEFFECT *) &pPresentationParameters->SwapEffect;
 234     localParameters.hDeviceWindow                  = &pPresentationParameters->hDeviceWindow;
 235     localParameters.Windowed                       = &pPresentationParameters->Windowed;
 236     localParameters.EnableAutoDepthStencil         = &pPresentationParameters->EnableAutoDepthStencil;
 237     localParameters.AutoDepthStencilFormat         = (WINED3DFORMAT *)&pPresentationParameters->AutoDepthStencilFormat;
 238     localParameters.Flags                          = &pPresentationParameters->Flags;
 239     localParameters.FullScreen_RefreshRateInHz     = &pPresentationParameters->FullScreen_RefreshRateInHz;
 240     localParameters.PresentationInterval           = &pPresentationParameters->FullScreen_PresentationInterval;
 241     return IWineD3DDevice_Reset(This->WineD3DDevice, &localParameters);
 242 }
 243
 244 HRESULT WINAPI IDirect3DDevice8Impl_Present(LPDIRECT3DDEVICE8 iface, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) {
 245     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 246     TRACE("(%p) Relay\n", This);
 247     return IWineD3DDevice_Present(This->WineD3DDevice, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
 248 }
 249
 250 HRESULT WINAPI IDirect3DDevice8Impl_GetBackBuffer(LPDIRECT3DDEVICE8 iface, UINT BackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface8** ppBackBuffer) {
 251     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 252     IWineD3DSurface *retSurface = NULL;
 253     HRESULT rc = D3D_OK;
 254
 255     TRACE("(%p) Relay\n", This);
 256
 257     rc = IWineD3DDevice_GetBackBuffer(This->WineD3DDevice, 0, BackBuffer, Type, (IWineD3DSurface **)&retSurface);
 258     if (rc == D3D_OK && NULL != retSurface && NULL != ppBackBuffer) {
 259         IWineD3DSurface_GetParent(retSurface, (IUnknown **)ppBackBuffer);
 260         IWineD3DSurface_Release(retSurface);
 261     }
 262     return rc;
 263 }
 264
 265 HRESULT WINAPI IDirect3DDevice8Impl_GetRasterStatus(LPDIRECT3DDEVICE8 iface, D3DRASTER_STATUS* pRasterStatus) {
 266     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 267     TRACE("(%p) Relay\n", This);
 268
 269     return IWineD3DDevice_GetRasterStatus(This->WineD3DDevice, 0, pRasterStatus);
 270 }
 271
 272 void WINAPI IDirect3DDevice8Impl_SetGammaRamp(LPDIRECT3DDEVICE8 iface, DWORD Flags, CONST D3DGAMMARAMP* pRamp) {
 273     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 274     TRACE("(%p) Relay\n", This);
 275
 276     return IWineD3DDevice_SetGammaRamp(This->WineD3DDevice, 0, Flags, pRamp);
 277 }
 278
 279 void WINAPI IDirect3DDevice8Impl_GetGammaRamp(LPDIRECT3DDEVICE8 iface, D3DGAMMARAMP* pRamp) {
 280     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 281     TRACE("(%p) Relay\n", This);
 282
 283     return IWineD3DDevice_GetGammaRamp(This->WineD3DDevice, 0, pRamp);
 284 }
 285
 286 HRESULT WINAPI IDirect3DDevice8Impl_CreateTexture(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, UINT Levels, DWORD Usage,
 287                                                     D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture8 **ppTexture) {
 288     IDirect3DTexture8Impl *object;
 289     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 290     HRESULT hrc = D3D_OK;
 291
 292     TRACE("(%p) : W(%d) H(%d), Lvl(%d) d(%ld), Fmt(%u), Pool(%d)\n", This, Width, Height, Levels, Usage, Format,  Pool);
 293
 294     /* Allocate the storage for the device */
 295     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DTexture8Impl));
 296
 297     if (NULL == object) {
 298         FIXME("Allocation of memory failed\n");
 299 /*        *ppTexture = NULL; */
 300         return D3DERR_OUTOFVIDEOMEMORY;
 301     }
 302
 303     object->lpVtbl = &Direct3DTexture8_Vtbl;
 304     object->ref = 1;
 305     hrc = IWineD3DDevice_CreateTexture(This->WineD3DDevice, Width, Height, Levels, Usage,
 306                                  (WINED3DFORMAT)Format, (WINED3DPOOL) Pool, &object->wineD3DTexture, NULL, (IUnknown *)object, D3D8CB_CreateSurface);
 307
 308     if (FAILED(hrc)) {
 309         /* free up object */
 310         FIXME("(%p) call to IWineD3DDevice_CreateTexture failed\n", This);
 311         HeapFree(GetProcessHeap(), 0, object);
 312 /*      *ppTexture = NULL; */
 313    } else {
 314         *ppTexture = (LPDIRECT3DTEXTURE8) object;
 315    }
 316
 317    TRACE("(%p) Created Texture %p, %p\n",This,object,object->wineD3DTexture);
 318    return hrc;
 319 }
 320
 321 HRESULT WINAPI IDirect3DDevice8Impl_CreateVolumeTexture(LPDIRECT3DDEVICE8 iface,
 322                                                           UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage,
 323                                                           D3DFORMAT Format, D3DPOOL Pool, IDirect3DVolumeTexture8** ppVolumeTexture) {
 324
 325     IDirect3DVolumeTexture8Impl *object;
 326     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 327     HRESULT hrc = D3D_OK;
 328
 329     TRACE("(%p) Relay\n", This);
 330
 331     /* Allocate the storage for the device */
 332     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVolumeTexture8Impl));
 333     if (NULL == object) {
 334         FIXME("(%p) allocation of memory failed\n", This);
 335         *ppVolumeTexture = NULL;
 336         return D3DERR_OUTOFVIDEOMEMORY;
 337     }
 338
 339     object->lpVtbl = &Direct3DVolumeTexture8_Vtbl;
 340     object->ref = 1;
 341     hrc = IWineD3DDevice_CreateVolumeTexture(This->WineD3DDevice, Width, Height, Depth, Levels, Usage,
 342                                  (WINED3DFORMAT)Format, (WINED3DPOOL) Pool, &object->wineD3DVolumeTexture, NULL,
 343                                  (IUnknown *)object, D3D8CB_CreateVolume);
 344
 345     if (hrc != D3D_OK) {
 346
 347         /* free up object */
 348         FIXME("(%p) call to IWineD3DDevice_CreateVolumeTexture failed\n", This);
 349         HeapFree(GetProcessHeap(), 0, object);
 350         *ppVolumeTexture = NULL;
 351     } else {
 352         *ppVolumeTexture = (LPDIRECT3DVOLUMETEXTURE8) object;
 353     }
 354     TRACE("(%p)  returning %p\n", This , *ppVolumeTexture);
 355     return hrc;
 356 }
 357
 358 HRESULT WINAPI IDirect3DDevice8Impl_CreateCubeTexture(LPDIRECT3DDEVICE8 iface, UINT EdgeLength, UINT Levels, DWORD Usage,
 359                                                         D3DFORMAT Format, D3DPOOL Pool, IDirect3DCubeTexture8** ppCubeTexture) {
 360
 361     IDirect3DCubeTexture8Impl *object;
 362     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 363     HRESULT hr = D3D_OK;
 364
 365     TRACE("(%p) : ELen(%d) Lvl(%d) Usage(%ld) fmt(%u), Pool(%d)\n" , This, EdgeLength, Levels, Usage, Format, Pool);
 366
 367     /* Allocate the storage for the device */
 368     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 369
 370     if (NULL == object) {
 371         FIXME("(%p) allocation of CubeTexture failed\n", This);
 372         *ppCubeTexture = NULL;
 373         return D3DERR_OUTOFVIDEOMEMORY;
 374     }
 375
 376     object->lpVtbl = &Direct3DCubeTexture8_Vtbl;
 377     object->ref = 1;
 378     hr = IWineD3DDevice_CreateCubeTexture(This->WineD3DDevice, EdgeLength, Levels, Usage,
 379                                  (WINED3DFORMAT)Format, (WINED3DPOOL) Pool, &object->wineD3DCubeTexture, NULL, (IUnknown*)object,
 380                                  D3D8CB_CreateSurface);
 381
 382     if (hr != D3D_OK){
 383
 384         /* free up object */
 385         FIXME("(%p) call to IWineD3DDevice_CreateCubeTexture failed\n", This);
 386         HeapFree(GetProcessHeap(), 0, object);
 387         *ppCubeTexture = NULL;
 388     } else {
 389         *ppCubeTexture = (LPDIRECT3DCUBETEXTURE8) object;
 390     }
 391
 392     TRACE("(%p) returning %p\n",This, *ppCubeTexture);
 393     return hr;
 394 }
 395
 396 HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexBuffer(LPDIRECT3DDEVICE8 iface, UINT Size, DWORD Usage, DWORD FVF, D3DPOOL Pool, IDirect3DVertexBuffer8** ppVertexBuffer) {
 397     IDirect3DVertexBuffer8Impl *object;
 398     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 399     HRESULT hrc = D3D_OK;
 400
 401     TRACE("(%p) Relay\n", This);
 402     /* Allocate the storage for the device */
 403     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DVertexBuffer8Impl));
 404     if (NULL == object) {
 405         FIXME("Allocation of memory failed\n");
 406         *ppVertexBuffer = NULL;
 407         return D3DERR_OUTOFVIDEOMEMORY;
 408     }
 409
 410     object->lpVtbl = &Direct3DVertexBuffer8_Vtbl;
 411     object->ref = 1;
 412     hrc = IWineD3DDevice_CreateVertexBuffer(This->WineD3DDevice, Size, Usage, FVF, (WINED3DPOOL) Pool, &(object->wineD3DVertexBuffer), NULL, (IUnknown *)object);
 413
 414     if (D3D_OK != hrc) {
 415
 416         /* free up object */
 417         FIXME("(%p) call to IWineD3DDevice_CreateVertexBuffer failed\n", This);
 418         HeapFree(GetProcessHeap(), 0, object);
 419         *ppVertexBuffer = NULL;
 420     } else {
 421         *ppVertexBuffer = (LPDIRECT3DVERTEXBUFFER8) object;
 422     }
 423     return hrc;
 424 }
 425
 426 HRESULT WINAPI IDirect3DDevice8Impl_CreateIndexBuffer(LPDIRECT3DDEVICE8 iface, UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DIndexBuffer8** ppIndexBuffer) {
 427     IDirect3DIndexBuffer8Impl *object;
 428     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 429     HRESULT hrc = D3D_OK;
 430
 431     TRACE("(%p) Relay\n", This);
 432     /* Allocate the storage for the device */
 433     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 434     if (NULL == object) {
 435         FIXME("Allocation of memory failed\n");
 436         *ppIndexBuffer = NULL;
 437         return D3DERR_OUTOFVIDEOMEMORY;
 438     }
 439
 440     object->lpVtbl = &Direct3DIndexBuffer8_Vtbl;
 441     object->ref = 1;
 442     TRACE("Calling wined3d create index buffer\n");
 443     hrc = IWineD3DDevice_CreateIndexBuffer(This->WineD3DDevice, Length, Usage, Format, (WINED3DPOOL) Pool, &object->wineD3DIndexBuffer, NULL, (IUnknown *)object);
 444
 445     if (D3D_OK != hrc) {
 446
 447         /* free up object */
 448         FIXME("(%p) call to IWineD3DDevice_CreateIndexBuffer failed\n", This);
 449         HeapFree(GetProcessHeap(), 0, object);
 450         *ppIndexBuffer = NULL;
 451     } else {
 452         *ppIndexBuffer = (LPDIRECT3DINDEXBUFFER8)object;
 453     }
 454     return hrc;
 455 }
 456
 457 HRESULT WINAPI IDirect3DDevice8Impl_CreateSurface(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IDirect3DSurface8 **ppSurface,D3DRESOURCETYPE Type, UINT Usage,D3DPOOL Pool, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality)  {
 458     HRESULT hrc;
 459     IDirect3DSurface8Impl *object;
 460     IDirect3DDevice8Impl  *This = (IDirect3DDevice8Impl *)iface;
 461     TRACE("(%p) Relay\n", This);
 462     if(MultisampleQuality < 0) {
 463         FIXME("MultisampleQuality out of range %ld, substituting 0\n", MultisampleQuality);
 464         /*FIXME: Find out what windows does with a MultisampleQuality < 0 */
 465         MultisampleQuality=0;
 466     }
 467
 468     if(MultisampleQuality > 0){
 469         FIXME("MultisampleQuality set to %ld, substituting 0\n" , MultisampleQuality);
 470         /*
 471         MultisampleQuality
 472         [in] Quality level. The valid range is between zero and one less than the level returned by pQualityLevels used by IDirect3D8::CheckDeviceMultiSampleType. Passing a larger value returns the error D3DERR_INVALIDCALL. The MultisampleQuality values of paired render targets, depth stencil surfaces, and the MultiSample type must all match.
 473         */
 474         MultisampleQuality=0;
 475     }
 476     /*FIXME: Check MAX bounds of MultisampleQuality*/
 477
 478     /* Allocate the storage for the device */
 479     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DSurface8Impl));
 480     if (NULL == object) {
 481         FIXME("Allocation of memory failed\n");
 482         *ppSurface = NULL;
 483         return D3DERR_OUTOFVIDEOMEMORY;
 484     }
 485
 486     object->lpVtbl = &Direct3DSurface8_Vtbl;
 487     object->ref = 1;
 488
 489     TRACE("(%p) : w(%d) h(%d) fmt(%d) surf@%p\n", This, Width, Height, Format, *ppSurface);
 490
 491     hrc = IWineD3DDevice_CreateSurface(This->WineD3DDevice, Width, Height, Format, Lockable, Discard, Level,  &object->wineD3DSurface, Type, Usage, (WINED3DPOOL) Pool,MultiSample,MultisampleQuality, NULL,(IUnknown *)object);
 492     if (hrc != D3D_OK || NULL == object->wineD3DSurface) {
 493        /* free up object */
 494         FIXME("(%p) call to IWineD3DDevice_CreateSurface failed\n", This);
 495         HeapFree(GetProcessHeap(), 0, object);
 496         *ppSurface = NULL;
 497     } else {
 498         *ppSurface = (LPDIRECT3DSURFACE8) object;
 499     }
 500     return hrc;
 501 }
 502
 503 HRESULT WINAPI IDirect3DDevice8Impl_CreateRenderTarget(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, BOOL Lockable, IDirect3DSurface8** ppSurface) {
 504     TRACE("Relay\n");
 505
 506     return IDirect3DDevice8Impl_CreateSurface(iface, Width, Height, Format, Lockable, FALSE /* Discard */, 0 /* Level */ , ppSurface, D3DRTYPE_SURFACE, D3DUSAGE_RENDERTARGET, D3DPOOL_DEFAULT, MultiSample, 0);
 507 }
 508
 509 HRESULT WINAPI IDirect3DDevice8Impl_CreateDepthStencilSurface(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, IDirect3DSurface8** ppSurface) {
 510     TRACE("Relay\n");
 511     /* TODO: Verify that Discard is false */
 512     return IDirect3DDevice8Impl_CreateSurface(iface, Width, Height, Format, TRUE /* Lockable */, FALSE, 0 /* Level */
 513                                                ,ppSurface, D3DRTYPE_SURFACE, D3DUSAGE_DEPTHSTENCIL,
 514                                                 D3DPOOL_DEFAULT, MultiSample, 0);
 515 }
 516
 517 HRESULT WINAPI IDirect3DDevice8Impl_CreateImageSurface(LPDIRECT3DDEVICE8 iface, UINT Width, UINT Height, D3DFORMAT Format, IDirect3DSurface8** ppSurface) {
 518     TRACE("Relay\n");
 519
 520     return IDirect3DDevice8Impl_CreateSurface(iface, Width, Height, Format, TRUE /* Loackable */ , FALSE /*Discard*/ , 0 /* Level */ , ppSurface, D3DRTYPE_SURFACE, 0 /* Usage (undefined/none) */ , D3DPOOL_SCRATCH, D3DMULTISAMPLE_NONE, 0 /* MultisampleQuality */);
 521 }
 522
 523 HRESULT WINAPI IDirect3DDevice8Impl_CopyRects(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8 *pSourceSurface, CONST RECT *pSourceRects, UINT cRects, IDirect3DSurface8 *pDestinationSurface, CONST POINT *pDestPoints) {
 524     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 525
 526     TRACE("(%p) Relay\n" , This);
 527
 528     return IWineD3DDevice_CopyRects(This->WineD3DDevice, pSourceSurface == NULL ? NULL : ((IDirect3DSurface8Impl *)pSourceSurface)->wineD3DSurface,
 529             pSourceRects, cRects, pDestinationSurface == NULL ? NULL : ((IDirect3DSurface8Impl *)pDestinationSurface)->wineD3DSurface, pDestPoints);
 530 }
 531
 532 HRESULT WINAPI IDirect3DDevice8Impl_UpdateTexture(LPDIRECT3DDEVICE8 iface, IDirect3DBaseTexture8* pSourceTexture, IDirect3DBaseTexture8* pDestinationTexture) {
 533     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 534     TRACE("(%p) Relay\n" , This);
 535
 536     return IWineD3DDevice_UpdateTexture(This->WineD3DDevice,  ((IDirect3DBaseTexture8Impl *)pSourceTexture)->wineD3DBaseTexture, ((IDirect3DBaseTexture8Impl *)pDestinationTexture)->wineD3DBaseTexture);
 537 }
 538
 539 HRESULT WINAPI IDirect3DDevice8Impl_GetFrontBuffer(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pDestSurface) {
 540     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 541     IDirect3DSurface8Impl *destSurface = (IDirect3DSurface8Impl *)pDestSurface;
 542
 543     TRACE("(%p) Relay\n" , This);
 544
 545     if (pDestSurface == NULL) {
 546         WARN("(%p) : Caller passed NULL as pDestSurface returning D3DERR_INVALIDCALL\n", This);
 547         return D3DERR_INVALIDCALL;
 548     }
 549
 550     return IWineD3DDevice_GetFrontBufferData(This->WineD3DDevice, 0, destSurface->wineD3DSurface);
 551 }
 552
 553 HRESULT WINAPI IDirect3DDevice8Impl_SetRenderTarget(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pRenderTarget, IDirect3DSurface8* pNewZStencil) {
 554     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 555     IDirect3DSurface8Impl *pSurface = (IDirect3DSurface8Impl *)pRenderTarget;
 556     IDirect3DSurface8Impl *pZSurface = (IDirect3DSurface8Impl *)pNewZStencil;
 557     TRACE("(%p) Relay\n" , This);
 558
 559     IWineD3DDevice_SetDepthStencilSurface(This->WineD3DDevice, NULL == pZSurface ? NULL : (IWineD3DSurface *)pZSurface->wineD3DSurface);
 560
 561     return IWineD3DDevice_SetRenderTarget(This->WineD3DDevice, 0, (IWineD3DSurface *)pSurface->wineD3DSurface);
 562 }
 563
 564 HRESULT  WINAPI  IDirect3DDevice8Impl_GetRenderTarget(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8** ppRenderTarget) {
 565     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 566     HRESULT hr = D3D_OK;
 567     IWineD3DSurface *pRenderTarget;
 568
 569     TRACE("(%p) Relay\n" , This);
 570
 571     if (ppRenderTarget == NULL) {
 572         return D3DERR_INVALIDCALL;
 573     }
 574     hr = IWineD3DDevice_GetRenderTarget(This->WineD3DDevice, 0, &pRenderTarget);
 575
 576     if (hr == D3D_OK && pRenderTarget != NULL) {
 577         IWineD3DResource_GetParent((IWineD3DResource *)pRenderTarget,(IUnknown**)ppRenderTarget);
 578         IWineD3DResource_Release((IWineD3DResource *)pRenderTarget);
 579     } else {
 580         FIXME("Call to IWineD3DDevice_GetRenderTarget failed\n");
 581         *ppRenderTarget = NULL;
 582     }
 583
 584     return hr;
 585 }
 586
 587 HRESULT  WINAPI  IDirect3DDevice8Impl_GetDepthStencilSurface(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8** ppZStencilSurface) {
 588     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 589     HRESULT hr = D3D_OK;
 590     IWineD3DSurface *pZStencilSurface;
 591
 592     TRACE("(%p) Relay\n" , This);
 593     if(ppZStencilSurface == NULL){
 594         return D3DERR_INVALIDCALL;
 595     }
 596
 597     hr=IWineD3DDevice_GetDepthStencilSurface(This->WineD3DDevice,&pZStencilSurface);
 598     if(hr == D3D_OK && pZStencilSurface != NULL){
 599         IWineD3DResource_GetParent((IWineD3DResource *)pZStencilSurface,(IUnknown**)ppZStencilSurface);
 600         IWineD3DResource_Release((IWineD3DResource *)pZStencilSurface);
 601     }else{
 602         FIXME("Call to IWineD3DDevice_GetRenderTarget failed\n");
 603         *ppZStencilSurface = NULL;
 604     }
 605
 606     return D3D_OK;
 607 }
 608
 609 HRESULT WINAPI IDirect3DDevice8Impl_BeginScene(LPDIRECT3DDEVICE8 iface) {
 610     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 611     return IWineD3DDevice_BeginScene(This->WineD3DDevice);
 612 }
 613
 614 HRESULT WINAPI IDirect3DDevice8Impl_EndScene(LPDIRECT3DDEVICE8 iface) {
 615     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 616     TRACE("(%p) Relay\n" , This);
 617
 618     return IWineD3DDevice_EndScene(This->WineD3DDevice);
 619 }
 620
 621 HRESULT WINAPI IDirect3DDevice8Impl_Clear(LPDIRECT3DDEVICE8 iface, DWORD Count, CONST D3DRECT* pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil) {
 622     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 623     TRACE("(%p) Relay\n" , This);
 624
 625     return IWineD3DDevice_Clear(This->WineD3DDevice, Count, pRects, Flags, Color, Z, Stencil);
 626 }
 627
 628 HRESULT WINAPI IDirect3DDevice8Impl_SetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* lpMatrix) {
 629     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 630     TRACE("(%p) Relay\n" , This);
 631
 632     return IWineD3DDevice_SetTransform(This->WineD3DDevice, State, lpMatrix);
 633 }
 634
 635 HRESULT WINAPI IDirect3DDevice8Impl_GetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix) {
 636     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 637     TRACE("(%p) Relay\n" , This);
 638
 639     return IWineD3DDevice_GetTransform(This->WineD3DDevice, State, pMatrix);
 640 }
 641
 642 HRESULT WINAPI IDirect3DDevice8Impl_MultiplyTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix) {
 643     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 644     TRACE("(%p) Relay\n" , This);
 645
 646     return IWineD3DDevice_MultiplyTransform(This->WineD3DDevice, State, pMatrix);
 647 }
 648
 649 HRESULT WINAPI IDirect3DDevice8Impl_SetViewport(LPDIRECT3DDEVICE8 iface, CONST D3DVIEWPORT8* pViewport) {
 650     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 651     TRACE("(%p) Relay\n" , This);
 652
 653     return IWineD3DDevice_SetViewport(This->WineD3DDevice, (const WINED3DVIEWPORT *)pViewport);
 654 }
 655
 656 HRESULT WINAPI IDirect3DDevice8Impl_GetViewport(LPDIRECT3DDEVICE8 iface, D3DVIEWPORT8* pViewport) {
 657     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 658     TRACE("(%p) Relay\n" , This);
 659
 660     return IWineD3DDevice_GetViewport(This->WineD3DDevice, (WINED3DVIEWPORT *)pViewport);
 661 }
 662
 663 HRESULT WINAPI IDirect3DDevice8Impl_SetMaterial(LPDIRECT3DDEVICE8 iface, CONST D3DMATERIAL8* pMaterial) {
 664     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 665     TRACE("(%p) Relay\n" , This);
 666 /* FIXME: Verify that D3DMATERIAL8 ~= WINED3DMATERIAL */
 667     return IWineD3DDevice_SetMaterial(This->WineD3DDevice, (const WINED3DMATERIAL *)pMaterial);
 668 }
 669
 670 HRESULT WINAPI IDirect3DDevice8Impl_GetMaterial(LPDIRECT3DDEVICE8 iface, D3DMATERIAL8* pMaterial) {
 671     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 672     TRACE("(%p) Relay\n" , This);
 673 /* FIXME: Verify that D3DMATERIAL8 ~= WINED3DMATERIAL */
 674     return IWineD3DDevice_GetMaterial(This->WineD3DDevice, (WINED3DMATERIAL *)pMaterial);
 675 }
 676
 677 HRESULT WINAPI IDirect3DDevice8Impl_SetLight(LPDIRECT3DDEVICE8 iface, DWORD Index, CONST D3DLIGHT8* pLight) {
 678     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 679     TRACE("(%p) Relay\n" , This);
 680 /* FIXME: Verify that D3DLIGHT8 ~= WINED3DLIGHT */
 681     return IWineD3DDevice_SetLight(This->WineD3DDevice, Index, (const WINED3DLIGHT *)pLight);
 682 }
 683
 684 HRESULT WINAPI IDirect3DDevice8Impl_GetLight(LPDIRECT3DDEVICE8 iface, DWORD Index,D3DLIGHT8* pLight) {
 685     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 686     TRACE("(%p) Relay\n" , This);
 687 /* FIXME: Verify that D3DLIGHT8 ~= WINED3DLIGHT */
 688     return IWineD3DDevice_GetLight(This->WineD3DDevice, Index, (WINED3DLIGHT *)pLight);
 689 }
 690
 691 HRESULT WINAPI IDirect3DDevice8Impl_LightEnable(LPDIRECT3DDEVICE8 iface, DWORD Index,BOOL Enable) {
 692     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 693     TRACE("(%p) Relay\n" , This);
 694
 695     return IWineD3DDevice_SetLightEnable(This->WineD3DDevice, Index, Enable);
 696 }
 697
 698 HRESULT WINAPI IDirect3DDevice8Impl_GetLightEnable(LPDIRECT3DDEVICE8 iface, DWORD Index,BOOL* pEnable) {
 699     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 700     TRACE("(%p) Relay\n" , This);
 701
 702     return IWineD3DDevice_GetLightEnable(This->WineD3DDevice, Index, pEnable);
 703 }
 704
 705 HRESULT WINAPI IDirect3DDevice8Impl_SetClipPlane(LPDIRECT3DDEVICE8 iface, DWORD Index,CONST float* pPlane) {
 706     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 707     TRACE("(%p) Relay\n" , This);
 708
 709     return IWineD3DDevice_SetClipPlane(This->WineD3DDevice, Index, pPlane);
 710 }
 711
 712 HRESULT WINAPI IDirect3DDevice8Impl_GetClipPlane(LPDIRECT3DDEVICE8 iface, DWORD Index,float* pPlane) {
 713     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 714     TRACE("(%p) Relay\n" , This);
 715
 716     return IWineD3DDevice_GetClipPlane(This->WineD3DDevice, Index, pPlane);
 717 }
 718
 719 HRESULT WINAPI IDirect3DDevice8Impl_SetRenderState(LPDIRECT3DDEVICE8 iface, D3DRENDERSTATETYPE State,DWORD Value) {
 720     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 721     TRACE("(%p) Relay\n" , This);
 722
 723     return IWineD3DDevice_SetRenderState(This->WineD3DDevice, State, Value);
 724 }
 725
 726 HRESULT WINAPI IDirect3DDevice8Impl_GetRenderState(LPDIRECT3DDEVICE8 iface, D3DRENDERSTATETYPE State,DWORD* pValue) {
 727     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 728     TRACE("(%p) Relay\n" , This);
 729
 730     return IWineD3DDevice_GetRenderState(This->WineD3DDevice, State, pValue);
 731 }
 732
 733 HRESULT WINAPI IDirect3DDevice8Impl_BeginStateBlock(LPDIRECT3DDEVICE8 iface) {
 734   IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 735
 736   TRACE("(%p)\n", This);
 737
 738   return IWineD3DDevice_BeginStateBlock(This->WineD3DDevice);
 739 }
 740
 741 HRESULT WINAPI IDirect3DDevice8Impl_EndStateBlock(LPDIRECT3DDEVICE8 iface, DWORD* pToken) {
 742     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 743     HRESULT hr;
 744     IWineD3DStateBlock* wineD3DStateBlock;
 745     IDirect3DStateBlock8Impl* object;
 746
 747     TRACE("(%p) Relay\n", This);
 748
 749     /* Tell wineD3D to endstatablock before anything else (in case we run out
 750      * of memory later and cause locking problems)
 751      */
 752     hr = IWineD3DDevice_EndStateBlock(This->WineD3DDevice , &wineD3DStateBlock);
 753     if (hr != D3D_OK) {
 754        FIXME("IWineD3DDevice_EndStateBlock returned an error\n");
 755        return hr;
 756     }
 757
 758     /* allocate a new IDirectD3DStateBlock */
 759     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY ,sizeof(IDirect3DStateBlock8Impl));
 760     object->ref = 1;
 761     object->lpVtbl = &Direct3DStateBlock8_Vtbl;
 762
 763     object->wineD3DStateBlock = wineD3DStateBlock;
 764
 765     *pToken = (DWORD)object;
 766     TRACE("(%p)Returning %p %p\n", This, object, wineD3DStateBlock);
 767
 768     return hr;
 769 }
 770
 771 HRESULT WINAPI IDirect3DDevice8Impl_ApplyStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token) {
 772     IDirect3DStateBlock8Impl *pSB  = (IDirect3DStateBlock8Impl*) Token;
 773     IDirect3DDevice8Impl     *This = (IDirect3DDevice8Impl *)iface;
 774
 775     TRACE("(%p) %p Relay\n", This, pSB);
 776
 777     return  IWineD3DStateBlock_Apply(pSB->wineD3DStateBlock);
 778 }
 779
 780 HRESULT WINAPI IDirect3DDevice8Impl_CaptureStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token) {
 781     IDirect3DStateBlock8Impl* pSB = (IDirect3DStateBlock8Impl *)Token;
 782     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 783
 784     TRACE("(%p) %p Relay\n", This, pSB);
 785
 786     return IWineD3DStateBlock_Capture(pSB->wineD3DStateBlock);
 787 }
 788
 789 HRESULT WINAPI IDirect3DDevice8Impl_DeleteStateBlock(LPDIRECT3DDEVICE8 iface, DWORD Token) {
 790     IDirect3DStateBlock8Impl* pSB = (IDirect3DStateBlock8Impl *)Token;
 791     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 792
 793     TRACE("(%p) Relay\n", This);
 794
 795     while(IUnknown_Release((IUnknown *)pSB));
 796
 797     return D3D_OK;
 798 }
 799
 800 HRESULT WINAPI IDirect3DDevice8Impl_CreateStateBlock(LPDIRECT3DDEVICE8 iface, D3DSTATEBLOCKTYPE Type, DWORD* pToken) {
 801    IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 802    IDirect3DStateBlock8Impl *object;
 803    HRESULT hrc = D3D_OK;
 804
 805    TRACE("(%p) Relay\n", This);
 806
 807    object  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DStateBlock8Impl));
 808    if (NULL == object) {
 809       FIXME("(%p)  Failed to allocate %d bytes\n", This, sizeof(IDirect3DStateBlock8Impl));
 810       *pToken = 0;
 811       return E_OUTOFMEMORY;
 812    }
 813    object->lpVtbl = &Direct3DStateBlock8_Vtbl;
 814    object->ref = 1;
 815
 816    hrc = IWineD3DDevice_CreateStateBlock(This->WineD3DDevice, (WINED3DSTATEBLOCKTYPE)Type, &object->wineD3DStateBlock, (IUnknown *)object);
 817    if(D3D_OK != hrc){
 818        FIXME("(%p) Call to IWineD3DDevice_CreateStateBlock failed.\n", This);
 819        HeapFree(GetProcessHeap(), 0, object);
 820        *pToken = 0;
 821    } else {
 822        *pToken = (DWORD)object;
 823    }
 824    TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, object);
 825
 826    return hrc;
 827 }
 828
 829 HRESULT WINAPI IDirect3DDevice8Impl_SetClipStatus(LPDIRECT3DDEVICE8 iface, CONST D3DCLIPSTATUS8* pClipStatus) {
 830     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 831     TRACE("(%p) Relay\n" , This);
 832 /* FIXME: Verify that D3DCLIPSTATUS8 ~= WINED3DCLIPSTATUS */
 833     return IWineD3DDevice_SetClipStatus(This->WineD3DDevice, (const WINED3DCLIPSTATUS *)pClipStatus);
 834 }
 835
 836 HRESULT WINAPI IDirect3DDevice8Impl_GetClipStatus(LPDIRECT3DDEVICE8 iface, D3DCLIPSTATUS8* pClipStatus) {
 837     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 838     TRACE("(%p) Relay\n" , This);
 839
 840     return IWineD3DDevice_GetClipStatus(This->WineD3DDevice, (WINED3DCLIPSTATUS *)pClipStatus);
 841 }
 842
 843 HRESULT WINAPI IDirect3DDevice8Impl_GetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage,IDirect3DBaseTexture8** ppTexture) {
 844     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 845     IWineD3DBaseTexture *retTexture = NULL;
 846     HRESULT rc = D3D_OK;
 847
 848     TRACE("(%p) Relay\n" , This);
 849
 850     if(ppTexture == NULL){
 851         return D3DERR_INVALIDCALL;
 852     }
 853
 854     rc = IWineD3DDevice_GetTexture(This->WineD3DDevice, Stage, (IWineD3DBaseTexture **)&retTexture);
 855     if (rc == D3D_OK && NULL != retTexture) {
 856         IWineD3DBaseTexture_GetParent(retTexture, (IUnknown **)ppTexture);
 857         IWineD3DBaseTexture_Release(retTexture);
 858     } else {
 859         FIXME("Call to get texture  (%ld) failed (%p)\n", Stage, retTexture);
 860         *ppTexture = NULL;
 861     }
 862
 863     return rc;
 864 }
 865
 866 HRESULT WINAPI IDirect3DDevice8Impl_SetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage, IDirect3DBaseTexture8* pTexture) {
 867     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 868     TRACE("(%p) Relay %ld %p\n" , This, Stage, pTexture);
 869
 870     return IWineD3DDevice_SetTexture(This->WineD3DDevice, Stage,
 871                                      pTexture==NULL ? NULL : ((IDirect3DBaseTexture8Impl *)pTexture)->wineD3DBaseTexture);
 872 }
 873
 874 HRESULT  WINAPI  IDirect3DDevice8Impl_GetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue) {
 875     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 876     TRACE("(%p) Relay\n" , This);
 877
 878     switch(Type) {
 879     case D3DTSS_ADDRESSU:
 880         Type = WINED3DSAMP_ADDRESSU;
 881         break;
 882     case D3DTSS_ADDRESSV:
 883         Type = WINED3DSAMP_ADDRESSV;
 884         break;
 885     case D3DTSS_ADDRESSW:
 886         Type = WINED3DSAMP_ADDRESSW;
 887         break;
 888     case D3DTSS_BORDERCOLOR:
 889         Type = WINED3DSAMP_BORDERCOLOR;
 890         break;
 891     case D3DTSS_MAGFILTER:
 892         Type = WINED3DSAMP_MAGFILTER;
 893         break;
 894     case D3DTSS_MAXANISOTROPY:
 895         Type = WINED3DSAMP_MAXANISOTROPY;
 896         break;
 897     case D3DTSS_MAXMIPLEVEL:
 898         Type = WINED3DSAMP_MAXMIPLEVEL;
 899         break;
 900     case D3DTSS_MINFILTER:
 901         Type = WINED3DSAMP_MINFILTER;
 902         break;
 903     case D3DTSS_MIPFILTER:
 904         Type = WINED3DSAMP_MIPFILTER;
 905         break;
 906     case D3DTSS_MIPMAPLODBIAS:
 907         Type = WINED3DSAMP_MIPMAPLODBIAS;
 908         break;
 909     default:
 910         return IWineD3DDevice_GetTextureStageState(This->WineD3DDevice, Stage, Type, pValue);
 911     }
 912
 913     return IWineD3DDevice_GetSamplerState(This->WineD3DDevice, Stage, Type, pValue);
 914 }
 915
 916 HRESULT WINAPI IDirect3DDevice8Impl_SetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value) {
 917     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 918     TRACE("(%p) Relay\n" , This);
 919
 920     switch(Type) {
 921     case D3DTSS_ADDRESSU:
 922         Type = WINED3DSAMP_ADDRESSU;
 923         break;
 924     case D3DTSS_ADDRESSV:
 925         Type = WINED3DSAMP_ADDRESSV;
 926         break;
 927     case D3DTSS_ADDRESSW:
 928         Type = WINED3DSAMP_ADDRESSW;
 929         break;
 930     case D3DTSS_BORDERCOLOR:
 931         Type = WINED3DSAMP_BORDERCOLOR;
 932         break;
 933     case D3DTSS_MAGFILTER:
 934         Type = WINED3DSAMP_MAGFILTER;
 935         break;
 936     case D3DTSS_MAXANISOTROPY:
 937         Type = WINED3DSAMP_MAXANISOTROPY;
 938         break;
 939     case D3DTSS_MAXMIPLEVEL:
 940         Type = WINED3DSAMP_MAXMIPLEVEL;
 941         break;
 942     case D3DTSS_MINFILTER:
 943         Type = WINED3DSAMP_MINFILTER;
 944         break;
 945     case D3DTSS_MIPFILTER:
 946         Type = WINED3DSAMP_MIPFILTER;
 947         break;
 948     case D3DTSS_MIPMAPLODBIAS:
 949         Type = WINED3DSAMP_MIPMAPLODBIAS;
 950         break;
 951     default:
 952         return IWineD3DDevice_SetTextureStageState(This->WineD3DDevice, Stage, Type, Value);
 953     }
 954
 955     return IWineD3DDevice_SetSamplerState(This->WineD3DDevice, Stage, Type, Value);
 956 }
 957
 958 HRESULT WINAPI IDirect3DDevice8Impl_ValidateDevice(LPDIRECT3DDEVICE8 iface, DWORD* pNumPasses) {
 959     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 960     TRACE("(%p) Relay\n" , This);
 961
 962     return IWineD3DDevice_ValidateDevice(This->WineD3DDevice, pNumPasses);
 963 }
 964
 965 HRESULT WINAPI IDirect3DDevice8Impl_GetInfo(LPDIRECT3DDEVICE8 iface, DWORD DevInfoID, void* pDevInfoStruct, DWORD DevInfoStructSize) {
 966     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 967     FIXME("(%p) : stub\n", This);
 968     return D3D_OK;
 969 }
 970
 971 HRESULT WINAPI IDirect3DDevice8Impl_SetPaletteEntries(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber, CONST PALETTEENTRY* pEntries) {
 972     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 973     TRACE("(%p) Relay\n" , This);
 974
 975     return IWineD3DDevice_SetPaletteEntries(This->WineD3DDevice, PaletteNumber, pEntries);
 976 }
 977
 978 HRESULT WINAPI IDirect3DDevice8Impl_GetPaletteEntries(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber, PALETTEENTRY* pEntries) {
 979     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 980     TRACE("(%p) Relay\n" , This);
 981
 982     return IWineD3DDevice_GetPaletteEntries(This->WineD3DDevice, PaletteNumber, pEntries);
 983 }
 984
 985 HRESULT WINAPI IDirect3DDevice8Impl_SetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface, UINT PaletteNumber) {
 986     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 987     TRACE("(%p) Relay\n" , This);
 988
 989     return IWineD3DDevice_SetCurrentTexturePalette(This->WineD3DDevice, PaletteNumber);
 990 }
 991
 992 HRESULT  WINAPI  IDirect3DDevice8Impl_GetCurrentTexturePalette(LPDIRECT3DDEVICE8 iface, UINT *PaletteNumber) {
 993     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
 994     TRACE("(%p) Relay\n" , This);
 995
 996     return IWineD3DDevice_GetCurrentTexturePalette(This->WineD3DDevice, PaletteNumber);
 997 }
 998
 999 HRESULT WINAPI IDirect3DDevice8Impl_DrawPrimitive(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) {
1000     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1001     TRACE("(%p) Relay\n" , This);
1002
1003     return IWineD3DDevice_DrawPrimitive(This->WineD3DDevice, PrimitiveType, StartVertex, PrimitiveCount);
1004 }
1005
1006 HRESULT WINAPI IDirect3DDevice8Impl_DrawIndexedPrimitive(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,
1007                                                            UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount) {
1008     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1009     TRACE("(%p) Relay\n" , This);
1010
1011     return IWineD3DDevice_DrawIndexedPrimitive(This->WineD3DDevice, PrimitiveType, This->baseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
1012 }
1013
1014 HRESULT WINAPI IDirect3DDevice8Impl_DrawPrimitiveUP(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride) {
1015     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1016     TRACE("(%p) Relay\n" , This);
1017
1018     return IWineD3DDevice_DrawPrimitiveUP(This->WineD3DDevice, PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
1019 }
1020
1021 HRESULT WINAPI IDirect3DDevice8Impl_DrawIndexedPrimitiveUP(LPDIRECT3DDEVICE8 iface, D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,
1022                                                              UINT NumVertexIndices,UINT PrimitiveCount,CONST void* pIndexData,
1023                                                              D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,
1024                                                              UINT VertexStreamZeroStride) {
1025     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1026     TRACE("(%p) Relay\n" , This);
1027
1028     return IWineD3DDevice_DrawIndexedPrimitiveUP(This->WineD3DDevice, PrimitiveType, MinVertexIndex, NumVertexIndices, PrimitiveCount,
1029                                                  pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride);
1030 }
1031
1032 HRESULT WINAPI IDirect3DDevice8Impl_ProcessVertices(LPDIRECT3DDEVICE8 iface, UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8* pDestBuffer,DWORD Flags) {
1033     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1034     TRACE("(%p) Relay\n" , This);
1035
1036     return IWineD3DDevice_ProcessVertices(This->WineD3DDevice,SrcStartIndex, DestIndex, VertexCount, ((IDirect3DVertexBuffer8Impl *)pDestBuffer)->wineD3DVertexBuffer, NULL, Flags);
1037 }
1038
1039 HRESULT WINAPI IDirect3DDevice8Impl_CreateVertexShader(LPDIRECT3DDEVICE8 iface, CONST DWORD* pDeclaration, CONST DWORD* pFunction, DWORD* ppShader, DWORD Usage) {
1040     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1041     HRESULT hrc = D3D_OK;
1042     IDirect3DVertexShader8Impl *object;
1043
1044     /* Setup a stub object for now */
1045     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1046     TRACE("(%p) : pFunction(%p), ppShader(%p)\n", This, pFunction, ppShader);
1047     if (NULL == object) {
1048         FIXME("Allocation of memory failed\n");
1049         *ppShader = 0;
1050         return D3DERR_OUTOFVIDEOMEMORY;
1051     }
1052
1053     object->ref = 1;
1054     object->lpVtbl = &Direct3DVertexShader8_Vtbl;
1055     /* Usage is missing ..*/
1056     hrc = IWineD3DDevice_CreateVertexShader(This->WineD3DDevice, pDeclaration, pFunction, &object->wineD3DVertexShader, (IUnknown *)object);
1057
1058     if (FAILED(hrc)) {
1059         /* free up object */
1060         FIXME("Call to IWineD3DDevice_CreateVertexShader failed\n");
1061         HeapFree(GetProcessHeap(), 0, object);
1062         *ppShader = 0;
1063     } else {
1064         /* TODO: Store the VS declarations locally so that they can be derefferenced with a value higher than VS_HIGHESTFIXEDFXF */
1065         DWORD i = 0;
1066         while(This->vShaders[i] != NULL && i < MAX_SHADERS) ++i;
1067         if (MAX_SHADERS == i) {
1068             FIXME("(%p) : Number of shaders exceeds the maximum number of possible shaders\n", This);
1069             hrc = E_OUTOFMEMORY;
1070         } else {
1071             This->vShaders[i] = object;
1072             *ppShader = i + VS_HIGHESTFIXEDFXF + 1;
1073         }
1074     }
1075     TRACE("(%p) : returning %p\n", This, object);
1076
1077     return hrc;
1078 }
1079
1080 HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD pShader) {
1081     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1082     HRESULT hrc = D3D_OK;
1083
1084     TRACE("(%p) : Relay\n", This);
1085     if (VS_HIGHESTFIXEDFXF >= pShader) {
1086         TRACE("Setting FVF, %d %ld\n", VS_HIGHESTFIXEDFXF, pShader);
1087         IWineD3DDevice_SetFVF(This->WineD3DDevice, pShader);
1088
1089         /* Call SetVertexShader with a NULL shader to set the vertexshader in the stateblock to NULL. */
1090         IWineD3DDevice_SetVertexShader(This->WineD3DDevice, NULL);
1091     } else {
1092         TRACE("Setting shader\n");
1093         if (MAX_SHADERS <= pShader - (VS_HIGHESTFIXEDFXF + 1)) {
1094             FIXME("(%p) : Number of shaders exceeds the maximum number of possible shaders\n", This);
1095             hrc = D3DERR_INVALIDCALL;
1096         } else {
1097             IDirect3DVertexShader8Impl *shader = This->vShaders[pShader - (VS_HIGHESTFIXEDFXF + 1)];
1098             hrc =  IWineD3DDevice_SetVertexShader(This->WineD3DDevice, 0 == shader ? NULL : shader->wineD3DVertexShader);
1099         }
1100     }
1101     TRACE("(%p) : returning hr(%lu)\n", This, hrc);
1102
1103     return hrc;
1104 }
1105
1106 HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD* ppShader) {
1107     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1108     IWineD3DVertexShader *pShader;
1109     HRESULT hrc = D3D_OK;
1110
1111     TRACE("(%p) : Relay  device@%p\n", This, This->WineD3DDevice);
1112     hrc = IWineD3DDevice_GetVertexShader(This->WineD3DDevice, &pShader);
1113     if (D3D_OK == hrc) {
1114         if(0 != pShader) {
1115             DWORD i = 0;
1116             hrc = IWineD3DVertexShader_GetParent(pShader, (IUnknown **)ppShader);
1117             IWineD3DVertexShader_Release(pShader);
1118             while(This->vShaders[i] != (IDirect3DVertexShader8Impl *)ppShader && i < MAX_SHADERS) ++i;
1119             if (i < MAX_SHADERS) {
1120                 *ppShader = i + VS_HIGHESTFIXEDFXF + 1;
1121             } else {
1122                 WARN("(%p) : Couldn't find math for shader %p in d3d7 shadres list\n", This, (IDirect3DVertexShader8Impl *)ppShader);
1123                 *ppShader = 0;
1124             }
1125         } else {
1126             WARN("(%p) : The shader has been set to NULL\n", This);
1127
1128             /* TODO: Find out what should be returned, e.g. the FVF */
1129             *ppShader = 0;
1130             hrc = D3DERR_INVALIDCALL;
1131         }
1132     } else {
1133         WARN("(%p) : Call to IWineD3DDevice_GetVertexShader failed %lu (device %p)\n", This, hrc, This->WineD3DDevice);
1134     }
1135     TRACE("(%p) : returning %p\n", This, (IDirect3DVertexShader8 *)*ppShader);
1136
1137     return hrc;
1138 }
1139
1140 HRESULT  WINAPI  IDirect3DDevice8Impl_DeleteVertexShader(LPDIRECT3DDEVICE8 iface, DWORD pShader) {
1141     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1142     HRESULT hrc = D3D_OK;
1143     TRACE("(%p) Relay\n", This);
1144     if (pShader <= VS_HIGHESTFIXEDFXF) {
1145         WARN("(%p) : Caller passed a shader below the value of VS_HIGHESTFIXEDFXF\n", This);
1146         hrc = D3DERR_INVALIDCALL;
1147     } else if (MAX_SHADERS <= pShader - (VS_HIGHESTFIXEDFXF + 1)) {
1148         FIXME("(%p) : Caller passed a shader greater than the maximum number of shaders\n", This);
1149         hrc = D3DERR_INVALIDCALL;
1150     } else {
1151         IDirect3DVertexShader8Impl *shader = This->vShaders[pShader - (VS_HIGHESTFIXEDFXF + 1)];
1152         while(IUnknown_Release((IUnknown *)shader));
1153         This->vShaders[pShader - (VS_HIGHESTFIXEDFXF + 1)] = NULL;
1154         hrc = D3D_OK;
1155     }
1156
1157     return hrc;
1158 }
1159
1160 HRESULT WINAPI IDirect3DDevice8Impl_SetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, CONST void* pConstantData, DWORD ConstantCount) {
1161     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1162     TRACE("(%p) : Relay\n", This);
1163
1164     return IWineD3DDevice_SetVertexShaderConstantF(This->WineD3DDevice, Register, (CONST float *)pConstantData, ConstantCount);
1165 }
1166
1167 HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, void* pConstantData, DWORD ConstantCount) {
1168     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1169     TRACE("(%p) : Relay\n", This);
1170
1171     return IWineD3DDevice_GetVertexShaderConstantF(This->WineD3DDevice, Register, (float *)pConstantData, ConstantCount);
1172 }
1173
1174 HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderDeclaration(LPDIRECT3DDEVICE8 iface, DWORD pVertexShader, void* pData, DWORD* pSizeOfData) {
1175     IDirect3DVertexShader8Impl *This = (IDirect3DVertexShader8Impl *)pVertexShader;
1176
1177     TRACE("(%p) : Relay\n", This);
1178 /*    return IWineD3DVertexShader_GetDeclaration(This->wineD3DVertexShader, pData, (UINT *)pSizeOfData); */
1179     return D3DERR_INVALIDCALL;
1180 }
1181 HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD pVertexShader, void* pData, DWORD* pSizeOfData) {
1182     IDirect3DVertexShader8Impl *This = (IDirect3DVertexShader8Impl *)pVertexShader;
1183
1184     TRACE("(%p) : Relay\n", This);
1185     return IWineD3DVertexShader_GetFunction(This->wineD3DVertexShader, pData, (UINT *)pSizeOfData);
1186 }
1187
1188 HRESULT WINAPI IDirect3DDevice8Impl_SetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8* pIndexData, UINT baseVertexIndex) {
1189     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1190     TRACE("(%p) Relay\n", This);
1191 /* FIXME: store base vertex index properly */
1192     This->baseVertexIndex = baseVertexIndex;
1193     return IWineD3DDevice_SetIndices(This->WineD3DDevice,
1194                                      NULL == pIndexData ? NULL : ((IDirect3DIndexBuffer8Impl *)pIndexData)->wineD3DIndexBuffer,
1195                                      0);
1196 }
1197
1198 HRESULT WINAPI IDirect3DDevice8Impl_GetIndices(LPDIRECT3DDEVICE8 iface, IDirect3DIndexBuffer8** ppIndexData,UINT* pBaseVertexIndex) {
1199     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1200     IWineD3DIndexBuffer *retIndexData = NULL;
1201     HRESULT rc = D3D_OK;
1202     UINT tmp;
1203
1204     TRACE("(%p) Relay\n", This);
1205
1206     if(ppIndexData == NULL){
1207         return D3DERR_INVALIDCALL;
1208     }
1209
1210     rc = IWineD3DDevice_GetIndices(This->WineD3DDevice, &retIndexData, &tmp);
1211     if (D3D_OK == rc && NULL != retIndexData) {
1212         IWineD3DVertexBuffer_GetParent(retIndexData, (IUnknown **)ppIndexData);
1213         IWineD3DVertexBuffer_Release(retIndexData);
1214     } else {
1215         if(rc != D3D_OK)  FIXME("Call to GetIndices failed\n");
1216         *ppIndexData = NULL;
1217     }
1218 /* FIXME: store base vertex index properly */
1219     *pBaseVertexIndex = This->baseVertexIndex;
1220     return rc;
1221 }
1222 HRESULT WINAPI IDirect3DDevice8Impl_CreatePixelShader(LPDIRECT3DDEVICE8 iface, CONST DWORD* pFunction, DWORD* ppShader) {
1223     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1224     IDirect3DPixelShader8Impl *object;
1225     HRESULT hrc = D3D_OK;
1226
1227     if (NULL == ppShader) {
1228         TRACE("(%p) Invalid call\n", This);
1229         return D3DERR_INVALIDCALL;
1230     }
1231     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1232
1233     if (NULL == object) {
1234         return E_OUTOFMEMORY;
1235     } else {
1236
1237         object->ref    = 1;
1238         object->lpVtbl = &Direct3DPixelShader8_Vtbl;
1239         hrc = IWineD3DDevice_CreatePixelShader(This->WineD3DDevice, pFunction, &object->wineD3DPixelShader , (IUnknown *)object);
1240         if (D3D_OK != hrc) {
1241             FIXME("(%p) call to IWineD3DDevice_CreatePixelShader failed\n", This);
1242             HeapFree(GetProcessHeap(), 0 , object);
1243             *ppShader = 0;
1244         } else {
1245             *ppShader = (DWORD)object;
1246         }
1247
1248     }
1249
1250     TRACE("(%p) : returning %p\n", This, (void *)*ppShader);
1251     return hrc;
1252 }
1253
1254 HRESULT WINAPI IDirect3DDevice8Impl_SetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD pShader) {
1255     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1256     IDirect3DPixelShader8Impl *shader = (IDirect3DPixelShader8Impl *)pShader;
1257     TRACE("(%p) Relay\n", This);
1258
1259     return IWineD3DDevice_SetPixelShader(This->WineD3DDevice, shader == NULL ? NULL :shader->wineD3DPixelShader);
1260 }
1261
1262 HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShader(LPDIRECT3DDEVICE8 iface, DWORD* ppShader) {
1263     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1264     IWineD3DPixelShader *object;
1265
1266     HRESULT hrc = D3D_OK;
1267     TRACE("(%p) Relay\n", This);
1268     if (NULL == ppShader) {
1269         TRACE("(%p) Invalid call\n", This);
1270         return D3DERR_INVALIDCALL;
1271     }
1272
1273     hrc = IWineD3DDevice_GetPixelShader(This->WineD3DDevice, &object);
1274     if (D3D_OK == hrc && NULL != object) {
1275        hrc = IWineD3DPixelShader_GetParent(object, (IUnknown **)ppShader);
1276        IWineD3DPixelShader_Release(object);
1277     } else {
1278         *ppShader = (DWORD)NULL;
1279     }
1280
1281     TRACE("(%p) : returning %p\n", This, (void *)*ppShader);
1282     return hrc;
1283 }
1284
1285 HRESULT WINAPI IDirect3DDevice8Impl_DeletePixelShader(LPDIRECT3DDEVICE8 iface, DWORD pShader) {
1286     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1287     IDirect3DPixelShader8Impl *shader = (IDirect3DPixelShader8Impl *)pShader;
1288     TRACE("(%p) Relay\n", This);
1289
1290     if (NULL != shader) {
1291         while(IUnknown_Release((IUnknown *)shader));
1292     }
1293
1294     return D3D_OK;
1295 }
1296
1297 HRESULT  WINAPI  IDirect3DDevice8Impl_SetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, CONST void* pConstantData, DWORD ConstantCount) {
1298     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1299     TRACE("(%p) Relay\n", This);
1300
1301     return IWineD3DDevice_SetPixelShaderConstantF(This->WineD3DDevice, Register, (CONST float *)pConstantData, ConstantCount);
1302 }
1303
1304 HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, void* pConstantData, DWORD ConstantCount) {
1305     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1306     TRACE("(%p) Relay\n", This);
1307
1308     return IWineD3DDevice_GetPixelShaderConstantF(This->WineD3DDevice, Register, (float *)pConstantData, ConstantCount);
1309 }
1310
1311 HRESULT WINAPI IDirect3DDevice8Impl_GetPixelShaderFunction(LPDIRECT3DDEVICE8 iface, DWORD pPixelShader, void* pData, DWORD* pSizeOfData) {
1312     IDirect3DPixelShader8Impl *This = (IDirect3DPixelShader8Impl *)pPixelShader;
1313
1314     TRACE("(%p) : Relay\n", This);
1315     return IWineD3DPixelShader_GetFunction(This->wineD3DPixelShader, pData, (UINT *)pSizeOfData);
1316 }
1317
1318 HRESULT WINAPI IDirect3DDevice8Impl_DrawRectPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo) {
1319     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1320     TRACE("(%p) Relay\n", This);
1321
1322     return IWineD3DDevice_DrawRectPatch(This->WineD3DDevice, Handle, pNumSegs, (WINED3DRECTPATCH_INFO *)pRectPatchInfo);
1323 }
1324
1325 HRESULT WINAPI IDirect3DDevice8Impl_DrawTriPatch(LPDIRECT3DDEVICE8 iface, UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo) {
1326     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1327     TRACE("(%p) Relay\n", This);
1328
1329     return IWineD3DDevice_DrawTriPatch(This->WineD3DDevice, Handle, pNumSegs, (WINED3DTRIPATCH_INFO *)pTriPatchInfo);
1330 }
1331
1332 HRESULT WINAPI IDirect3DDevice8Impl_DeletePatch(LPDIRECT3DDEVICE8 iface, UINT Handle) {
1333     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1334     TRACE("(%p) Relay\n", This);
1335
1336     return IWineD3DDevice_DeletePatch(This->WineD3DDevice, Handle);
1337 }
1338
1339 HRESULT WINAPI IDirect3DDevice8Impl_SetStreamSource(LPDIRECT3DDEVICE8 iface, UINT StreamNumber,IDirect3DVertexBuffer8* pStreamData,UINT Stride) {
1340     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1341     TRACE("(%p) Relay\n" , This);
1342
1343     return IWineD3DDevice_SetStreamSource(This->WineD3DDevice, StreamNumber,
1344                                           NULL == pStreamData ? NULL : ((IDirect3DVertexBuffer8Impl *)pStreamData)->wineD3DVertexBuffer,
1345                                           0/* Offset in bytes */, Stride);
1346 }
1347
1348 HRESULT WINAPI IDirect3DDevice8Impl_GetStreamSource(LPDIRECT3DDEVICE8 iface, UINT StreamNumber,IDirect3DVertexBuffer8** pStream,UINT* pStride) {
1349     IDirect3DDevice8Impl *This = (IDirect3DDevice8Impl *)iface;
1350     IWineD3DVertexBuffer *retStream = NULL;
1351     HRESULT rc = D3D_OK;
1352
1353     TRACE("(%p) Relay\n" , This);
1354
1355     if(pStream == NULL){
1356         return D3DERR_INVALIDCALL;
1357     }
1358
1359     rc = IWineD3DDevice_GetStreamSource(This->WineD3DDevice, StreamNumber, (IWineD3DVertexBuffer **)&retStream, 0 /* Offset in bytes */, pStride);
1360     if (rc == D3D_OK  && NULL != retStream) {
1361         IWineD3DVertexBuffer_GetParent(retStream, (IUnknown **)pStream);
1362         IWineD3DVertexBuffer_Release(retStream);
1363     }else{
1364          FIXME("Call to GetStreamSource failed %p\n",  pStride);
1365         *pStream = NULL;
1366     }
1367
1368     return rc;
1369 }
1370
1371
1372 const IDirect3DDevice8Vtbl Direct3DDevice8_Vtbl =
1373 {
1374     IDirect3DDevice8Impl_QueryInterface,
1375     IDirect3DDevice8Impl_AddRef,
1376     IDirect3DDevice8Impl_Release,
1377     IDirect3DDevice8Impl_TestCooperativeLevel,
1378     IDirect3DDevice8Impl_GetAvailableTextureMem,
1379     IDirect3DDevice8Impl_ResourceManagerDiscardBytes,
1380     IDirect3DDevice8Impl_GetDirect3D,
1381     IDirect3DDevice8Impl_GetDeviceCaps,
1382     IDirect3DDevice8Impl_GetDisplayMode,
1383     IDirect3DDevice8Impl_GetCreationParameters,
1384     IDirect3DDevice8Impl_SetCursorProperties,
1385     IDirect3DDevice8Impl_SetCursorPosition,
1386     IDirect3DDevice8Impl_ShowCursor,
1387     IDirect3DDevice8Impl_CreateAdditionalSwapChain,
1388     IDirect3DDevice8Impl_Reset,
1389     IDirect3DDevice8Impl_Present,
1390     IDirect3DDevice8Impl_GetBackBuffer,
1391     IDirect3DDevice8Impl_GetRasterStatus,
1392     IDirect3DDevice8Impl_SetGammaRamp,
1393     IDirect3DDevice8Impl_GetGammaRamp,
1394     IDirect3DDevice8Impl_CreateTexture,
1395     IDirect3DDevice8Impl_CreateVolumeTexture,
1396     IDirect3DDevice8Impl_CreateCubeTexture,
1397     IDirect3DDevice8Impl_CreateVertexBuffer,
1398     IDirect3DDevice8Impl_CreateIndexBuffer,
1399     IDirect3DDevice8Impl_CreateRenderTarget,
1400     IDirect3DDevice8Impl_CreateDepthStencilSurface,
1401     IDirect3DDevice8Impl_CreateImageSurface,
1402     IDirect3DDevice8Impl_CopyRects,
1403     IDirect3DDevice8Impl_UpdateTexture,
1404     IDirect3DDevice8Impl_GetFrontBuffer,
1405     IDirect3DDevice8Impl_SetRenderTarget,
1406     IDirect3DDevice8Impl_GetRenderTarget,
1407     IDirect3DDevice8Impl_GetDepthStencilSurface,
1408     IDirect3DDevice8Impl_BeginScene,
1409     IDirect3DDevice8Impl_EndScene,
1410     IDirect3DDevice8Impl_Clear,
1411     IDirect3DDevice8Impl_SetTransform,
1412     IDirect3DDevice8Impl_GetTransform,
1413     IDirect3DDevice8Impl_MultiplyTransform,
1414     IDirect3DDevice8Impl_SetViewport,
1415     IDirect3DDevice8Impl_GetViewport,
1416     IDirect3DDevice8Impl_SetMaterial,
1417     IDirect3DDevice8Impl_GetMaterial,
1418     IDirect3DDevice8Impl_SetLight,
1419     IDirect3DDevice8Impl_GetLight,
1420     IDirect3DDevice8Impl_LightEnable,
1421     IDirect3DDevice8Impl_GetLightEnable,
1422     IDirect3DDevice8Impl_SetClipPlane,
1423     IDirect3DDevice8Impl_GetClipPlane,
1424     IDirect3DDevice8Impl_SetRenderState,
1425     IDirect3DDevice8Impl_GetRenderState,
1426     IDirect3DDevice8Impl_BeginStateBlock,
1427     IDirect3DDevice8Impl_EndStateBlock,
1428     IDirect3DDevice8Impl_ApplyStateBlock,
1429     IDirect3DDevice8Impl_CaptureStateBlock,
1430     IDirect3DDevice8Impl_DeleteStateBlock,
1431     IDirect3DDevice8Impl_CreateStateBlock,
1432     IDirect3DDevice8Impl_SetClipStatus,
1433     IDirect3DDevice8Impl_GetClipStatus,
1434     IDirect3DDevice8Impl_GetTexture,
1435     IDirect3DDevice8Impl_SetTexture,
1436     IDirect3DDevice8Impl_GetTextureStageState,
1437     IDirect3DDevice8Impl_SetTextureStageState,
1438     IDirect3DDevice8Impl_ValidateDevice,
1439     IDirect3DDevice8Impl_GetInfo,
1440     IDirect3DDevice8Impl_SetPaletteEntries,
1441     IDirect3DDevice8Impl_GetPaletteEntries,
1442     IDirect3DDevice8Impl_SetCurrentTexturePalette,
1443     IDirect3DDevice8Impl_GetCurrentTexturePalette,
1444     IDirect3DDevice8Impl_DrawPrimitive,
1445     IDirect3DDevice8Impl_DrawIndexedPrimitive,
1446     IDirect3DDevice8Impl_DrawPrimitiveUP,
1447     IDirect3DDevice8Impl_DrawIndexedPrimitiveUP,
1448     IDirect3DDevice8Impl_ProcessVertices,
1449     IDirect3DDevice8Impl_CreateVertexShader,
1450     IDirect3DDevice8Impl_SetVertexShader,
1451     IDirect3DDevice8Impl_GetVertexShader,
1452     IDirect3DDevice8Impl_DeleteVertexShader,
1453     IDirect3DDevice8Impl_SetVertexShaderConstant,
1454     IDirect3DDevice8Impl_GetVertexShaderConstant,
1455     IDirect3DDevice8Impl_GetVertexShaderDeclaration,
1456     IDirect3DDevice8Impl_GetVertexShaderFunction,
1457     IDirect3DDevice8Impl_SetStreamSource,
1458     IDirect3DDevice8Impl_GetStreamSource,
1459     IDirect3DDevice8Impl_SetIndices,
1460     IDirect3DDevice8Impl_GetIndices,
1461     IDirect3DDevice8Impl_CreatePixelShader,
1462     IDirect3DDevice8Impl_SetPixelShader,
1463     IDirect3DDevice8Impl_GetPixelShader,
1464     IDirect3DDevice8Impl_DeletePixelShader,
1465     IDirect3DDevice8Impl_SetPixelShaderConstant,
1466     IDirect3DDevice8Impl_GetPixelShaderConstant,
1467     IDirect3DDevice8Impl_GetPixelShaderFunction,
1468     IDirect3DDevice8Impl_DrawRectPatch,
1469     IDirect3DDevice8Impl_DrawTriPatch,
1470     IDirect3DDevice8Impl_DeletePatch
1471 };
1472
1473 /* Internal function called back during the CreateDevice to create a render target  */
1474 HRESULT WINAPI D3D8CB_CreateSurface(IUnknown *device, UINT Width, UINT Height,
1475                                          WINED3DFORMAT Format, DWORD Usage, WINED3DPOOL Pool, UINT Level,
1476                                          IWineD3DSurface **ppSurface, HANDLE *pSharedHandle) {
1477
1478     HRESULT res = D3D_OK;
1479     IDirect3DSurface8Impl *d3dSurface = NULL;
1480     BOOL Lockable = TRUE;
1481
1482     if((WINED3DPOOL_DEFAULT == Pool && WINED3DUSAGE_DYNAMIC != Usage))
1483         Lockable = FALSE;
1484
1485     TRACE("relay\n");
1486     res = IDirect3DDevice8Impl_CreateSurface((IDirect3DDevice8 *)device, Width, Height, (D3DFORMAT)Format, Lockable, FALSE/*Discard*/, Level,  (IDirect3DSurface8 **)&d3dSurface, D3DRTYPE_SURFACE, Usage, Pool, D3DMULTISAMPLE_NONE, 0 /* MultisampleQuality */);
1487
1488     if (res == D3D_OK) {
1489         *ppSurface = d3dSurface->wineD3DSurface;
1490     } else {
1491         FIXME("(%p) IDirect3DDevice8_CreateSurface failed\n", device);
1492     }
1493     return res;
1494 }