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

   1 /*
   2  * Copyright (c) 2006 Stefan Dösinger
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20 #include "wine/port.h"
  21 #include "wine/debug.h"
  22
  23 #include <assert.h>
  24 #include <stdarg.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27
  28 #define COBJMACROS
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winerror.h"
  33 #include "wingdi.h"
  34 #include "wine/exception.h"
  35
  36 #include "ddraw.h"
  37 #include "d3d.h"
  38
  39 #include "ddraw_private.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(d3d7);
  42
  43 /*****************************************************************************
  44  * IDirect3D7::QueryInterface
  45  *
  46  * QueryInterface implementation with thunks to IDirectDraw7
  47  *
  48  *****************************************************************************/
  49 static HRESULT WINAPI
  50 Thunk_IDirect3DImpl_7_QueryInterface(IDirect3D7 *iface,
  51                                     REFIID refiid,
  52                                     void **obj)
  53 {
  54     IDirectDrawImpl *This = ddraw_from_d3d7(iface);
  55     TRACE("(%p)->(%s,%p): Thunking to IDirectDraw7\n", This, debugstr_guid(refiid), obj);
  56
  57     return IDirectDraw7_QueryInterface((IDirectDraw7 *)This, refiid, obj);
  58 }
  59
  60 static HRESULT WINAPI
  61 Thunk_IDirect3DImpl_3_QueryInterface(IDirect3D3 *iface,
  62                                     REFIID refiid,
  63                                     void **obj)
  64 {
  65     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
  66     TRACE("(%p)->(%s,%p): Thunking to IDirectDraw7\n", This, debugstr_guid(refiid), obj);
  67
  68     return IDirectDraw7_QueryInterface((IDirectDraw7 *)This, refiid, obj);
  69 }
  70
  71 static HRESULT WINAPI
  72 Thunk_IDirect3DImpl_2_QueryInterface(IDirect3D2 *iface,
  73                                     REFIID refiid,
  74                                     void **obj)
  75 {
  76     IDirectDrawImpl *This = ddraw_from_d3d2(iface);
  77     TRACE("(%p)->(%s,%p): Thunking to IDirectDraw7\n", This, debugstr_guid(refiid), obj);
  78
  79     return IDirectDraw7_QueryInterface((IDirectDraw7 *)This, refiid, obj);
  80 }
  81
  82 static HRESULT WINAPI
  83 Thunk_IDirect3DImpl_1_QueryInterface(IDirect3D *iface,
  84                                     REFIID refiid,
  85                                     void **obj)
  86 {
  87     IDirectDrawImpl *This = ddraw_from_d3d1(iface);
  88     TRACE("(%p)->(%s,%p): Thunking to IDirectDraw7\n", This, debugstr_guid(refiid), obj);
  89
  90     return IDirectDraw7_QueryInterface((IDirectDraw7 *)This, refiid, obj);
  91 }
  92
  93 /*****************************************************************************
  94  * IDirect3D7::AddRef
  95  *
  96  * DirectDraw refcounting is a bit odd. Every version of the ddraw interface
  97  * has its own refcount, but IDirect3D 1/2/3 refcounts are linked to
  98  * IDirectDraw, and IDirect3D7 is linked to IDirectDraw7
  99  *
 100  * IDirect3D7 -> IDirectDraw7
 101  * IDirect3D3 -> IDirectDraw
 102  * IDirect3D2 -> IDirectDraw
 103  * IDirect3D  -> IDirectDraw
 104  *
 105  * So every AddRef implementation thunks to a different interface, and the
 106  * IDirectDrawX::AddRef implementations have different counters...
 107  *
 108  * Returns
 109  *  The new refcount
 110  *
 111  *****************************************************************************/
 112 static ULONG WINAPI
 113 Thunk_IDirect3DImpl_7_AddRef(IDirect3D7 *iface)
 114 {
 115     IDirectDrawImpl *This = ddraw_from_d3d7(iface);
 116     TRACE("(%p) : Thunking to IDirectDraw7.\n", This);
 117
 118     return IDirectDraw7_AddRef((IDirectDraw7 *)This);
 119 }
 120
 121 static ULONG WINAPI
 122 Thunk_IDirect3DImpl_3_AddRef(IDirect3D3 *iface)
 123 {
 124     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
 125     TRACE("(%p) : Thunking to IDirectDraw.\n", This);
 126
 127     return IDirectDraw_AddRef((IDirectDraw *)&This->IDirectDraw_vtbl);
 128 }
 129
 130 static ULONG WINAPI
 131 Thunk_IDirect3DImpl_2_AddRef(IDirect3D2 *iface)
 132 {
 133     IDirectDrawImpl *This = ddraw_from_d3d2(iface);
 134     TRACE("(%p) : Thunking to IDirectDraw.\n", This);
 135
 136     return IDirectDraw_AddRef((IDirectDraw *)&This->IDirectDraw_vtbl);
 137 }
 138
 139 static ULONG WINAPI
 140 Thunk_IDirect3DImpl_1_AddRef(IDirect3D *iface)
 141 {
 142     IDirectDrawImpl *This = ddraw_from_d3d1(iface);
 143     TRACE("(%p) : Thunking to IDirectDraw.\n", This);
 144
 145     return IDirectDraw_AddRef((IDirectDraw *)&This->IDirectDraw_vtbl);
 146 }
 147
 148 /*****************************************************************************
 149  * IDirect3D7::Release
 150  *
 151  * Same story as IDirect3D7::AddRef
 152  *
 153  * Returns: The new refcount
 154  *
 155  *****************************************************************************/
 156 static ULONG WINAPI
 157 Thunk_IDirect3DImpl_7_Release(IDirect3D7 *iface)
 158 {
 159     IDirectDrawImpl *This = ddraw_from_d3d7(iface);
 160     TRACE("(%p) : Thunking to IDirectDraw7.\n", This);
 161
 162     return IDirectDraw7_Release((IDirectDraw7 *)This);
 163 }
 164
 165 static ULONG WINAPI
 166 Thunk_IDirect3DImpl_3_Release(IDirect3D3 *iface)
 167 {
 168     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
 169     TRACE("(%p) : Thunking to IDirectDraw.\n", This);
 170
 171     return IDirectDraw_Release((IDirectDraw *)&This->IDirectDraw_vtbl);
 172 }
 173
 174 static ULONG WINAPI
 175 Thunk_IDirect3DImpl_2_Release(IDirect3D2 *iface)
 176 {
 177     IDirectDrawImpl *This = ddraw_from_d3d2(iface);
 178     TRACE("(%p) : Thunking to IDirectDraw.\n", This);
 179
 180     return IDirectDraw_Release((IDirectDraw *)&This->IDirectDraw_vtbl);
 181 }
 182
 183 static ULONG WINAPI
 184 Thunk_IDirect3DImpl_1_Release(IDirect3D *iface)
 185 {
 186     IDirectDrawImpl *This = ddraw_from_d3d1(iface);
 187     TRACE("(%p) : Thunking to IDirectDraw.\n", This);
 188
 189     return IDirectDraw_Release((IDirectDraw *)&This->IDirectDraw_vtbl);
 190 }
 191
 192 /*****************************************************************************
 193  * IDirect3D Methods
 194  *****************************************************************************/
 195
 196 /*****************************************************************************
 197  * IDirect3D::Initialize
 198  *
 199  * Initializes the IDirect3D interface. This is a no-op implementation,
 200  * as all initialization is done at create time.
 201  *
 202  * Version 1
 203  *
 204  * Params:
 205  *  refiid: ?
 206  *
 207  * Returns:
 208  *  D3D_OK, because it's a no-op
 209  *
 210  *****************************************************************************/
 211 static HRESULT WINAPI
 212 IDirect3DImpl_1_Initialize(IDirect3D *iface,
 213                            REFIID refiid)
 214 {
 215     IDirectDrawImpl *This = ddraw_from_d3d1(iface);
 216
 217     TRACE("(%p)->(%s) no-op...\n", This, debugstr_guid(refiid));
 218     return D3D_OK;
 219 }
 220
 221 /*****************************************************************************
 222  * IDirect3D7::EnumDevices
 223  *
 224  * The EnumDevices method for IDirect3D7. It enumerates all supported
 225  * D3D7 devices. Currently the T&L, HAL and RGB devices are enumerated.
 226  *
 227  * Params:
 228  *  Callback: Function to call for each enumerated device
 229  *  Context: Pointer to pass back to the app
 230  *
 231  * Returns:
 232  *  D3D_OK, or the return value of the GetCaps call
 233  *
 234  *****************************************************************************/
 235 static HRESULT WINAPI
 236 IDirect3DImpl_7_EnumDevices(IDirect3D7 *iface,
 237                           LPD3DENUMDEVICESCALLBACK7 Callback,
 238                           void *Context)
 239 {
 240     IDirectDrawImpl *This = ddraw_from_d3d7(iface);
 241     char interface_name_tnl[] = "WINE Direct3D7 Hardware Transform and Lighting acceleration using WineD3D";
 242     char device_name_tnl[] = "Wine D3D7 T&L HAL";
 243     char interface_name_hal[] = "WINE Direct3D7 Hardware acceleration using WineD3D";
 244     char device_name_hal[] = "Wine D3D7 HAL";
 245     char interface_name_rgb[] = "WINE Direct3D7 RGB Software Emulation using WineD3D";
 246     char device_name_rgb[] = "Wine D3D7 RGB";
 247     D3DDEVICEDESC7 ddesc;
 248     D3DDEVICEDESC oldDesc;
 249     HRESULT hr;
 250
 251     TRACE("(%p)->(%p,%p)\n", This, Callback, Context);
 252     EnterCriticalSection(&ddraw_cs);
 253
 254     TRACE("(%p) Enumerating WineD3D D3Device7 interface\n", This);
 255     hr = IDirect3DImpl_GetCaps(This->wineD3D, &oldDesc, &ddesc);
 256     if(hr != D3D_OK)
 257     {
 258         LeaveCriticalSection(&ddraw_cs);
 259         return hr;
 260     }
 261     Callback(interface_name_tnl, device_name_tnl, &ddesc, Context);
 262
 263     ddesc.deviceGUID = IID_IDirect3DHALDevice;
 264     Callback(interface_name_hal, device_name_hal, &ddesc, Context);
 265
 266     ddesc.deviceGUID = IID_IDirect3DRGBDevice;
 267     Callback(interface_name_rgb, device_name_rgb, &ddesc, Context);
 268
 269     TRACE("(%p) End of enumeration\n", This);
 270     LeaveCriticalSection(&ddraw_cs);
 271     return D3D_OK;
 272 }
 273
 274 /*****************************************************************************
 275  * IDirect3D3::EnumDevices
 276  *
 277  * Enumerates all supported Direct3DDevice interfaces. This is the
 278  * implementation for Direct3D 1 to Direc3D 3, Version 7 has its own.
 279  *
 280  * Version 1, 2 and 3
 281  *
 282  * Params:
 283  *  Callback: Application-provided routine to call for each enumerated device
 284  *  Context: Pointer to pass to the callback
 285  *
 286  * Returns:
 287  *  D3D_OK on success,
 288  *  The result of IDirect3DImpl_GetCaps if it failed
 289  *
 290  *****************************************************************************/
 291 static HRESULT WINAPI
 292 IDirect3DImpl_3_EnumDevices(IDirect3D3 *iface,
 293                             LPD3DENUMDEVICESCALLBACK Callback,
 294                             void *Context)
 295 {
 296     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
 297     D3DDEVICEDESC dref, d1, d2;
 298     D3DDEVICEDESC7 newDesc;
 299     static CHAR wined3d_description[] = "Wine D3DDevice using WineD3D and OpenGL";
 300     HRESULT hr;
 301
 302     /* Some games (Motoracer 2 demo) have the bad idea to modify the device name string.
 303        Let's put the string in a sufficiently sized array in writable memory. */
 304     char device_name[50];
 305     strcpy(device_name,"Direct3D HEL");
 306
 307     TRACE("(%p)->(%p,%p)\n", This, Callback, Context);
 308     EnterCriticalSection(&ddraw_cs);
 309
 310     hr = IDirect3DImpl_GetCaps(This->wineD3D, &dref, &newDesc);
 311     if(hr != D3D_OK)
 312     {
 313         LeaveCriticalSection(&ddraw_cs);
 314         return hr;
 315     }
 316
 317     /* Do I have to enumerate the reference id? Note from old d3d7:
 318      * "It seems that enumerating the reference IID on Direct3D 1 games
 319      * (AvP / Motoracer2) breaks them". So do not enumerate this iid in V1
 320      *
 321      * There's a registry key HKLM\Software\Microsoft\Direct3D\Drivers, EnumReference
 322      * which enables / disables enumerating the reference rasterizer. It's a DWORD,
 323      * 0 means disabled, 2 means enabled. The enablerefrast.reg and disablerefrast.reg
 324      * files in the DirectX 7.0 sdk demo directory suggest this.
 325      *
 326      * Some games(GTA 2) seem to use the second enumerated device, so I have to enumerate
 327      * at least 2 devices. So enumerate the reference device to have 2 devices.
 328      *
 329      * Other games(Rollcage) tell emulation and hal device apart by certain flags.
 330      * Rollcage expects D3DPTEXTURECAPS_POW2 to be set(yeah, it is a limitation flag),
 331      * and it refuses all devices that have the perspective flag set. This way it refuses
 332      * the emulation device, and HAL devices never have POW2 unset in d3d7 on windows.
 333      */
 334
 335     if(This->d3dversion != 1)
 336     {
 337         static CHAR reference_description[] = "RGB Direct3D emulation";
 338
 339         TRACE("(%p) Enumerating WineD3D D3DDevice interface\n", This);
 340         d1 = dref;
 341         d2 = dref;
 342         /* The rgb device has the pow2 flag set in the hel caps, but not in the hal caps */
 343         d1.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
 344         d1.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
 345         hr = Callback( (LPIID) &IID_IDirect3DRGBDevice, reference_description, device_name, &d1, &d2, Context);
 346         if(hr != D3DENUMRET_OK)
 347         {
 348             TRACE("Application cancelled the enumeration\n");
 349             LeaveCriticalSection(&ddraw_cs);
 350             return D3D_OK;
 351         }
 352     }
 353
 354     strcpy(device_name,"Direct3D HAL");
 355
 356     TRACE("(%p) Enumerating HAL Direct3D device\n", This);
 357     d1 = dref;
 358     d2 = dref;
 359     /* The hal device does not have the pow2 flag set in hel, but in hal */
 360     d2.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
 361     d2.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
 362     hr = Callback( (LPIID) &IID_IDirect3DHALDevice, wined3d_description, device_name, &d1, &d2, Context);
 363     if(hr != D3DENUMRET_OK)
 364     {
 365         TRACE("Application cancelled the enumeration\n");
 366         LeaveCriticalSection(&ddraw_cs);
 367         return D3D_OK;
 368     }
 369     TRACE("(%p) End of enumeration\n", This);
 370
 371     LeaveCriticalSection(&ddraw_cs);
 372     return D3D_OK;
 373 }
 374
 375 static HRESULT WINAPI
 376 Thunk_IDirect3DImpl_2_EnumDevices(IDirect3D2 *iface,
 377                                   LPD3DENUMDEVICESCALLBACK Callback,
 378                                   void *Context)
 379 {
 380     IDirectDrawImpl *This = ddraw_from_d3d2(iface);
 381     TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, Callback, Context);
 382     return IDirect3D3_EnumDevices((IDirect3D3 *)&This->IDirect3D3_vtbl, Callback, Context);
 383 }
 384
 385 static HRESULT WINAPI
 386 Thunk_IDirect3DImpl_1_EnumDevices(IDirect3D *iface,
 387                                   LPD3DENUMDEVICESCALLBACK Callback,
 388                                   void *Context)
 389 {
 390     IDirectDrawImpl *This = ddraw_from_d3d1(iface);
 391     TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, Callback, Context);
 392     return IDirect3D3_EnumDevices((IDirect3D3 *)&This->IDirect3D3_vtbl, Callback, Context);
 393 }
 394
 395 /*****************************************************************************
 396  * IDirect3D3::CreateLight
 397  *
 398  * Creates an IDirect3DLight interface. This interface is used in
 399  * Direct3D3 or earlier for lighting. In Direct3D7 it has been replaced
 400  * by the DIRECT3DLIGHT7 structure. Wine's Direct3DLight implementation
 401  * uses the IDirect3DDevice7 interface with D3D7 lights.
 402  *
 403  * Version 1, 2 and 3
 404  *
 405  * Params:
 406  *  Light: Address to store the new interface pointer
 407  *  UnkOuter: Basically for aggregation, but ddraw doesn't support it.
 408  *            Must be NULL
 409  *
 410  * Returns:
 411  *  D3D_OK on success
 412  *  DDERR_OUTOFMEMORY if memory allocation failed
 413  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
 414  *
 415  *****************************************************************************/
 416 static HRESULT WINAPI
 417 IDirect3DImpl_3_CreateLight(IDirect3D3 *iface,
 418                             IDirect3DLight **Light,
 419                             IUnknown *UnkOuter )
 420 {
 421     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
 422     IDirect3DLightImpl *object;
 423
 424     TRACE("(%p)->(%p,%p)\n", This, Light, UnkOuter);
 425
 426     if(UnkOuter)
 427         return CLASS_E_NOAGGREGATION;
 428
 429     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DLightImpl));
 430     if (object == NULL)
 431         return DDERR_OUTOFMEMORY;
 432
 433     object->lpVtbl = &IDirect3DLight_Vtbl;
 434     object->ref = 1;
 435     object->ddraw = This;
 436     object->next = NULL;
 437     object->active_viewport = NULL;
 438
 439     /* Update functions */
 440     object->activate = light_update;
 441     object->desactivate = light_activate;
 442     object->update = light_desactivate;
 443     object->active_viewport = NULL;
 444
 445     *Light = (IDirect3DLight *)object;
 446
 447     TRACE("(%p) creating implementation at %p.\n", This, object);
 448
 449     return D3D_OK;
 450 }
 451
 452 static HRESULT WINAPI
 453 Thunk_IDirect3DImpl_2_CreateLight(IDirect3D2 *iface,
 454                                   IDirect3DLight **Direct3DLight,
 455                                   IUnknown *UnkOuter)
 456 {
 457     IDirectDrawImpl *This = ddraw_from_d3d2(iface);
 458     TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, Direct3DLight, UnkOuter);
 459     return IDirect3D3_CreateLight((IDirect3D3 *)&This->IDirect3D3_vtbl, Direct3DLight, UnkOuter);
 460 }
 461
 462 static HRESULT WINAPI
 463 Thunk_IDirect3DImpl_1_CreateLight(IDirect3D *iface,
 464                                   IDirect3DLight **Direct3DLight,
 465                                   IUnknown *UnkOuter)
 466 {
 467     IDirectDrawImpl *This = ddraw_from_d3d1(iface);
 468     TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, Direct3DLight, UnkOuter);
 469     return IDirect3D3_CreateLight((IDirect3D3 *)&This->IDirect3D3_vtbl, Direct3DLight, UnkOuter);
 470 }
 471
 472 /*****************************************************************************
 473  * IDirect3D3::CreateMaterial
 474  *
 475  * Creates an IDirect3DMaterial interface. This interface is used by Direct3D3
 476  * and older versions. The IDirect3DMaterial implementation wraps its
 477  * functionality to IDirect3DDevice7::SetMaterial and friends.
 478  *
 479  * Version 1, 2 and 3
 480  *
 481  * Params:
 482  *  Material: Address to store the new interface's pointer to
 483  *  UnkOuter: Basically for aggregation, but ddraw doesn't support it.
 484  *            Must be NULL
 485  *
 486  * Returns:
 487  *  D3D_OK on success
 488  *  DDERR_OUTOFMEMORY if memory allocation failed
 489  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
 490  *
 491  *****************************************************************************/
 492 static HRESULT WINAPI
 493 IDirect3DImpl_3_CreateMaterial(IDirect3D3 *iface,
 494                                IDirect3DMaterial3 **Material,
 495                                IUnknown *UnkOuter )
 496 {
 497     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
 498     IDirect3DMaterialImpl *object;
 499
 500     TRACE("(%p)->(%p,%p)\n", This, Material, UnkOuter);
 501
 502     if(UnkOuter)
 503         return CLASS_E_NOAGGREGATION;
 504
 505     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DMaterialImpl));
 506     if (object == NULL)
 507         return DDERR_OUTOFMEMORY;
 508
 509     object->lpVtbl = &IDirect3DMaterial3_Vtbl;
 510     object->IDirect3DMaterial2_vtbl = &IDirect3DMaterial2_Vtbl;
 511     object->IDirect3DMaterial_vtbl = &IDirect3DMaterial_Vtbl;
 512     object->ref = 1;
 513     object->ddraw = This;
 514     object->activate = material_activate;
 515
 516     *Material = (IDirect3DMaterial3 *)object;
 517
 518     TRACE("(%p) creating implementation at %p.\n", This, object);
 519
 520     return D3D_OK;
 521 }
 522
 523 static HRESULT WINAPI
 524 Thunk_IDirect3DImpl_2_CreateMaterial(IDirect3D2 *iface,
 525                                      IDirect3DMaterial2 **Direct3DMaterial,
 526                                      IUnknown* UnkOuter)
 527 {
 528     IDirectDrawImpl *This = ddraw_from_d3d2(iface);
 529     HRESULT ret;
 530     IDirect3DMaterial3 *ret_val;
 531
 532     TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, Direct3DMaterial, UnkOuter);
 533     ret = IDirect3D3_CreateMaterial((IDirect3D3 *)&This->IDirect3D3_vtbl, &ret_val, UnkOuter);
 534
 535     *Direct3DMaterial = ret_val ?
 536             (IDirect3DMaterial2 *)&((IDirect3DMaterialImpl *)ret_val)->IDirect3DMaterial2_vtbl : NULL;
 537
 538     TRACE(" returning interface %p.\n", *Direct3DMaterial);
 539
 540     return ret;
 541 }
 542
 543 static HRESULT WINAPI
 544 Thunk_IDirect3DImpl_1_CreateMaterial(IDirect3D *iface,
 545                                      IDirect3DMaterial **Direct3DMaterial,
 546                                      IUnknown* UnkOuter)
 547 {
 548     IDirectDrawImpl *This = ddraw_from_d3d1(iface);
 549     HRESULT ret;
 550     LPDIRECT3DMATERIAL3 ret_val;
 551
 552     TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, Direct3DMaterial, UnkOuter);
 553     ret = IDirect3D3_CreateMaterial((IDirect3D3 *)&This->IDirect3D3_vtbl, &ret_val, UnkOuter);
 554
 555     *Direct3DMaterial = ret_val ?
 556             (IDirect3DMaterial *)&((IDirect3DMaterialImpl *)ret_val)->IDirect3DMaterial_vtbl : NULL;
 557
 558     TRACE(" returning interface %p.\n", *Direct3DMaterial);
 559
 560     return ret;
 561 }
 562
 563 /*****************************************************************************
 564  * IDirect3D3::CreateViewport
 565  *
 566  * Creates an IDirect3DViewport interface. This interface is used
 567  * by Direct3D and earlier versions for Viewport management. In Direct3D7
 568  * it has been replaced by a viewport structure and
 569  * IDirect3DDevice7::*Viewport. Wine's IDirect3DViewport implementation
 570  * uses the IDirect3DDevice7 methods for its functionality
 571  *
 572  * Params:
 573  *  Viewport: Address to store the new interface pointer
 574  *  UnkOuter: Basically for aggregation, but ddraw doesn't support it.
 575  *            Must be NULL
 576  *
 577  * Returns:
 578  *  D3D_OK on success
 579  *  DDERR_OUTOFMEMORY if memory allocation failed
 580  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
 581  *
 582  *****************************************************************************/
 583 static HRESULT WINAPI
 584 IDirect3DImpl_3_CreateViewport(IDirect3D3 *iface,
 585                               IDirect3DViewport3 **Viewport,
 586                               IUnknown *UnkOuter )
 587 {
 588     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
 589     IDirect3DViewportImpl *object;
 590
 591     if(UnkOuter)
 592         return CLASS_E_NOAGGREGATION;
 593
 594     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DViewportImpl));
 595     if (object == NULL)
 596         return DDERR_OUTOFMEMORY;
 597
 598     object->lpVtbl = &IDirect3DViewport3_Vtbl;
 599     object->ref = 1;
 600     object->ddraw = This;
 601     object->activate = viewport_activate;
 602     object->use_vp2 = 0xFF;
 603     object->next = NULL;
 604     object->lights = NULL;
 605     object->num_lights = 0;
 606     object->map_lights = 0;
 607
 608     *Viewport = (IDirect3DViewport3 *)object;
 609
 610     TRACE("(%p) creating implementation at %p.\n",This, object);
 611
 612     return D3D_OK;
 613 }
 614
 615 static HRESULT WINAPI
 616 Thunk_IDirect3DImpl_2_CreateViewport(IDirect3D2 *iface,
 617                                      IDirect3DViewport2 **D3DViewport2,
 618                                      IUnknown *UnkOuter)
 619 {
 620     IDirectDrawImpl *This = ddraw_from_d3d2(iface);
 621     TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, D3DViewport2, UnkOuter);
 622
 623     return IDirect3D3_CreateViewport((IDirect3D3 *)&This->IDirect3D3_vtbl,
 624                                      (IDirect3DViewport3 **) D3DViewport2 /* No need to cast here */,
 625                                      UnkOuter);
 626 }
 627
 628 static HRESULT WINAPI
 629 Thunk_IDirect3DImpl_1_CreateViewport(IDirect3D *iface,
 630                                      IDirect3DViewport **D3DViewport,
 631                                      IUnknown* UnkOuter)
 632 {
 633     IDirectDrawImpl *This = ddraw_from_d3d1(iface);
 634     TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, D3DViewport, UnkOuter);
 635
 636     return IDirect3D3_CreateViewport((IDirect3D3 *)&This->IDirect3D3_vtbl,
 637                                      (IDirect3DViewport3 **) D3DViewport /* No need to cast here */,
 638                                      UnkOuter);
 639 }
 640
 641 /*****************************************************************************
 642  * IDirect3D3::FindDevice
 643  *
 644  * This method finds a device with the requested properties and returns a
 645  * device description
 646  *
 647  * Verion 1, 2 and 3
 648  * Params:
 649  *  D3DDFS: Describes the requested device characteristics
 650  *  D3DFDR: Returns the device description
 651  *
 652  * Returns:
 653  *  D3D_OK on success
 654  *  DDERR_INVALIDPARAMS if no device was found
 655  *
 656  *****************************************************************************/
 657 static HRESULT WINAPI
 658 IDirect3DImpl_3_FindDevice(IDirect3D3 *iface,
 659                            D3DFINDDEVICESEARCH *D3DDFS,
 660                            D3DFINDDEVICERESULT *D3DFDR)
 661 {
 662     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
 663     D3DDEVICEDESC desc;
 664     D3DDEVICEDESC7 newDesc;
 665     HRESULT hr;
 666
 667     TRACE("(%p)->(%p,%p)\n", This, D3DDFS, D3DFDR);
 668
 669     if (!D3DDFS || !D3DFDR)
 670         return DDERR_INVALIDPARAMS;
 671
 672     if (D3DDFS->dwSize != sizeof(D3DFINDDEVICESEARCH) ||
 673         D3DFDR->dwSize != sizeof(D3DFINDDEVICERESULT))
 674         return DDERR_INVALIDPARAMS;
 675
 676     if ((D3DDFS->dwFlags & D3DFDS_COLORMODEL) &&
 677         (D3DDFS->dcmColorModel != D3DCOLOR_RGB))
 678     {
 679         TRACE(" trying to request a non-RGB D3D color model. Not supported.\n");
 680         return DDERR_INVALIDPARAMS; /* No real idea what to return here :-) */
 681     }
 682     if (D3DDFS->dwFlags & D3DFDS_GUID)
 683     {
 684         TRACE(" trying to match guid %s.\n", debugstr_guid(&(D3DDFS->guid)));
 685         if ((IsEqualGUID(&IID_D3DDEVICE_WineD3D, &(D3DDFS->guid)) == 0) &&
 686             (IsEqualGUID(&IID_IDirect3DHALDevice, &(D3DDFS->guid)) == 0) &&
 687             (IsEqualGUID(&IID_IDirect3DRefDevice, &(D3DDFS->guid)) == 0) &&
 688             (IsEqualGUID(&IID_IDirect3DRGBDevice, &(D3DDFS->guid)) == 0))
 689         {
 690             TRACE(" no match for this GUID.\n");
 691             return DDERR_NOTFOUND;
 692         }
 693     }
 694
 695     /* Get the caps */
 696     hr = IDirect3DImpl_GetCaps(This->wineD3D, &desc, &newDesc);
 697     if(hr != D3D_OK) return hr;
 698
 699     /* Now return our own GUID */
 700     D3DFDR->guid = IID_D3DDEVICE_WineD3D;
 701     D3DFDR->ddHwDesc = desc;
 702     D3DFDR->ddSwDesc = desc;
 703
 704     TRACE(" returning Wine's WineD3D device with (undumped) capabilities\n");
 705
 706     return D3D_OK;
 707 }
 708
 709 static HRESULT WINAPI
 710 Thunk_IDirect3DImpl_2_FindDevice(IDirect3D2 *iface,
 711                                  D3DFINDDEVICESEARCH *D3DDFS,
 712                                  D3DFINDDEVICERESULT *D3DFDR)
 713 {
 714     IDirectDrawImpl *This = ddraw_from_d3d2(iface);
 715     TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", iface, D3DDFS, D3DFDR);
 716     return IDirect3D3_FindDevice((IDirect3D3 *)&This->IDirect3D3_vtbl, D3DDFS, D3DFDR);
 717 }
 718
 719 static HRESULT WINAPI
 720 Thunk_IDirect3DImpl_1_FindDevice(IDirect3D *iface,
 721                                 D3DFINDDEVICESEARCH *D3DDFS,
 722                                 D3DFINDDEVICERESULT *D3DDevice)
 723 {
 724     IDirectDrawImpl *This = ddraw_from_d3d1(iface);
 725     TRACE("(%p)->(%p,%p) thunking to IDirect3D3 interface.\n", This, D3DDFS, D3DDevice);
 726     return IDirect3D3_FindDevice((IDirect3D3 *)&This->IDirect3D3_vtbl, D3DDFS, D3DDevice);
 727 }
 728
 729 /*****************************************************************************
 730  * IDirect3D7::CreateDevice
 731  *
 732  * Creates an IDirect3DDevice7 interface.
 733  *
 734  * Version 2, 3 and 7. IDirect3DDevice 1 interfaces are interfaces to
 735  * DirectDraw surfaces and are created with
 736  * IDirectDrawSurface::QueryInterface. This method uses CreateDevice to
 737  * create the device object and QueryInterfaces for IDirect3DDevice
 738  *
 739  * Params:
 740  *  refiid: IID of the device to create
 741  *  Surface: Initial rendertarget
 742  *  Device: Address to return the interface pointer
 743  *
 744  * Returns:
 745  *  D3D_OK on success
 746  *  DDERR_OUTOFMEMORY if memory allocation failed
 747  *  DDERR_INVALIDPARAMS if a device exists already
 748  *
 749  *****************************************************************************/
 750 static HRESULT WINAPI
 751 IDirect3DImpl_7_CreateDevice(IDirect3D7 *iface,
 752                              REFCLSID refiid,
 753                              IDirectDrawSurface7 *Surface,
 754                              IDirect3DDevice7 **Device)
 755 {
 756     IDirectDrawImpl *This = ddraw_from_d3d7(iface);
 757     IDirect3DDeviceImpl *object;
 758     IParentImpl *IndexBufferParent;
 759     HRESULT hr;
 760     IDirectDrawSurfaceImpl *target = (IDirectDrawSurfaceImpl *)Surface;
 761     TRACE("(%p)->(%s,%p,%p)\n", iface, debugstr_guid(refiid), Surface, Device);
 762
 763     EnterCriticalSection(&ddraw_cs);
 764     *Device = NULL;
 765
 766     /* Fail device creation if non-opengl surfaces are used */
 767     if(This->ImplType != SURFACE_OPENGL)
 768     {
 769         ERR("The application wants to create a Direct3D device, but non-opengl surfaces are set in the registry. Please set the surface implementation to opengl or autodetection to allow 3D rendering\n");
 770
 771         /* We only hit this path if a default surface is set in the registry. Incorrect autodetection
 772          * is caught in CreateSurface or QueryInterface
 773          */
 774         LeaveCriticalSection(&ddraw_cs);
 775         return DDERR_NO3D;
 776     }
 777
 778     /* So far we can only create one device per ddraw object */
 779     if(This->d3ddevice)
 780     {
 781         FIXME("(%p): Only one Direct3D device per DirectDraw object supported\n", This);
 782         LeaveCriticalSection(&ddraw_cs);
 783         return DDERR_INVALIDPARAMS;
 784     }
 785
 786     object = HeapAlloc(GetProcessHeap(), 0, sizeof(IDirect3DDeviceImpl));
 787     if(!object)
 788     {
 789         ERR("Out of memory when allocating a IDirect3DDevice implementation\n");
 790         LeaveCriticalSection(&ddraw_cs);
 791         return DDERR_OUTOFMEMORY;
 792     }
 793
 794     if (This->cooperative_level & DDSCL_FPUPRESERVE)
 795         object->lpVtbl = &IDirect3DDevice7_FPUPreserve_Vtbl;
 796     else
 797         object->lpVtbl = &IDirect3DDevice7_FPUSetup_Vtbl;
 798
 799     object->IDirect3DDevice3_vtbl = &IDirect3DDevice3_Vtbl;
 800     object->IDirect3DDevice2_vtbl = &IDirect3DDevice2_Vtbl;
 801     object->IDirect3DDevice_vtbl = &IDirect3DDevice1_Vtbl;
 802     object->ref = 1;
 803     object->ddraw = This;
 804     object->viewport_list = NULL;
 805     object->current_viewport = NULL;
 806     object->material = 0;
 807     object->target = target;
 808
 809     object->Handles = NULL;
 810     object->numHandles = 0;
 811
 812     object->legacyTextureBlending = FALSE;
 813
 814     /* This is for convenience */
 815     object->wineD3DDevice = This->wineD3DDevice;
 816
 817     /* Create an index buffer, it's needed for indexed drawing */
 818     IndexBufferParent = HeapAlloc(GetProcessHeap(), 0, sizeof(IParentImpl));
 819     if(!IndexBufferParent)
 820     {
 821         ERR("Allocating memory for an index buffer parent failed\n");
 822         HeapFree(GetProcessHeap(), 0, object);
 823         LeaveCriticalSection(&ddraw_cs);
 824         return DDERR_OUTOFMEMORY;
 825     }
 826     IndexBufferParent->lpVtbl = &IParent_Vtbl;
 827     IndexBufferParent->ref = 1;
 828
 829     /* Create an Index Buffer. WineD3D needs one for Drawing indexed primitives
 830      * Create a (hopefully) long enough buffer, and copy the indices into it
 831      * Ideally, a IWineD3DBuffer::SetData method could be created, which
 832      * takes the pointer and avoids the memcpy
 833      */
 834     hr = IWineD3DDevice_CreateIndexBuffer(This->wineD3DDevice, 0x40000 /* Length. Don't know how long it should be */,
 835             WINED3DUSAGE_DYNAMIC /* Usage */, WINED3DPOOL_DEFAULT, &object->indexbuffer, (IUnknown *)IndexBufferParent,
 836             &ddraw_null_wined3d_parent_ops);
 837
 838     if(FAILED(hr))
 839     {
 840         ERR("Failed to create an index buffer\n");
 841         HeapFree(GetProcessHeap(), 0, object);
 842         LeaveCriticalSection(&ddraw_cs);
 843         return hr;
 844     }
 845     IndexBufferParent->child = (IUnknown *) object->indexbuffer;
 846
 847     /* No need to set the indices, it's done when necessary */
 848
 849     /* AddRef the WineD3D Device */
 850     IWineD3DDevice_AddRef(This->wineD3DDevice);
 851
 852     /* Don't forget to return the interface ;) */
 853     *Device = (IDirect3DDevice7 *)object;
 854
 855     TRACE(" (%p) Created an IDirect3DDeviceImpl object at %p\n", This, object);
 856
 857     /* This is for apps which create a non-flip, non-d3d primary surface
 858      * and an offscreen D3DDEVICE surface, then render to the offscreen surface
 859      * and do a Blt from the offscreen to the primary surface.
 860      *
 861      * Set the offscreen D3DDDEVICE surface(=target) as the back buffer,
 862      * and the primary surface(=This->d3d_target) as the front buffer.
 863      *
 864      * This way the app will render to the D3DDEVICE surface and WineD3D
 865      * will catch the Blt was Back Buffer -> Front buffer blt and perform
 866      * a flip instead. This way we don't have to deal with a mixed GL / GDI
 867      * environment.
 868      *
 869      * This should be checked against windowed apps. The only app tested with
 870      * this is moto racer 2 during the loading screen.
 871      */
 872     TRACE("Isrendertarget: %s, d3d_target=%p\n", target->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE ? "true" : "false", This->d3d_target);
 873     if(!(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) &&
 874        (This->d3d_target != target))
 875     {
 876         TRACE("(%p) Using %p as front buffer, %p as back buffer\n", This, This->d3d_target, target);
 877         hr = IWineD3DDevice_SetFrontBackBuffers(This->wineD3DDevice,
 878                                                 This->d3d_target->WineD3DSurface,
 879                                                 target->WineD3DSurface);
 880         if(hr != D3D_OK)
 881             ERR("(%p) Error %08x setting the front and back buffer\n", This, hr);
 882
 883         /* Render to the back buffer */
 884         IWineD3DDevice_SetRenderTarget(This->wineD3DDevice, 0,
 885                                        target->WineD3DSurface,
 886                                        TRUE);
 887         object->OffScreenTarget = TRUE;
 888     }
 889     else
 890     {
 891         object->OffScreenTarget = FALSE;
 892     }
 893
 894     /* AddRef the render target. Also AddRef the render target from ddraw,
 895      * because if it is released before the app releases the D3D device, the D3D capabilities
 896      * of WineD3D will be uninitialized, which has bad effects.
 897      *
 898      * In most cases, those surfaces are the surfaces are the same anyway, but this will simply
 899      * add another ref which is released when the device is destroyed.
 900      */
 901     IDirectDrawSurface7_AddRef(Surface);
 902     IDirectDrawSurface7_AddRef((IDirectDrawSurface7 *)This->d3d_target);
 903
 904     This->d3ddevice = object;
 905
 906     IWineD3DDevice_SetRenderState(This->wineD3DDevice,
 907                                   WINED3DRS_ZENABLE,
 908                                   IDirect3DDeviceImpl_UpdateDepthStencil(object));
 909     LeaveCriticalSection(&ddraw_cs);
 910     return D3D_OK;
 911 }
 912
 913 static HRESULT WINAPI
 914 Thunk_IDirect3DImpl_3_CreateDevice(IDirect3D3 *iface,
 915                                    REFCLSID refiid,
 916                                    IDirectDrawSurface4 *Surface,
 917                                    IDirect3DDevice3 **Device,
 918                                    IUnknown *UnkOuter)
 919 {
 920     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
 921     HRESULT hr;
 922     TRACE("(%p)->(%s,%p,%p,%p): Thunking to IDirect3D7\n", This, debugstr_guid(refiid), Surface, Device, UnkOuter);
 923
 924     if(UnkOuter != NULL)
 925         return CLASS_E_NOAGGREGATION;
 926
 927     hr =  IDirect3D7_CreateDevice((IDirect3D7 *)&This->IDirect3D7_vtbl, refiid,
 928             (IDirectDrawSurface7 *)Surface /* Same VTables */, (IDirect3DDevice7 **)Device);
 929
 930     *Device = *Device ? (IDirect3DDevice3 *)&((IDirect3DDeviceImpl *)*Device)->IDirect3DDevice3_vtbl : NULL;
 931     return hr;
 932 }
 933
 934 static HRESULT WINAPI
 935 Thunk_IDirect3DImpl_2_CreateDevice(IDirect3D2 *iface,
 936                                    REFCLSID refiid,
 937                                    IDirectDrawSurface *Surface,
 938                                    IDirect3DDevice2 **Device)
 939 {
 940     IDirectDrawImpl *This = ddraw_from_d3d2(iface);
 941     HRESULT hr;
 942     TRACE("(%p)->(%s,%p,%p): Thunking to IDirect3D7\n", This, debugstr_guid(refiid), Surface, Device);
 943
 944     hr =  IDirect3D7_CreateDevice((IDirect3D7 *)&This->IDirect3D7_vtbl, refiid,
 945             Surface ? (IDirectDrawSurface7 *)surface_from_surface3((IDirectDrawSurface3 *)Surface) : NULL,
 946             (IDirect3DDevice7 **)Device);
 947
 948     *Device = *Device ? (IDirect3DDevice2 *)&((IDirect3DDeviceImpl *)*Device)->IDirect3DDevice2_vtbl : NULL;
 949     return hr;
 950 }
 951
 952 /*****************************************************************************
 953  * IDirect3D7::CreateVertexBuffer
 954  *
 955  * Creates a new vertex buffer object and returns a IDirect3DVertexBuffer7
 956  * interface.
 957  *
 958  * Version 3 and 7
 959  *
 960  * Params:
 961  *  Desc: Requested Vertex buffer properties
 962  *  VertexBuffer: Address to return the interface pointer at
 963  *  Flags: Some flags, must be 0
 964  *
 965  * Returns
 966  *  D3D_OK on success
 967  *  DDERR_OUTOFMEMORY if memory allocation failed
 968  *  The return value of IWineD3DDevice::CreateVertexBuffer if this call fails
 969  *  DDERR_INVALIDPARAMS if Desc or VertexBuffer are NULL, or Flags != 0
 970  *
 971  *****************************************************************************/
 972 static HRESULT WINAPI
 973 IDirect3DImpl_7_CreateVertexBuffer(IDirect3D7 *iface,
 974                                    D3DVERTEXBUFFERDESC *Desc,
 975                                    IDirect3DVertexBuffer7 **VertexBuffer,
 976                                    DWORD Flags)
 977 {
 978     IDirectDrawImpl *This = ddraw_from_d3d7(iface);
 979     IDirect3DVertexBufferImpl *object;
 980     HRESULT hr;
 981     DWORD usage;
 982     TRACE("(%p)->(%p,%p,%08x)\n", This, Desc, VertexBuffer, Flags);
 983
 984     TRACE("(%p) Vertex buffer description:\n", This);
 985     TRACE("(%p)  dwSize=%d\n", This, Desc->dwSize);
 986     TRACE("(%p)  dwCaps=%08x\n", This, Desc->dwCaps);
 987     TRACE("(%p)  FVF=%08x\n", This, Desc->dwFVF);
 988     TRACE("(%p)  dwNumVertices=%d\n", This, Desc->dwNumVertices);
 989
 990     /* D3D7 SDK: "No Flags are currently defined for this method. This
 991      * parameter must be 0"
 992      *
 993      * Never trust the documentation - this is wrong
 994     if(Flags != 0)
 995     {
 996         ERR("(%p) Flags is %08lx, returning DDERR_INVALIDPARAMS\n", This, Flags);
 997         return DDERR_INVALIDPARAMS;
 998     }
 999      */
1000
1001     /* Well, this sounds sane */
1002     if( (!VertexBuffer) || (!Desc) )
1003         return DDERR_INVALIDPARAMS;
1004
1005     /* Now create the vertex buffer */
1006     object = HeapAlloc(GetProcessHeap(), 0, sizeof(IDirect3DVertexBufferImpl));
1007     if(!object)
1008     {
1009         ERR("(%p) Out of memory when allocating a IDirect3DVertexBufferImpl structure\n", This);
1010         return DDERR_OUTOFMEMORY;
1011     }
1012
1013     object->ref = 1;
1014     object->lpVtbl = &IDirect3DVertexBuffer7_Vtbl;
1015     object->IDirect3DVertexBuffer_vtbl = &IDirect3DVertexBuffer1_Vtbl;
1016
1017     object->Caps = Desc->dwCaps;
1018     object->ddraw = This;
1019     object->fvf = Desc->dwFVF;
1020
1021     usage = Desc->dwCaps & D3DVBCAPS_WRITEONLY ? WINED3DUSAGE_WRITEONLY : 0;
1022     usage |= WINED3DUSAGE_STATICDECL;
1023
1024     EnterCriticalSection(&ddraw_cs);
1025     hr = IWineD3DDevice_CreateVertexBuffer(This->wineD3DDevice,
1026             get_flexible_vertex_size(Desc->dwFVF) * Desc->dwNumVertices,
1027             usage, Desc->dwCaps & D3DVBCAPS_SYSTEMMEMORY ? WINED3DPOOL_SYSTEMMEM : WINED3DPOOL_DEFAULT,
1028             &object->wineD3DVertexBuffer, (IUnknown *)object, &ddraw_null_wined3d_parent_ops);
1029     if(hr != D3D_OK)
1030     {
1031         ERR("(%p) IWineD3DDevice::CreateVertexBuffer failed with hr=%08x\n", This, hr);
1032         HeapFree(GetProcessHeap(), 0, object);
1033         LeaveCriticalSection(&ddraw_cs);
1034         if (hr == WINED3DERR_INVALIDCALL)
1035             return DDERR_INVALIDPARAMS;
1036         else
1037             return hr;
1038     }
1039
1040     object->wineD3DVertexDeclaration = IDirectDrawImpl_FindDecl(This,
1041                                                                 Desc->dwFVF);
1042     if(!object->wineD3DVertexDeclaration)
1043     {
1044         ERR("Cannot find the vertex declaration for fvf %08x\n", Desc->dwFVF);
1045         IWineD3DBuffer_Release(object->wineD3DVertexBuffer);
1046         HeapFree(GetProcessHeap(), 0, object);
1047         LeaveCriticalSection(&ddraw_cs);
1048         return DDERR_INVALIDPARAMS;
1049     }
1050     IWineD3DVertexDeclaration_AddRef(object->wineD3DVertexDeclaration);
1051
1052     /* Return the interface */
1053     *VertexBuffer = (IDirect3DVertexBuffer7 *)object;
1054
1055     TRACE("(%p) Created new vertex buffer implementation at %p, returning interface at %p\n", This, object, *VertexBuffer);
1056     LeaveCriticalSection(&ddraw_cs);
1057     return D3D_OK;
1058 }
1059
1060 static HRESULT WINAPI
1061 Thunk_IDirect3DImpl_3_CreateVertexBuffer(IDirect3D3 *iface,
1062                                          D3DVERTEXBUFFERDESC *Desc,
1063                                          IDirect3DVertexBuffer **VertexBuffer,
1064                                          DWORD Flags,
1065                                          IUnknown *UnkOuter)
1066 {
1067     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
1068     HRESULT hr;
1069     TRACE("(%p)->(%p,%p,%08x,%p): Relaying to IDirect3D7\n", This, Desc, VertexBuffer, Flags, UnkOuter);
1070
1071     if(UnkOuter != NULL) return CLASS_E_NOAGGREGATION;
1072
1073     hr = IDirect3D7_CreateVertexBuffer((IDirect3D7 *)&This->IDirect3D7_vtbl,
1074             Desc, (IDirect3DVertexBuffer7 **)VertexBuffer, Flags);
1075
1076     *VertexBuffer = *VertexBuffer ?
1077             (IDirect3DVertexBuffer *)&((IDirect3DVertexBufferImpl *)*VertexBuffer)->IDirect3DVertexBuffer_vtbl : NULL;
1078
1079     return hr;
1080 }
1081
1082
1083 /*****************************************************************************
1084  * IDirect3D7::EnumZBufferFormats
1085  *
1086  * Enumerates all supported Z buffer pixel formats
1087  *
1088  * Version 3 and 7
1089  *
1090  * Params:
1091  *  refiidDevice:
1092  *  Callback: Callback to call for each pixel format
1093  *  Context: Pointer to pass back to the callback
1094  *
1095  * Returns:
1096  *  D3D_OK on success
1097  *  DDERR_INVALIDPARAMS if Callback is NULL
1098  *  For details, see IWineD3DDevice::EnumZBufferFormats
1099  *
1100  *****************************************************************************/
1101 static HRESULT WINAPI
1102 IDirect3DImpl_7_EnumZBufferFormats(IDirect3D7 *iface,
1103                                    REFCLSID refiidDevice,
1104                                    LPD3DENUMPIXELFORMATSCALLBACK Callback,
1105                                    void *Context)
1106 {
1107     IDirectDrawImpl *This = ddraw_from_d3d7(iface);
1108     HRESULT hr;
1109     unsigned int i;
1110     WINED3DDISPLAYMODE d3ddm;
1111     WINED3DDEVTYPE type;
1112
1113     /* Order matters. Specifically, BattleZone II (full version) expects the
1114      * 16-bit depth formats to be listed before the 24 and 32 ones. */
1115     WINED3DFORMAT FormatList[] = {
1116         WINED3DFMT_S1_UINT_D15_UNORM,
1117         WINED3DFMT_D16_UNORM,
1118         WINED3DFMT_X8D24_UNORM,
1119         WINED3DFMT_S4X4_UINT_D24_UNORM,
1120         WINED3DFMT_D24_UNORM_S8_UINT,
1121         WINED3DFMT_D32_UNORM,
1122     };
1123
1124     TRACE("(%p)->(%s,%p,%p): Relay\n", iface, debugstr_guid(refiidDevice), Callback, Context);
1125
1126     if(!Callback)
1127         return DDERR_INVALIDPARAMS;
1128
1129     if(IsEqualGUID(refiidDevice, &IID_IDirect3DHALDevice)    ||
1130        IsEqualGUID(refiidDevice, &IID_IDirect3DTnLHalDevice) ||
1131        IsEqualGUID(refiidDevice, &IID_D3DDEVICE_WineD3D))
1132     {
1133         TRACE("Asked for HAL device\n");
1134         type = WINED3DDEVTYPE_HAL;
1135     }
1136     else if(IsEqualGUID(refiidDevice, &IID_IDirect3DRGBDevice) ||
1137             IsEqualGUID(refiidDevice, &IID_IDirect3DMMXDevice))
1138     {
1139         TRACE("Asked for SW device\n");
1140         type = WINED3DDEVTYPE_SW;
1141     }
1142     else if(IsEqualGUID(refiidDevice, &IID_IDirect3DRefDevice))
1143     {
1144         TRACE("Asked for REF device\n");
1145         type = WINED3DDEVTYPE_REF;
1146     }
1147     else if(IsEqualGUID(refiidDevice, &IID_IDirect3DNullDevice))
1148     {
1149         TRACE("Asked for NULLREF device\n");
1150         type = WINED3DDEVTYPE_NULLREF;
1151     }
1152     else
1153     {
1154         FIXME("Unexpected device GUID %s\n", debugstr_guid(refiidDevice));
1155         type = WINED3DDEVTYPE_HAL;
1156     }
1157
1158     EnterCriticalSection(&ddraw_cs);
1159     /* We need an adapter format from somewhere to please wined3d and WGL. Use the current display mode.
1160      * So far all cards offer the same depth stencil format for all modes, but if some do not and apps
1161      * do not like that we'll have to find some workaround, like iterating over all imaginable formats
1162      * and collecting all the depth stencil formats we can get
1163      */
1164     hr = IWineD3DDevice_GetDisplayMode(This->wineD3DDevice,
1165                                        0 /* swapchain 0 */,
1166                                        &d3ddm);
1167
1168     for(i = 0; i < (sizeof(FormatList) / sizeof(FormatList[0])); i++)
1169     {
1170         hr = IWineD3D_CheckDeviceFormat(This->wineD3D,
1171                                         WINED3DADAPTER_DEFAULT /* Adapter */,
1172                                         type /* DeviceType */,
1173                                         d3ddm.Format /* AdapterFormat */,
1174                                         WINED3DUSAGE_DEPTHSTENCIL /* Usage */,
1175                                         WINED3DRTYPE_SURFACE,
1176                                         FormatList[i],
1177                                         SURFACE_OPENGL);
1178         if(hr == D3D_OK)
1179         {
1180             DDPIXELFORMAT pformat;
1181
1182             memset(&pformat, 0, sizeof(pformat));
1183             pformat.dwSize = sizeof(pformat);
1184             PixelFormat_WineD3DtoDD(&pformat, FormatList[i]);
1185
1186             TRACE("Enumerating WineD3DFormat %d\n", FormatList[i]);
1187             hr = Callback(&pformat, Context);
1188             if(hr != DDENUMRET_OK)
1189             {
1190                 TRACE("Format enumeration cancelled by application\n");
1191                 LeaveCriticalSection(&ddraw_cs);
1192                 return D3D_OK;
1193             }
1194         }
1195     }
1196     TRACE("End of enumeration\n");
1197     LeaveCriticalSection(&ddraw_cs);
1198     return D3D_OK;
1199 }
1200
1201 static HRESULT WINAPI
1202 Thunk_IDirect3DImpl_3_EnumZBufferFormats(IDirect3D3 *iface,
1203                                          REFCLSID riidDevice,
1204                                          LPD3DENUMPIXELFORMATSCALLBACK Callback,
1205                                          void *Context)
1206 {
1207     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
1208     TRACE("(%p)->(%s,%p,%p) thunking to IDirect3D7 interface.\n", This, debugstr_guid(riidDevice), Callback, Context);
1209     return IDirect3D7_EnumZBufferFormats((IDirect3D7 *)&This->IDirect3D7_vtbl, riidDevice, Callback, Context);
1210 }
1211
1212 /*****************************************************************************
1213  * IDirect3D7::EvictManagedTextures
1214  *
1215  * Removes all managed textures (=surfaces with DDSCAPS2_TEXTUREMANAGE or
1216  * DDSCAPS2_D3DTEXTUREMANAGE caps) to be removed from video memory.
1217  *
1218  * Version 3 and 7
1219  *
1220  * Returns:
1221  *  D3D_OK, because it's a stub
1222  *
1223  *****************************************************************************/
1224 static HRESULT WINAPI
1225 IDirect3DImpl_7_EvictManagedTextures(IDirect3D7 *iface)
1226 {
1227     IDirectDrawImpl *This = ddraw_from_d3d7(iface);
1228     FIXME("(%p): Stub!\n", This);
1229
1230     /* Implementation idea:
1231      * Add an IWineD3DSurface method which sets the opengl texture
1232      * priority low or even removes the opengl texture.
1233      */
1234
1235     return D3D_OK;
1236 }
1237
1238 static HRESULT WINAPI
1239 Thunk_IDirect3DImpl_3_EvictManagedTextures(IDirect3D3 *iface)
1240 {
1241     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
1242     TRACE("(%p)->() thunking to IDirect3D7 interface.\n", This);
1243     return IDirect3D7_EvictManagedTextures((IDirect3D7 *)&This->IDirect3D7_vtbl);
1244 }
1245
1246 /*****************************************************************************
1247  * IDirect3DImpl_GetCaps
1248  *
1249  * This function retrieves the device caps from wined3d
1250  * and converts it into a D3D7 and D3D - D3D3 structure
1251  * This is a helper function called from various places in ddraw
1252  *
1253  * Params:
1254  *  WineD3D: The interface to get the caps from
1255  *  Desc123: Old D3D <3 structure to fill (needed)
1256  *  Desc7: D3D7 device desc structure to fill (needed)
1257  *
1258  * Returns
1259  *  D3D_OK on success, or the return value of IWineD3D::GetCaps
1260  *
1261  *****************************************************************************/
1262 HRESULT
1263 IDirect3DImpl_GetCaps(IWineD3D *WineD3D,
1264                       D3DDEVICEDESC *Desc123,
1265                       D3DDEVICEDESC7 *Desc7)
1266 {
1267     WINED3DCAPS WCaps;
1268     HRESULT hr;
1269
1270     /* Some variables to assign to the pointers in WCaps */
1271     TRACE("()->(%p,%p,%p\n", WineD3D, Desc123, Desc7);
1272
1273     memset(&WCaps, 0, sizeof(WCaps));
1274     EnterCriticalSection(&ddraw_cs);
1275     hr = IWineD3D_GetDeviceCaps(WineD3D, 0, WINED3DDEVTYPE_HAL, &WCaps);
1276     LeaveCriticalSection(&ddraw_cs);
1277     if(hr != D3D_OK)
1278     {
1279         return hr;
1280     }
1281
1282     /* Copy the results into the d3d7 and d3d3 structures */
1283     Desc7->dwDevCaps = WCaps.DevCaps;
1284     Desc7->dpcLineCaps.dwMiscCaps = WCaps.PrimitiveMiscCaps;
1285     Desc7->dpcLineCaps.dwRasterCaps = WCaps.RasterCaps;
1286     Desc7->dpcLineCaps.dwZCmpCaps = WCaps.ZCmpCaps;
1287     Desc7->dpcLineCaps.dwSrcBlendCaps = WCaps.SrcBlendCaps;
1288     Desc7->dpcLineCaps.dwDestBlendCaps = WCaps.DestBlendCaps;
1289     Desc7->dpcLineCaps.dwAlphaCmpCaps = WCaps.AlphaCmpCaps;
1290     Desc7->dpcLineCaps.dwShadeCaps = WCaps.ShadeCaps;
1291     Desc7->dpcLineCaps.dwTextureCaps = WCaps.TextureCaps;
1292     Desc7->dpcLineCaps.dwTextureFilterCaps = WCaps.TextureFilterCaps;
1293     Desc7->dpcLineCaps.dwTextureAddressCaps = WCaps.TextureAddressCaps;
1294
1295     Desc7->dwMaxTextureWidth = WCaps.MaxTextureWidth;
1296     Desc7->dwMaxTextureHeight = WCaps.MaxTextureHeight;
1297
1298     Desc7->dwMaxTextureRepeat = WCaps.MaxTextureRepeat;
1299     Desc7->dwMaxTextureAspectRatio = WCaps.MaxTextureAspectRatio;
1300     Desc7->dwMaxAnisotropy = WCaps.MaxAnisotropy;
1301     Desc7->dvMaxVertexW = WCaps.MaxVertexW;
1302
1303     Desc7->dvGuardBandLeft = WCaps.GuardBandLeft;
1304     Desc7->dvGuardBandTop = WCaps.GuardBandTop;
1305     Desc7->dvGuardBandRight = WCaps.GuardBandRight;
1306     Desc7->dvGuardBandBottom = WCaps.GuardBandBottom;
1307
1308     Desc7->dvExtentsAdjust = WCaps.ExtentsAdjust;
1309     Desc7->dwStencilCaps = WCaps.StencilCaps;
1310
1311     Desc7->dwFVFCaps = WCaps.FVFCaps;
1312     Desc7->dwTextureOpCaps = WCaps.TextureOpCaps;
1313
1314     Desc7->dwVertexProcessingCaps = WCaps.VertexProcessingCaps;
1315     Desc7->dwMaxActiveLights = WCaps.MaxActiveLights;
1316
1317     /* Remove all non-d3d7 caps */
1318     Desc7->dwDevCaps &= (
1319         D3DDEVCAPS_FLOATTLVERTEX         | D3DDEVCAPS_SORTINCREASINGZ          | D3DDEVCAPS_SORTDECREASINGZ          |
1320         D3DDEVCAPS_SORTEXACT             | D3DDEVCAPS_EXECUTESYSTEMMEMORY      | D3DDEVCAPS_EXECUTEVIDEOMEMORY       |
1321         D3DDEVCAPS_TLVERTEXSYSTEMMEMORY  | D3DDEVCAPS_TLVERTEXVIDEOMEMORY      | D3DDEVCAPS_TEXTURESYSTEMMEMORY      |
1322         D3DDEVCAPS_TEXTUREVIDEOMEMORY    | D3DDEVCAPS_DRAWPRIMTLVERTEX         | D3DDEVCAPS_CANRENDERAFTERFLIP       |
1323         D3DDEVCAPS_TEXTURENONLOCALVIDMEM | D3DDEVCAPS_DRAWPRIMITIVES2          | D3DDEVCAPS_SEPARATETEXTUREMEMORIES  |
1324         D3DDEVCAPS_DRAWPRIMITIVES2EX     | D3DDEVCAPS_HWTRANSFORMANDLIGHT      | D3DDEVCAPS_CANBLTSYSTONONLOCAL      |
1325         D3DDEVCAPS_HWRASTERIZATION);
1326
1327     Desc7->dwStencilCaps &= (
1328         D3DSTENCILCAPS_KEEP              | D3DSTENCILCAPS_ZERO                 | D3DSTENCILCAPS_REPLACE              |
1329         D3DSTENCILCAPS_INCRSAT           | D3DSTENCILCAPS_DECRSAT              | D3DSTENCILCAPS_INVERT               |
1330         D3DSTENCILCAPS_INCR              | D3DSTENCILCAPS_DECR);
1331
1332     /* FVF caps ?*/
1333
1334     Desc7->dwTextureOpCaps &= (
1335         D3DTEXOPCAPS_DISABLE             | D3DTEXOPCAPS_SELECTARG1             | D3DTEXOPCAPS_SELECTARG2             |
1336         D3DTEXOPCAPS_MODULATE            | D3DTEXOPCAPS_MODULATE2X             | D3DTEXOPCAPS_MODULATE4X             |
1337         D3DTEXOPCAPS_ADD                 | D3DTEXOPCAPS_ADDSIGNED              | D3DTEXOPCAPS_ADDSIGNED2X            |
1338         D3DTEXOPCAPS_SUBTRACT            | D3DTEXOPCAPS_ADDSMOOTH              | D3DTEXOPCAPS_BLENDTEXTUREALPHA      |
1339         D3DTEXOPCAPS_BLENDFACTORALPHA    | D3DTEXOPCAPS_BLENDTEXTUREALPHAPM    | D3DTEXOPCAPS_BLENDCURRENTALPHA      |
1340         D3DTEXOPCAPS_PREMODULATE         | D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
1341         D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA | D3DTEXOPCAPS_BUMPENVMAP    |
1342         D3DTEXOPCAPS_BUMPENVMAPLUMINANCE | D3DTEXOPCAPS_DOTPRODUCT3);
1343
1344     Desc7->dwVertexProcessingCaps &= (
1345         D3DVTXPCAPS_TEXGEN               | D3DVTXPCAPS_MATERIALSOURCE7         | D3DVTXPCAPS_VERTEXFOG               |
1346         D3DVTXPCAPS_DIRECTIONALLIGHTS    | D3DVTXPCAPS_POSITIONALLIGHTS        | D3DVTXPCAPS_LOCALVIEWER);
1347
1348     Desc7->dpcLineCaps.dwMiscCaps &= (
1349         D3DPMISCCAPS_MASKPLANES          | D3DPMISCCAPS_MASKZ                  | D3DPMISCCAPS_LINEPATTERNREP         |
1350         D3DPMISCCAPS_CONFORMANT          | D3DPMISCCAPS_CULLNONE               | D3DPMISCCAPS_CULLCW                 |
1351         D3DPMISCCAPS_CULLCCW);
1352
1353     Desc7->dpcLineCaps.dwRasterCaps &= (
1354         D3DPRASTERCAPS_DITHER            | D3DPRASTERCAPS_ROP2                 | D3DPRASTERCAPS_XOR                  |
1355         D3DPRASTERCAPS_PAT               | D3DPRASTERCAPS_ZTEST                | D3DPRASTERCAPS_SUBPIXEL             |
1356         D3DPRASTERCAPS_SUBPIXELX         | D3DPRASTERCAPS_FOGVERTEX            | D3DPRASTERCAPS_FOGTABLE             |
1357         D3DPRASTERCAPS_STIPPLE           | D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT | D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT |
1358         D3DPRASTERCAPS_ANTIALIASEDGES    | D3DPRASTERCAPS_MIPMAPLODBIAS        | D3DPRASTERCAPS_ZBIAS                |
1359         D3DPRASTERCAPS_ZBUFFERLESSHSR    | D3DPRASTERCAPS_FOGRANGE             | D3DPRASTERCAPS_ANISOTROPY           |
1360         D3DPRASTERCAPS_WBUFFER           | D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT | D3DPRASTERCAPS_WFOG           |
1361         D3DPRASTERCAPS_ZFOG);
1362
1363     Desc7->dpcLineCaps.dwZCmpCaps &= (
1364         D3DPCMPCAPS_NEVER                | D3DPCMPCAPS_LESS                    | D3DPCMPCAPS_EQUAL                   |
1365         D3DPCMPCAPS_LESSEQUAL            | D3DPCMPCAPS_GREATER                 | D3DPCMPCAPS_NOTEQUAL                |
1366         D3DPCMPCAPS_GREATEREQUAL         | D3DPCMPCAPS_ALWAYS);
1367
1368     Desc7->dpcLineCaps.dwSrcBlendCaps &= (
1369         D3DPBLENDCAPS_ZERO               | D3DPBLENDCAPS_ONE                   | D3DPBLENDCAPS_SRCCOLOR              |
1370         D3DPBLENDCAPS_INVSRCCOLOR        | D3DPBLENDCAPS_SRCALPHA              | D3DPBLENDCAPS_INVSRCALPHA           |
1371         D3DPBLENDCAPS_DESTALPHA          | D3DPBLENDCAPS_INVDESTALPHA          | D3DPBLENDCAPS_DESTCOLOR             |
1372         D3DPBLENDCAPS_INVDESTCOLOR       | D3DPBLENDCAPS_SRCALPHASAT           | D3DPBLENDCAPS_BOTHSRCALPHA          |
1373         D3DPBLENDCAPS_BOTHINVSRCALPHA);
1374
1375     Desc7->dpcLineCaps.dwDestBlendCaps &= (
1376         D3DPBLENDCAPS_ZERO               | D3DPBLENDCAPS_ONE                   | D3DPBLENDCAPS_SRCCOLOR              |
1377         D3DPBLENDCAPS_INVSRCCOLOR        | D3DPBLENDCAPS_SRCALPHA              | D3DPBLENDCAPS_INVSRCALPHA           |
1378         D3DPBLENDCAPS_DESTALPHA          | D3DPBLENDCAPS_INVDESTALPHA          | D3DPBLENDCAPS_DESTCOLOR             |
1379         D3DPBLENDCAPS_INVDESTCOLOR       | D3DPBLENDCAPS_SRCALPHASAT           | D3DPBLENDCAPS_BOTHSRCALPHA          |
1380         D3DPBLENDCAPS_BOTHINVSRCALPHA);
1381
1382     Desc7->dpcLineCaps.dwAlphaCmpCaps &= (
1383         D3DPCMPCAPS_NEVER                | D3DPCMPCAPS_LESS                    | D3DPCMPCAPS_EQUAL                   |
1384         D3DPCMPCAPS_LESSEQUAL            | D3DPCMPCAPS_GREATER                 | D3DPCMPCAPS_NOTEQUAL                |
1385         D3DPCMPCAPS_GREATEREQUAL         | D3DPCMPCAPS_ALWAYS);
1386
1387     Desc7->dpcLineCaps.dwShadeCaps &= (
1388         D3DPSHADECAPS_COLORFLATMONO      | D3DPSHADECAPS_COLORFLATRGB          | D3DPSHADECAPS_COLORGOURAUDMONO      |
1389         D3DPSHADECAPS_COLORGOURAUDRGB    | D3DPSHADECAPS_COLORPHONGMONO        | D3DPSHADECAPS_COLORPHONGRGB         |
1390         D3DPSHADECAPS_SPECULARFLATMONO   | D3DPSHADECAPS_SPECULARFLATRGB       | D3DPSHADECAPS_SPECULARGOURAUDMONO   |
1391         D3DPSHADECAPS_SPECULARGOURAUDRGB | D3DPSHADECAPS_SPECULARPHONGMONO     | D3DPSHADECAPS_SPECULARPHONGRGB      |
1392         D3DPSHADECAPS_ALPHAFLATBLEND     | D3DPSHADECAPS_ALPHAFLATSTIPPLED     | D3DPSHADECAPS_ALPHAGOURAUDBLEND     |
1393         D3DPSHADECAPS_ALPHAGOURAUDSTIPPLED | D3DPSHADECAPS_ALPHAPHONGBLEND     | D3DPSHADECAPS_ALPHAPHONGSTIPPLED    |
1394         D3DPSHADECAPS_FOGFLAT            | D3DPSHADECAPS_FOGGOURAUD            | D3DPSHADECAPS_FOGPHONG);
1395
1396     Desc7->dpcLineCaps.dwTextureCaps &= (
1397         D3DPTEXTURECAPS_PERSPECTIVE      | D3DPTEXTURECAPS_POW2                | D3DPTEXTURECAPS_ALPHA               |
1398         D3DPTEXTURECAPS_TRANSPARENCY     | D3DPTEXTURECAPS_BORDER              | D3DPTEXTURECAPS_SQUAREONLY          |
1399         D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE | D3DPTEXTURECAPS_ALPHAPALETTE| D3DPTEXTURECAPS_NONPOW2CONDITIONAL  |
1400         D3DPTEXTURECAPS_PROJECTED        | D3DPTEXTURECAPS_CUBEMAP             | D3DPTEXTURECAPS_COLORKEYBLEND);
1401
1402     Desc7->dpcLineCaps.dwTextureFilterCaps &= (
1403         D3DPTFILTERCAPS_NEAREST          | D3DPTFILTERCAPS_LINEAR              | D3DPTFILTERCAPS_MIPNEAREST          |
1404         D3DPTFILTERCAPS_MIPLINEAR        | D3DPTFILTERCAPS_LINEARMIPNEAREST    | D3DPTFILTERCAPS_LINEARMIPLINEAR     |
1405         D3DPTFILTERCAPS_MINFPOINT        | D3DPTFILTERCAPS_MINFLINEAR          | D3DPTFILTERCAPS_MINFANISOTROPIC     |
1406         D3DPTFILTERCAPS_MIPFPOINT        | D3DPTFILTERCAPS_MIPFLINEAR          | D3DPTFILTERCAPS_MAGFPOINT           |
1407         D3DPTFILTERCAPS_MAGFLINEAR       | D3DPTFILTERCAPS_MAGFANISOTROPIC     | D3DPTFILTERCAPS_MAGFAFLATCUBIC      |
1408         D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC);
1409
1410     Desc7->dpcLineCaps.dwTextureBlendCaps &= (
1411         D3DPTBLENDCAPS_DECAL             | D3DPTBLENDCAPS_MODULATE             | D3DPTBLENDCAPS_DECALALPHA           |
1412         D3DPTBLENDCAPS_MODULATEALPHA     | D3DPTBLENDCAPS_DECALMASK            | D3DPTBLENDCAPS_MODULATEMASK         |
1413         D3DPTBLENDCAPS_COPY              | D3DPTBLENDCAPS_ADD);
1414
1415     Desc7->dpcLineCaps.dwTextureAddressCaps &= (
1416         D3DPTADDRESSCAPS_WRAP            | D3DPTADDRESSCAPS_MIRROR             | D3DPTADDRESSCAPS_CLAMP              |
1417         D3DPTADDRESSCAPS_BORDER          | D3DPTADDRESSCAPS_INDEPENDENTUV);
1418
1419     if(!(Desc7->dpcLineCaps.dwTextureCaps & D3DPTEXTURECAPS_POW2)) {
1420         /* DirectX7 always has the np2 flag set, no matter what the card supports. Some old games(rollcage)
1421          * check the caps incorrectly. If wined3d supports nonpow2 textures it also has np2 conditional support
1422          */
1423         Desc7->dpcLineCaps.dwTextureCaps |= D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL;
1424     }
1425     /* Fill the missing members, and do some fixup */
1426     Desc7->dpcLineCaps.dwSize = sizeof(Desc7->dpcLineCaps);
1427     Desc7->dpcLineCaps.dwTextureBlendCaps = D3DPTBLENDCAPS_ADD | D3DPTBLENDCAPS_MODULATEMASK |
1428                                             D3DPTBLENDCAPS_COPY | D3DPTBLENDCAPS_DECAL |
1429                                             D3DPTBLENDCAPS_DECALALPHA | D3DPTBLENDCAPS_DECALMASK |
1430                                             D3DPTBLENDCAPS_MODULATE | D3DPTBLENDCAPS_MODULATEALPHA;
1431     Desc7->dpcLineCaps.dwStippleWidth = 32;
1432     Desc7->dpcLineCaps.dwStippleHeight = 32;
1433     /* Use the same for the TriCaps */
1434     Desc7->dpcTriCaps = Desc7->dpcLineCaps;
1435
1436     Desc7->dwDeviceRenderBitDepth = DDBD_16 | DDBD_24 | DDBD_32;
1437     Desc7->dwDeviceZBufferBitDepth = DDBD_16 | DDBD_24;
1438     Desc7->dwMinTextureWidth = 1;
1439     Desc7->dwMinTextureHeight = 1;
1440
1441     /* Convert DWORDs safely to WORDs */
1442     if(WCaps.MaxTextureBlendStages > 65535) Desc7->wMaxTextureBlendStages = 65535;
1443     else Desc7->wMaxTextureBlendStages = (WORD) WCaps.MaxTextureBlendStages;
1444     if(WCaps.MaxSimultaneousTextures > 65535) Desc7->wMaxSimultaneousTextures = 65535;
1445     else Desc7->wMaxSimultaneousTextures = (WORD) WCaps.MaxSimultaneousTextures;
1446
1447     if(WCaps.MaxUserClipPlanes > 65535) Desc7->wMaxUserClipPlanes = 65535;
1448     else Desc7->wMaxUserClipPlanes = (WORD) WCaps.MaxUserClipPlanes;
1449     if(WCaps.MaxVertexBlendMatrices > 65535) Desc7->wMaxVertexBlendMatrices = 65535;
1450     else Desc7->wMaxVertexBlendMatrices = (WORD) WCaps.MaxVertexBlendMatrices;
1451
1452     Desc7->deviceGUID = IID_IDirect3DTnLHalDevice;
1453
1454     Desc7->dwReserved1 = 0;
1455     Desc7->dwReserved2 = 0;
1456     Desc7->dwReserved3 = 0;
1457     Desc7->dwReserved4 = 0;
1458
1459     /* Fill the old structure */
1460     memset(Desc123, 0x0, sizeof(D3DDEVICEDESC));
1461     Desc123->dwSize = sizeof(D3DDEVICEDESC);
1462     Desc123->dwFlags = D3DDD_COLORMODEL            |
1463                        D3DDD_DEVCAPS               |
1464                        D3DDD_TRANSFORMCAPS         |
1465                        D3DDD_BCLIPPING             |
1466                        D3DDD_LIGHTINGCAPS          |
1467                        D3DDD_LINECAPS              |
1468                        D3DDD_TRICAPS               |
1469                        D3DDD_DEVICERENDERBITDEPTH  |
1470                        D3DDD_DEVICEZBUFFERBITDEPTH |
1471                        D3DDD_MAXBUFFERSIZE         |
1472                        D3DDD_MAXVERTEXCOUNT;
1473     Desc123->dcmColorModel = D3DCOLOR_RGB;
1474     Desc123->dwDevCaps = Desc7->dwDevCaps;
1475     Desc123->dtcTransformCaps.dwSize = sizeof(D3DTRANSFORMCAPS);
1476     Desc123->dtcTransformCaps.dwCaps = D3DTRANSFORMCAPS_CLIP;
1477     Desc123->bClipping = TRUE;
1478     Desc123->dlcLightingCaps.dwSize = sizeof(D3DLIGHTINGCAPS);
1479     Desc123->dlcLightingCaps.dwCaps = D3DLIGHTCAPS_DIRECTIONAL | D3DLIGHTCAPS_PARALLELPOINT | D3DLIGHTCAPS_POINT | D3DLIGHTCAPS_SPOT;
1480     Desc123->dlcLightingCaps.dwLightingModel = D3DLIGHTINGMODEL_RGB;
1481     Desc123->dlcLightingCaps.dwNumLights = Desc7->dwMaxActiveLights;
1482
1483     Desc123->dpcLineCaps.dwSize = sizeof(D3DPRIMCAPS);
1484     Desc123->dpcLineCaps.dwMiscCaps = Desc7->dpcLineCaps.dwMiscCaps;
1485     Desc123->dpcLineCaps.dwRasterCaps = Desc7->dpcLineCaps.dwRasterCaps;
1486     Desc123->dpcLineCaps.dwZCmpCaps = Desc7->dpcLineCaps.dwZCmpCaps;
1487     Desc123->dpcLineCaps.dwSrcBlendCaps = Desc7->dpcLineCaps.dwSrcBlendCaps;
1488     Desc123->dpcLineCaps.dwDestBlendCaps = Desc7->dpcLineCaps.dwDestBlendCaps;
1489     Desc123->dpcLineCaps.dwShadeCaps = Desc7->dpcLineCaps.dwShadeCaps;
1490     Desc123->dpcLineCaps.dwTextureCaps = Desc7->dpcLineCaps.dwTextureCaps;
1491     Desc123->dpcLineCaps.dwTextureFilterCaps = Desc7->dpcLineCaps.dwTextureFilterCaps;
1492     Desc123->dpcLineCaps.dwTextureBlendCaps = Desc7->dpcLineCaps.dwTextureBlendCaps;
1493     Desc123->dpcLineCaps.dwTextureAddressCaps = Desc7->dpcLineCaps.dwTextureAddressCaps;
1494     Desc123->dpcLineCaps.dwStippleWidth = Desc7->dpcLineCaps.dwStippleWidth;
1495     Desc123->dpcLineCaps.dwAlphaCmpCaps = Desc7->dpcLineCaps.dwAlphaCmpCaps;
1496
1497     Desc123->dpcTriCaps.dwSize = sizeof(D3DPRIMCAPS);
1498     Desc123->dpcTriCaps.dwMiscCaps = Desc7->dpcTriCaps.dwMiscCaps;
1499     Desc123->dpcTriCaps.dwRasterCaps = Desc7->dpcTriCaps.dwRasterCaps;
1500     Desc123->dpcTriCaps.dwZCmpCaps = Desc7->dpcTriCaps.dwZCmpCaps;
1501     Desc123->dpcTriCaps.dwSrcBlendCaps = Desc7->dpcTriCaps.dwSrcBlendCaps;
1502     Desc123->dpcTriCaps.dwDestBlendCaps = Desc7->dpcTriCaps.dwDestBlendCaps;
1503     Desc123->dpcTriCaps.dwShadeCaps = Desc7->dpcTriCaps.dwShadeCaps;
1504     Desc123->dpcTriCaps.dwTextureCaps = Desc7->dpcTriCaps.dwTextureCaps;
1505     Desc123->dpcTriCaps.dwTextureFilterCaps = Desc7->dpcTriCaps.dwTextureFilterCaps;
1506     Desc123->dpcTriCaps.dwTextureBlendCaps = Desc7->dpcTriCaps.dwTextureBlendCaps;
1507     Desc123->dpcTriCaps.dwTextureAddressCaps = Desc7->dpcTriCaps.dwTextureAddressCaps;
1508     Desc123->dpcTriCaps.dwStippleWidth = Desc7->dpcTriCaps.dwStippleWidth;
1509     Desc123->dpcTriCaps.dwAlphaCmpCaps = Desc7->dpcTriCaps.dwAlphaCmpCaps;
1510
1511     Desc123->dwDeviceRenderBitDepth = Desc7->dwDeviceRenderBitDepth;
1512     Desc123->dwDeviceZBufferBitDepth = Desc7->dwDeviceZBufferBitDepth;
1513     Desc123->dwMaxBufferSize = 0;
1514     Desc123->dwMaxVertexCount = 65536;
1515     Desc123->dwMinTextureWidth  = Desc7->dwMinTextureWidth;
1516     Desc123->dwMinTextureHeight = Desc7->dwMinTextureHeight;
1517     Desc123->dwMaxTextureWidth  = Desc7->dwMaxTextureWidth;
1518     Desc123->dwMaxTextureHeight = Desc7->dwMaxTextureHeight;
1519     Desc123->dwMinStippleWidth  = 1;
1520     Desc123->dwMinStippleHeight = 1;
1521     Desc123->dwMaxStippleWidth  = 32;
1522     Desc123->dwMaxStippleHeight = 32;
1523     Desc123->dwMaxTextureRepeat = Desc7->dwMaxTextureRepeat;
1524     Desc123->dwMaxTextureAspectRatio = Desc7->dwMaxTextureAspectRatio;
1525     Desc123->dwMaxAnisotropy = Desc7->dwMaxAnisotropy;
1526     Desc123->dvGuardBandLeft = Desc7->dvGuardBandLeft;
1527     Desc123->dvGuardBandRight = Desc7->dvGuardBandRight;
1528     Desc123->dvGuardBandTop = Desc7->dvGuardBandTop;
1529     Desc123->dvGuardBandBottom = Desc7->dvGuardBandBottom;
1530     Desc123->dvExtentsAdjust = Desc7->dvExtentsAdjust;
1531     Desc123->dwStencilCaps = Desc7->dwStencilCaps;
1532     Desc123->dwFVFCaps = Desc7->dwFVFCaps;
1533     Desc123->dwTextureOpCaps = Desc7->dwTextureOpCaps;
1534     Desc123->wMaxTextureBlendStages = Desc7->wMaxTextureBlendStages;
1535     Desc123->wMaxSimultaneousTextures = Desc7->wMaxSimultaneousTextures;
1536
1537     return DD_OK;
1538 }
1539 /*****************************************************************************
1540  * IDirect3D vtables in various versions
1541  *****************************************************************************/
1542
1543 const IDirect3DVtbl IDirect3D1_Vtbl =
1544 {
1545     /*** IUnknown methods ***/
1546     Thunk_IDirect3DImpl_1_QueryInterface,
1547     Thunk_IDirect3DImpl_1_AddRef,
1548     Thunk_IDirect3DImpl_1_Release,
1549     /*** IDirect3D methods ***/
1550     IDirect3DImpl_1_Initialize,
1551     Thunk_IDirect3DImpl_1_EnumDevices,
1552     Thunk_IDirect3DImpl_1_CreateLight,
1553     Thunk_IDirect3DImpl_1_CreateMaterial,
1554     Thunk_IDirect3DImpl_1_CreateViewport,
1555     Thunk_IDirect3DImpl_1_FindDevice
1556 };
1557
1558 const IDirect3D2Vtbl IDirect3D2_Vtbl =
1559 {
1560     /*** IUnknown methods ***/
1561     Thunk_IDirect3DImpl_2_QueryInterface,
1562     Thunk_IDirect3DImpl_2_AddRef,
1563     Thunk_IDirect3DImpl_2_Release,
1564     /*** IDirect3D2 methods ***/
1565     Thunk_IDirect3DImpl_2_EnumDevices,
1566     Thunk_IDirect3DImpl_2_CreateLight,
1567     Thunk_IDirect3DImpl_2_CreateMaterial,
1568     Thunk_IDirect3DImpl_2_CreateViewport,
1569     Thunk_IDirect3DImpl_2_FindDevice,
1570     Thunk_IDirect3DImpl_2_CreateDevice
1571 };
1572
1573 const IDirect3D3Vtbl IDirect3D3_Vtbl =
1574 {
1575     /*** IUnknown methods ***/
1576     Thunk_IDirect3DImpl_3_QueryInterface,
1577     Thunk_IDirect3DImpl_3_AddRef,
1578     Thunk_IDirect3DImpl_3_Release,
1579     /*** IDirect3D3 methods ***/
1580     IDirect3DImpl_3_EnumDevices,
1581     IDirect3DImpl_3_CreateLight,
1582     IDirect3DImpl_3_CreateMaterial,
1583     IDirect3DImpl_3_CreateViewport,
1584     IDirect3DImpl_3_FindDevice,
1585     Thunk_IDirect3DImpl_3_CreateDevice,
1586     Thunk_IDirect3DImpl_3_CreateVertexBuffer,
1587     Thunk_IDirect3DImpl_3_EnumZBufferFormats,
1588     Thunk_IDirect3DImpl_3_EvictManagedTextures
1589 };
1590
1591 const IDirect3D7Vtbl IDirect3D7_Vtbl =
1592 {
1593     /*** IUnknown methods ***/
1594     Thunk_IDirect3DImpl_7_QueryInterface,
1595     Thunk_IDirect3DImpl_7_AddRef,
1596     Thunk_IDirect3DImpl_7_Release,
1597     /*** IDirect3D7 methods ***/
1598     IDirect3DImpl_7_EnumDevices,
1599     IDirect3DImpl_7_CreateDevice,
1600     IDirect3DImpl_7_CreateVertexBuffer,
1601     IDirect3DImpl_7_EnumZBufferFormats,
1602     IDirect3DImpl_7_EvictManagedTextures
1603 };