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

   1 /*
   2  * Copyright 1997-2000 Marcus Meissner
   3  * Copyright 1998-2000 Lionel Ulmer
   4  * Copyright 2000-2001 TransGaming Technologies Inc.
   5  * Copyright 2006 Stefan Dösinger
   6  * Copyright 2008 Denver Gingerich
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include "ddraw_private.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  29
  30 /* Device identifier. Don't relay it to WineD3D */
  31 static const DDDEVICEIDENTIFIER2 deviceidentifier =
  32 {
  33     "display",
  34     "DirectDraw HAL",
  35     { { 0x00010001, 0x00010001 } },
  36     0, 0, 0, 0,
  37     /* a8373c10-7ac4-4deb-849a-009844d08b2d */
  38     {0xa8373c10,0x7ac4,0x4deb, {0x84,0x9a,0x00,0x98,0x44,0xd0,0x8b,0x2d}},
  39     0
  40 };
  41
  42 static void STDMETHODCALLTYPE ddraw_null_wined3d_object_destroyed(void *parent) {}
  43
  44 const struct wined3d_parent_ops ddraw_null_wined3d_parent_ops =
  45 {
  46     ddraw_null_wined3d_object_destroyed,
  47 };
  48
  49 static inline IDirectDrawImpl *ddraw_from_ddraw1(IDirectDraw *iface)
  50 {
  51     return (IDirectDrawImpl *)((char*)iface - FIELD_OFFSET(IDirectDrawImpl, IDirectDraw_vtbl));
  52 }
  53
  54 static inline IDirectDrawImpl *ddraw_from_ddraw2(IDirectDraw2 *iface)
  55 {
  56     return (IDirectDrawImpl *)((char*)iface - FIELD_OFFSET(IDirectDrawImpl, IDirectDraw2_vtbl));
  57 }
  58
  59 static inline IDirectDrawImpl *ddraw_from_ddraw3(IDirectDraw3 *iface)
  60 {
  61     return (IDirectDrawImpl *)((char*)iface - FIELD_OFFSET(IDirectDrawImpl, IDirectDraw3_vtbl));
  62 }
  63
  64 static inline IDirectDrawImpl *ddraw_from_ddraw4(IDirectDraw4 *iface)
  65 {
  66     return (IDirectDrawImpl *)((char*)iface - FIELD_OFFSET(IDirectDrawImpl, IDirectDraw4_vtbl));
  67 }
  68
  69 /*****************************************************************************
  70  * IUnknown Methods
  71  *****************************************************************************/
  72
  73 /*****************************************************************************
  74  * IDirectDraw7::QueryInterface
  75  *
  76  * Queries different interfaces of the DirectDraw object. It can return
  77  * IDirectDraw interfaces in version 1, 2, 4 and 7, and IDirect3D interfaces
  78  * in version 1, 2, 3 and 7. An IDirect3DDevice can be created with this
  79  * method.
  80  * The returned interface is AddRef()-ed before it's returned
  81  *
  82  * Used for version 1, 2, 4 and 7
  83  *
  84  * Params:
  85  *  refiid: Interface ID asked for
  86  *  obj: Used to return the interface pointer
  87  *
  88  * Returns:
  89  *  S_OK if an interface was found
  90  *  E_NOINTERFACE if the requested interface wasn't found
  91  *
  92  *****************************************************************************/
  93 static HRESULT WINAPI ddraw7_QueryInterface(IDirectDraw7 *iface, REFIID refiid, void **obj)
  94 {
  95     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
  96
  97     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(refiid), obj);
  98
  99     /* Can change surface impl type */
 100     EnterCriticalSection(&ddraw_cs);
 101
 102     /* According to COM docs, if the QueryInterface fails, obj should be set to NULL */
 103     *obj = NULL;
 104
 105     if(!refiid)
 106     {
 107         LeaveCriticalSection(&ddraw_cs);
 108         return DDERR_INVALIDPARAMS;
 109     }
 110
 111     /* Check DirectDraw Interfaces */
 112     if ( IsEqualGUID( &IID_IUnknown, refiid ) ||
 113          IsEqualGUID( &IID_IDirectDraw7, refiid ) )
 114     {
 115         *obj = This;
 116         TRACE("(%p) Returning IDirectDraw7 interface at %p\n", This, *obj);
 117     }
 118     else if ( IsEqualGUID( &IID_IDirectDraw4, refiid ) )
 119     {
 120         *obj = &This->IDirectDraw4_vtbl;
 121         TRACE("(%p) Returning IDirectDraw4 interface at %p\n", This, *obj);
 122     }
 123     else if ( IsEqualGUID( &IID_IDirectDraw3, refiid ) )
 124     {
 125         /* This Interface exists in ddrawex.dll, it is implemented in a wrapper */
 126         WARN("IDirectDraw3 is not valid in ddraw.dll\n");
 127         *obj = NULL;
 128         LeaveCriticalSection(&ddraw_cs);
 129         return E_NOINTERFACE;
 130     }
 131     else if ( IsEqualGUID( &IID_IDirectDraw2, refiid ) )
 132     {
 133         *obj = &This->IDirectDraw2_vtbl;
 134         TRACE("(%p) Returning IDirectDraw2 interface at %p\n", This, *obj);
 135     }
 136     else if ( IsEqualGUID( &IID_IDirectDraw, refiid ) )
 137     {
 138         *obj = &This->IDirectDraw_vtbl;
 139         TRACE("(%p) Returning IDirectDraw interface at %p\n", This, *obj);
 140     }
 141
 142     /* Direct3D
 143      * The refcount unit test revealed that an IDirect3D7 interface can only be queried
 144      * from a DirectDraw object that was created as an IDirectDraw7 interface. No idea
 145      * who had this idea and why. The older interfaces can query and IDirect3D version
 146      * because they are all created as IDirectDraw(1). This isn't really crucial behavior,
 147      * and messy to implement with the common creation function, so it has been left out here.
 148      */
 149     else if ( IsEqualGUID( &IID_IDirect3D  , refiid ) ||
 150               IsEqualGUID( &IID_IDirect3D2 , refiid ) ||
 151               IsEqualGUID( &IID_IDirect3D3 , refiid ) ||
 152               IsEqualGUID( &IID_IDirect3D7 , refiid ) )
 153     {
 154         /* Check the surface implementation */
 155         if(This->ImplType == SURFACE_UNKNOWN)
 156         {
 157             /* Apps may create the IDirect3D Interface before the primary surface.
 158              * set the surface implementation */
 159             This->ImplType = SURFACE_OPENGL;
 160             TRACE("(%p) Choosing OpenGL surfaces because a Direct3D interface was requested\n", This);
 161         }
 162         else if(This->ImplType != SURFACE_OPENGL && DefaultSurfaceType == SURFACE_UNKNOWN)
 163         {
 164             ERR("(%p) The App is requesting a D3D device, but a non-OpenGL surface type was choosen. Prepare for trouble!\n", This);
 165             ERR(" (%p) You may want to contact wine-devel for help\n", This);
 166             /* Should I assert(0) here??? */
 167         }
 168         else if(This->ImplType != SURFACE_OPENGL)
 169         {
 170             WARN("The app requests a Direct3D interface, but non-opengl surfaces where set in winecfg\n");
 171             /* Do not abort here, only reject 3D Device creation */
 172         }
 173
 174         if ( IsEqualGUID( &IID_IDirect3D  , refiid ) )
 175         {
 176             This->d3dversion = 1;
 177             *obj = &This->IDirect3D_vtbl;
 178             TRACE(" returning Direct3D interface at %p.\n", *obj);
 179         }
 180         else if ( IsEqualGUID( &IID_IDirect3D2  , refiid ) )
 181         {
 182             This->d3dversion = 2;
 183             *obj = &This->IDirect3D2_vtbl;
 184             TRACE(" returning Direct3D2 interface at %p.\n", *obj);
 185         }
 186         else if ( IsEqualGUID( &IID_IDirect3D3  , refiid ) )
 187         {
 188             This->d3dversion = 3;
 189             *obj = &This->IDirect3D3_vtbl;
 190             TRACE(" returning Direct3D3 interface at %p.\n", *obj);
 191         }
 192         else if(IsEqualGUID( &IID_IDirect3D7  , refiid ))
 193         {
 194             This->d3dversion = 7;
 195             *obj = &This->IDirect3D7_vtbl;
 196             TRACE(" returning Direct3D7 interface at %p.\n", *obj);
 197         }
 198     }
 199     else if (IsEqualGUID(refiid, &IID_IWineD3DDeviceParent))
 200     {
 201         *obj = &This->device_parent_vtbl;
 202     }
 203
 204     /* Unknown interface */
 205     else
 206     {
 207         ERR("(%p)->(%s, %p): No interface found\n", This, debugstr_guid(refiid), obj);
 208         LeaveCriticalSection(&ddraw_cs);
 209         return E_NOINTERFACE;
 210     }
 211
 212     IUnknown_AddRef( (IUnknown *) *obj );
 213     LeaveCriticalSection(&ddraw_cs);
 214     return S_OK;
 215 }
 216
 217 static HRESULT WINAPI ddraw4_QueryInterface(IDirectDraw4 *iface, REFIID riid, void **object)
 218 {
 219     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 220
 221     return ddraw7_QueryInterface((IDirectDraw7 *)ddraw_from_ddraw4(iface), riid, object);
 222 }
 223
 224 static HRESULT WINAPI ddraw3_QueryInterface(IDirectDraw3 *iface, REFIID riid, void **object)
 225 {
 226     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 227
 228     return ddraw7_QueryInterface((IDirectDraw7 *)ddraw_from_ddraw3(iface), riid, object);
 229 }
 230
 231 static HRESULT WINAPI ddraw2_QueryInterface(IDirectDraw2 *iface, REFIID riid, void **object)
 232 {
 233     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 234
 235     return ddraw7_QueryInterface((IDirectDraw7 *)ddraw_from_ddraw2(iface), riid, object);
 236 }
 237
 238 static HRESULT WINAPI ddraw1_QueryInterface(IDirectDraw *iface, REFIID riid, void **object)
 239 {
 240     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 241
 242     return ddraw7_QueryInterface((IDirectDraw7 *)ddraw_from_ddraw1(iface), riid, object);
 243 }
 244
 245 static HRESULT WINAPI d3d7_QueryInterface(IDirect3D7 *iface, REFIID riid, void **object)
 246 {
 247     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 248
 249     return ddraw7_QueryInterface((IDirectDraw7 *)ddraw_from_d3d7(iface), riid, object);
 250 }
 251
 252 static HRESULT WINAPI d3d3_QueryInterface(IDirect3D3 *iface, REFIID riid, void **object)
 253 {
 254     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 255
 256     return ddraw7_QueryInterface((IDirectDraw7 *)ddraw_from_d3d3(iface), riid, object);
 257 }
 258
 259 static HRESULT WINAPI d3d2_QueryInterface(IDirect3D2 *iface, REFIID riid, void **object)
 260 {
 261     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 262
 263     return ddraw7_QueryInterface((IDirectDraw7 *)ddraw_from_d3d2(iface), riid, object);
 264 }
 265
 266 static HRESULT WINAPI d3d1_QueryInterface(IDirect3D *iface, REFIID riid, void **object)
 267 {
 268     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 269
 270     return ddraw7_QueryInterface((IDirectDraw7 *)ddraw_from_d3d1(iface), riid, object);
 271 }
 272
 273 /*****************************************************************************
 274  * IDirectDraw7::AddRef
 275  *
 276  * Increases the interfaces refcount, basically
 277  *
 278  * DDraw refcounting is a bit tricky. The different DirectDraw interface
 279  * versions have individual refcounts, but the IDirect3D interfaces do not.
 280  * All interfaces are from one object, that means calling QueryInterface on an
 281  * IDirectDraw7 interface for an IDirectDraw4 interface does not create a new
 282  * IDirectDrawImpl object.
 283  *
 284  * That means all AddRef and Release implementations of IDirectDrawX work
 285  * with their own counter, and IDirect3DX::AddRef thunk to IDirectDraw (1),
 286  * except of IDirect3D7 which thunks to IDirectDraw7
 287  *
 288  * Returns: The new refcount
 289  *
 290  *****************************************************************************/
 291 static ULONG WINAPI ddraw7_AddRef(IDirectDraw7 *iface)
 292 {
 293     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
 294     ULONG ref = InterlockedIncrement(&This->ref7);
 295
 296     TRACE("%p increasing refcount to %u.\n", This, ref);
 297
 298     if(ref == 1) InterlockedIncrement(&This->numIfaces);
 299
 300     return ref;
 301 }
 302
 303 static ULONG WINAPI ddraw4_AddRef(IDirectDraw4 *iface)
 304 {
 305     IDirectDrawImpl *ddraw = ddraw_from_ddraw4(iface);
 306     ULONG ref = InterlockedIncrement(&ddraw->ref4);
 307
 308     TRACE("%p increasing refcount to %u.\n", ddraw, ref);
 309
 310     if (ref == 1) InterlockedIncrement(&ddraw->numIfaces);
 311
 312     return ref;
 313 }
 314
 315 static ULONG WINAPI ddraw3_AddRef(IDirectDraw3 *iface)
 316 {
 317     IDirectDrawImpl *ddraw = ddraw_from_ddraw3(iface);
 318     ULONG ref = InterlockedIncrement(&ddraw->ref3);
 319
 320     TRACE("%p increasing refcount to %u.\n", ddraw, ref);
 321
 322     if (ref == 1) InterlockedIncrement(&ddraw->numIfaces);
 323
 324     return ref;
 325 }
 326
 327 static ULONG WINAPI ddraw2_AddRef(IDirectDraw2 *iface)
 328 {
 329     IDirectDrawImpl *ddraw = ddraw_from_ddraw2(iface);
 330     ULONG ref = InterlockedIncrement(&ddraw->ref2);
 331
 332     TRACE("%p increasing refcount to %u.\n", ddraw, ref);
 333
 334     if (ref == 1) InterlockedIncrement(&ddraw->numIfaces);
 335
 336     return ref;
 337 }
 338
 339 static ULONG WINAPI ddraw1_AddRef(IDirectDraw *iface)
 340 {
 341     IDirectDrawImpl *ddraw = ddraw_from_ddraw1(iface);
 342     ULONG ref = InterlockedIncrement(&ddraw->ref1);
 343
 344     TRACE("%p increasing refcount to %u.\n", ddraw, ref);
 345
 346     if (ref == 1) InterlockedIncrement(&ddraw->numIfaces);
 347
 348     return ref;
 349 }
 350
 351 static ULONG WINAPI d3d7_AddRef(IDirect3D7 *iface)
 352 {
 353     TRACE("iface %p.\n", iface);
 354
 355     return ddraw7_AddRef((IDirectDraw7 *)ddraw_from_d3d7(iface));
 356 }
 357
 358 static ULONG WINAPI d3d3_AddRef(IDirect3D3 *iface)
 359 {
 360     TRACE("iface %p.\n", iface);
 361
 362     return ddraw1_AddRef((IDirectDraw *)&ddraw_from_d3d3(iface)->IDirectDraw_vtbl);
 363 }
 364
 365 static ULONG WINAPI d3d2_AddRef(IDirect3D2 *iface)
 366 {
 367     TRACE("iface %p.\n", iface);
 368
 369     return ddraw1_AddRef((IDirectDraw *)&ddraw_from_d3d2(iface)->IDirectDraw_vtbl);
 370 }
 371
 372 static ULONG WINAPI d3d1_AddRef(IDirect3D *iface)
 373 {
 374     TRACE("iface %p.\n", iface);
 375
 376     return ddraw1_AddRef((IDirectDraw *)&ddraw_from_d3d1(iface)->IDirectDraw_vtbl);
 377 }
 378
 379 /*****************************************************************************
 380  * ddraw_destroy
 381  *
 382  * Destroys a ddraw object if all refcounts are 0. This is to share code
 383  * between the IDirectDrawX::Release functions
 384  *
 385  * Params:
 386  *  This: DirectDraw object to destroy
 387  *
 388  *****************************************************************************/
 389 static void ddraw_destroy(IDirectDrawImpl *This)
 390 {
 391     IDirectDraw7_SetCooperativeLevel((IDirectDraw7 *)This, NULL, DDSCL_NORMAL);
 392     IDirectDraw7_RestoreDisplayMode((IDirectDraw7 *)This);
 393
 394     /* Destroy the device window if we created one */
 395     if(This->devicewindow != 0)
 396     {
 397         TRACE(" (%p) Destroying the device window %p\n", This, This->devicewindow);
 398         DestroyWindow(This->devicewindow);
 399         This->devicewindow = 0;
 400     }
 401
 402     EnterCriticalSection(&ddraw_cs);
 403     list_remove(&This->ddraw_list_entry);
 404     LeaveCriticalSection(&ddraw_cs);
 405
 406     /* Release the attached WineD3D stuff */
 407     IWineD3DDevice_Release(This->wineD3DDevice);
 408     IWineD3D_Release(This->wineD3D);
 409
 410     /* Now free the object */
 411     HeapFree(GetProcessHeap(), 0, This);
 412 }
 413
 414 /*****************************************************************************
 415  * IDirectDraw7::Release
 416  *
 417  * Decreases the refcount. If the refcount falls to 0, the object is destroyed
 418  *
 419  * Returns: The new refcount
 420  *****************************************************************************/
 421 static ULONG WINAPI ddraw7_Release(IDirectDraw7 *iface)
 422 {
 423     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
 424     ULONG ref = InterlockedDecrement(&This->ref7);
 425
 426     TRACE("%p decreasing refcount to %u.\n", This, ref);
 427
 428     if (!ref && !InterlockedDecrement(&This->numIfaces))
 429         ddraw_destroy(This);
 430
 431     return ref;
 432 }
 433
 434 static ULONG WINAPI ddraw4_Release(IDirectDraw4 *iface)
 435 {
 436     IDirectDrawImpl *ddraw = ddraw_from_ddraw4(iface);
 437     ULONG ref = InterlockedDecrement(&ddraw->ref4);
 438
 439     TRACE("%p decreasing refcount to %u.\n", ddraw, ref);
 440
 441     if (!ref && !InterlockedDecrement(&ddraw->numIfaces))
 442         ddraw_destroy(ddraw);
 443
 444     return ref;
 445 }
 446
 447 static ULONG WINAPI ddraw3_Release(IDirectDraw3 *iface)
 448 {
 449     IDirectDrawImpl *ddraw = ddraw_from_ddraw3(iface);
 450     ULONG ref = InterlockedDecrement(&ddraw->ref3);
 451
 452     TRACE("%p decreasing refcount to %u.\n", ddraw, ref);
 453
 454     if (!ref && !InterlockedDecrement(&ddraw->numIfaces))
 455         ddraw_destroy(ddraw);
 456
 457     return ref;
 458 }
 459
 460 static ULONG WINAPI ddraw2_Release(IDirectDraw2 *iface)
 461 {
 462     IDirectDrawImpl *ddraw = ddraw_from_ddraw2(iface);
 463     ULONG ref = InterlockedDecrement(&ddraw->ref2);
 464
 465     TRACE("%p decreasing refcount to %u.\n", ddraw, ref);
 466
 467     if (!ref && !InterlockedDecrement(&ddraw->numIfaces))
 468         ddraw_destroy(ddraw);
 469
 470     return ref;
 471 }
 472
 473 static ULONG WINAPI ddraw1_Release(IDirectDraw *iface)
 474 {
 475     IDirectDrawImpl *ddraw = ddraw_from_ddraw1(iface);
 476     ULONG ref = InterlockedDecrement(&ddraw->ref1);
 477
 478     TRACE("%p decreasing refcount to %u.\n", ddraw, ref);
 479
 480     if (!ref && !InterlockedDecrement(&ddraw->numIfaces))
 481         ddraw_destroy(ddraw);
 482
 483     return ref;
 484 }
 485
 486 static ULONG WINAPI d3d7_Release(IDirect3D7 *iface)
 487 {
 488     TRACE("iface %p.\n", iface);
 489
 490     return ddraw7_Release((IDirectDraw7 *)ddraw_from_d3d7(iface));
 491 }
 492
 493 static ULONG WINAPI d3d3_Release(IDirect3D3 *iface)
 494 {
 495     TRACE("iface %p.\n", iface);
 496
 497     return ddraw1_Release((IDirectDraw *)&ddraw_from_d3d3(iface)->IDirectDraw_vtbl);
 498 }
 499
 500 static ULONG WINAPI d3d2_Release(IDirect3D2 *iface)
 501 {
 502     TRACE("iface %p.\n", iface);
 503
 504     return ddraw1_Release((IDirectDraw *)&ddraw_from_d3d2(iface)->IDirectDraw_vtbl);
 505 }
 506
 507 static ULONG WINAPI d3d1_Release(IDirect3D *iface)
 508 {
 509     TRACE("iface %p.\n", iface);
 510
 511     return ddraw1_Release((IDirectDraw *)&ddraw_from_d3d1(iface)->IDirectDraw_vtbl);
 512 }
 513
 514 /*****************************************************************************
 515  * IDirectDraw methods
 516  *****************************************************************************/
 517
 518 /*****************************************************************************
 519  * IDirectDraw7::SetCooperativeLevel
 520  *
 521  * Sets the cooperative level for the DirectDraw object, and the window
 522  * assigned to it. The cooperative level determines the general behavior
 523  * of the DirectDraw application
 524  *
 525  * Warning: This is quite tricky, as it's not really documented which
 526  * cooperative levels can be combined with each other. If a game fails
 527  * after this function, try to check the cooperative levels passed on
 528  * Windows, and if it returns something different.
 529  *
 530  * If you think that this function caused the failure because it writes a
 531  * fixme, be sure to run again with a +ddraw trace.
 532  *
 533  * What is known about cooperative levels (See the ddraw modes test):
 534  * DDSCL_EXCLUSIVE and DDSCL_FULLSCREEN must be used with each other
 535  * DDSCL_NORMAL is not compatible with DDSCL_EXCLUSIVE or DDSCL_FULLSCREEN
 536  * DDSCL_SETFOCUSWINDOW can be passed only in DDSCL_NORMAL mode, but after that
 537  * DDSCL_FULLSCREEN can be activated
 538  * DDSCL_SETFOCUSWINDOW may only be used with DDSCL_NOWINDOWCHANGES
 539  *
 540  * Handled flags: DDSCL_NORMAL, DDSCL_FULLSCREEN, DDSCL_EXCLUSIVE,
 541  *                DDSCL_SETFOCUSWINDOW (partially),
 542  *                DDSCL_MULTITHREADED (work in progress)
 543  *
 544  * Unhandled flags, which should be implemented
 545  *  DDSCL_SETDEVICEWINDOW: Sets a window specially used for rendering (I don't
 546  *  expect any difference to a normal window for wine)
 547  *  DDSCL_CREATEDEVICEWINDOW: Tells ddraw to create its own window for
 548  *  rendering (Possible test case: Half-Life)
 549  *
 550  * Unsure about these: DDSCL_FPUSETUP DDSCL_FPURESERVE
 551  *
 552  * These don't seem very important for wine:
 553  *  DDSCL_ALLOWREBOOT, DDSCL_NOWINDOWCHANGES, DDSCL_ALLOWMODEX
 554  *
 555  * Returns:
 556  *  DD_OK if the cooperative level was set successfully
 557  *  DDERR_INVALIDPARAMS if the passed cooperative level combination is invalid
 558  *  DDERR_HWNDALREADYSET if DDSCL_SETFOCUSWINDOW is passed in exclusive mode
 559  *   (Probably others too, have to investigate)
 560  *
 561  *****************************************************************************/
 562 static HRESULT WINAPI ddraw7_SetCooperativeLevel(IDirectDraw7 *iface, HWND hwnd, DWORD cooplevel)
 563 {
 564     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
 565     HWND window;
 566
 567     TRACE("iface %p, window %p, flags %#x.\n", iface, hwnd, cooplevel);
 568     DDRAW_dump_cooperativelevel(cooplevel);
 569
 570     EnterCriticalSection(&ddraw_cs);
 571
 572     /* Get the old window */
 573     window = This->dest_window;
 574
 575     /* Tests suggest that we need one of them: */
 576     if(!(cooplevel & (DDSCL_SETFOCUSWINDOW |
 577                       DDSCL_NORMAL         |
 578                       DDSCL_EXCLUSIVE      )))
 579     {
 580         TRACE("Incorrect cooplevel flags, returning DDERR_INVALIDPARAMS\n");
 581         LeaveCriticalSection(&ddraw_cs);
 582         return DDERR_INVALIDPARAMS;
 583     }
 584
 585     /* Handle those levels first which set various hwnds */
 586     if(cooplevel & DDSCL_SETFOCUSWINDOW)
 587     {
 588         /* This isn't compatible with a lot of flags */
 589         if(cooplevel & ( DDSCL_MULTITHREADED   |
 590                          DDSCL_FPUSETUP        |
 591                          DDSCL_FPUPRESERVE     |
 592                          DDSCL_ALLOWREBOOT     |
 593                          DDSCL_ALLOWMODEX      |
 594                          DDSCL_SETDEVICEWINDOW |
 595                          DDSCL_NORMAL          |
 596                          DDSCL_EXCLUSIVE       |
 597                          DDSCL_FULLSCREEN      ) )
 598         {
 599             TRACE("Called with incompatible flags, returning DDERR_INVALIDPARAMS\n");
 600             LeaveCriticalSection(&ddraw_cs);
 601             return DDERR_INVALIDPARAMS;
 602         }
 603         else if( (This->cooperative_level & DDSCL_FULLSCREEN) && window)
 604         {
 605             TRACE("Setting DDSCL_SETFOCUSWINDOW with an already set window, returning DDERR_HWNDALREADYSET\n");
 606             LeaveCriticalSection(&ddraw_cs);
 607             return DDERR_HWNDALREADYSET;
 608         }
 609
 610         This->focuswindow = hwnd;
 611         /* Won't use the hwnd param for anything else */
 612         hwnd = NULL;
 613
 614         /* Use the focus window for drawing too */
 615         This->dest_window = This->focuswindow;
 616
 617         /* Destroy the device window, if we have one */
 618         if(This->devicewindow)
 619         {
 620             DestroyWindow(This->devicewindow);
 621             This->devicewindow = NULL;
 622         }
 623     }
 624     /* DDSCL_NORMAL or DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE */
 625     if(cooplevel & DDSCL_NORMAL)
 626     {
 627         /* Can't coexist with fullscreen or exclusive */
 628         if(cooplevel & (DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE) )
 629         {
 630             TRACE("(%p) DDSCL_NORMAL is not compative with DDSCL_FULLSCREEN or DDSCL_EXCLUSIVE\n", This);
 631             LeaveCriticalSection(&ddraw_cs);
 632             return DDERR_INVALIDPARAMS;
 633         }
 634
 635         /* Switching from fullscreen? */
 636         if(This->cooperative_level & DDSCL_FULLSCREEN)
 637         {
 638             This->cooperative_level &= ~DDSCL_FULLSCREEN;
 639             This->cooperative_level &= ~DDSCL_EXCLUSIVE;
 640             This->cooperative_level &= ~DDSCL_ALLOWMODEX;
 641
 642             IWineD3DDevice_ReleaseFocusWindow(This->wineD3DDevice);
 643         }
 644
 645         /* Don't override focus windows or private device windows */
 646         if( hwnd &&
 647             !(This->focuswindow) &&
 648             !(This->devicewindow) &&
 649             (hwnd != window) )
 650         {
 651             This->dest_window = hwnd;
 652         }
 653     }
 654     else if(cooplevel & DDSCL_FULLSCREEN)
 655     {
 656         /* Needs DDSCL_EXCLUSIVE */
 657         if(!(cooplevel & DDSCL_EXCLUSIVE) )
 658         {
 659             TRACE("(%p) DDSCL_FULLSCREEN needs DDSCL_EXCLUSIVE\n", This);
 660             LeaveCriticalSection(&ddraw_cs);
 661             return DDERR_INVALIDPARAMS;
 662         }
 663         /* Need a HWND
 664         if(hwnd == 0)
 665         {
 666             TRACE("(%p) DDSCL_FULLSCREEN needs a HWND\n", This);
 667             return DDERR_INVALIDPARAMS;
 668         }
 669         */
 670
 671         This->cooperative_level &= ~DDSCL_NORMAL;
 672
 673         /* Don't override focus windows or private device windows */
 674         if( hwnd &&
 675             !(This->focuswindow) &&
 676             !(This->devicewindow) &&
 677             (hwnd != window) )
 678         {
 679             HRESULT hr = IWineD3DDevice_AcquireFocusWindow(This->wineD3DDevice, hwnd);
 680             if (FAILED(hr))
 681             {
 682                 ERR("Failed to acquire focus window, hr %#x.\n", hr);
 683                 LeaveCriticalSection(&ddraw_cs);
 684                 return hr;
 685             }
 686             This->dest_window = hwnd;
 687         }
 688     }
 689     else if(cooplevel & DDSCL_EXCLUSIVE)
 690     {
 691         TRACE("(%p) DDSCL_EXCLUSIVE needs DDSCL_FULLSCREEN\n", This);
 692         LeaveCriticalSection(&ddraw_cs);
 693         return DDERR_INVALIDPARAMS;
 694     }
 695
 696     if(cooplevel & DDSCL_CREATEDEVICEWINDOW)
 697     {
 698         /* Don't create a device window if a focus window is set */
 699         if( !(This->focuswindow) )
 700         {
 701             HWND devicewindow = CreateWindowExA(0, DDRAW_WINDOW_CLASS_NAME, "DDraw device window",
 702                     WS_POPUP, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
 703                     NULL, NULL, NULL, NULL);
 704             if (!devicewindow)
 705             {
 706                 ERR("Failed to create window, last error %#x.\n", GetLastError());
 707                 LeaveCriticalSection(&ddraw_cs);
 708                 return E_FAIL;
 709             }
 710
 711             ShowWindow(devicewindow, SW_SHOW);   /* Just to be sure */
 712             TRACE("(%p) Created a DDraw device window. HWND=%p\n", This, devicewindow);
 713
 714             This->devicewindow = devicewindow;
 715             This->dest_window = devicewindow;
 716         }
 717     }
 718
 719     if(cooplevel & DDSCL_MULTITHREADED && !(This->cooperative_level & DDSCL_MULTITHREADED))
 720     {
 721         /* Enable thread safety in wined3d */
 722         IWineD3DDevice_SetMultithreaded(This->wineD3DDevice);
 723     }
 724
 725     /* Unhandled flags */
 726     if(cooplevel & DDSCL_ALLOWREBOOT)
 727         WARN("(%p) Unhandled flag DDSCL_ALLOWREBOOT, harmless\n", This);
 728     if(cooplevel & DDSCL_ALLOWMODEX)
 729         WARN("(%p) Unhandled flag DDSCL_ALLOWMODEX, harmless\n", This);
 730     if(cooplevel & DDSCL_FPUSETUP)
 731         WARN("(%p) Unhandled flag DDSCL_FPUSETUP, harmless\n", This);
 732
 733     /* Store the cooperative_level */
 734     This->cooperative_level |= cooplevel;
 735     TRACE("SetCooperativeLevel retuning DD_OK\n");
 736     LeaveCriticalSection(&ddraw_cs);
 737     return DD_OK;
 738 }
 739
 740 static HRESULT WINAPI ddraw4_SetCooperativeLevel(IDirectDraw4 *iface, HWND window, DWORD flags)
 741 {
 742     TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
 743
 744     return ddraw7_SetCooperativeLevel((IDirectDraw7 *)ddraw_from_ddraw4(iface), window, flags);
 745 }
 746
 747 static HRESULT WINAPI ddraw3_SetCooperativeLevel(IDirectDraw3 *iface, HWND window, DWORD flags)
 748 {
 749     TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
 750
 751     return ddraw7_SetCooperativeLevel((IDirectDraw7 *)ddraw_from_ddraw3(iface), window, flags);
 752 }
 753
 754 static HRESULT WINAPI ddraw2_SetCooperativeLevel(IDirectDraw2 *iface, HWND window, DWORD flags)
 755 {
 756     TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
 757
 758     return ddraw7_SetCooperativeLevel((IDirectDraw7 *)ddraw_from_ddraw2(iface), window, flags);
 759 }
 760
 761 static HRESULT WINAPI ddraw1_SetCooperativeLevel(IDirectDraw *iface, HWND window, DWORD flags)
 762 {
 763     TRACE("iface %p, window %p, flags %#x.\n", iface, window, flags);
 764
 765     return ddraw7_SetCooperativeLevel((IDirectDraw7 *)ddraw_from_ddraw1(iface), window, flags);
 766 }
 767
 768 /*****************************************************************************
 769  *
 770  * Helper function for SetDisplayMode and RestoreDisplayMode
 771  *
 772  * Implements DirectDraw's SetDisplayMode, but ignores the value of
 773  * ForceRefreshRate, since it is already handled by
 774  * ddraw7_SetDisplayMode.  RestoreDisplayMode can use this function
 775  * without worrying that ForceRefreshRate will override the refresh rate.  For
 776  * argument and return value documentation, see
 777  * ddraw7_SetDisplayMode.
 778  *
 779  *****************************************************************************/
 780 static HRESULT ddraw_set_display_mode(IDirectDraw7 *iface, DWORD Width, DWORD Height,
 781         DWORD BPP, DWORD RefreshRate, DWORD Flags)
 782 {
 783     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
 784     WINED3DDISPLAYMODE Mode;
 785     HRESULT hr;
 786
 787     TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
 788             iface, Width, Height, BPP, RefreshRate, Flags);
 789
 790     EnterCriticalSection(&ddraw_cs);
 791     if( !Width || !Height )
 792     {
 793         ERR("Width %u, Height %u, what to do?\n", Width, Height);
 794         /* It looks like Need for Speed Porsche Unleashed expects DD_OK here */
 795         LeaveCriticalSection(&ddraw_cs);
 796         return DD_OK;
 797     }
 798
 799     /* Check the exclusive mode
 800     if(!(This->cooperative_level & DDSCL_EXCLUSIVE))
 801         return DDERR_NOEXCLUSIVEMODE;
 802      * This is WRONG. Don't know if the SDK is completely
 803      * wrong and if there are any conditions when DDERR_NOEXCLUSIVE
 804      * is returned, but Half-Life 1.1.1.1 (Steam version)
 805      * depends on this
 806      */
 807
 808     Mode.Width = Width;
 809     Mode.Height = Height;
 810     Mode.RefreshRate = RefreshRate;
 811     switch(BPP)
 812     {
 813         case 8:  Mode.Format = WINED3DFMT_P8_UINT;          break;
 814         case 15: Mode.Format = WINED3DFMT_B5G5R5X1_UNORM;   break;
 815         case 16: Mode.Format = WINED3DFMT_B5G6R5_UNORM;     break;
 816         case 24: Mode.Format = WINED3DFMT_B8G8R8_UNORM;     break;
 817         case 32: Mode.Format = WINED3DFMT_B8G8R8X8_UNORM;   break;
 818     }
 819
 820     /* TODO: The possible return values from msdn suggest that
 821      * the screen mode can't be changed if a surface is locked
 822      * or some drawing is in progress
 823      */
 824
 825     /* TODO: Lose the primary surface */
 826     hr = IWineD3DDevice_SetDisplayMode(This->wineD3DDevice,
 827                                        0, /* First swapchain */
 828                                        &Mode);
 829     LeaveCriticalSection(&ddraw_cs);
 830     switch(hr)
 831     {
 832         case WINED3DERR_NOTAVAILABLE:       return DDERR_UNSUPPORTED;
 833         default:                            return hr;
 834     }
 835 }
 836
 837 /*****************************************************************************
 838  * IDirectDraw7::SetDisplayMode
 839  *
 840  * Sets the display screen resolution, color depth and refresh frequency
 841  * when in fullscreen mode (in theory).
 842  * Possible return values listed in the SDK suggest that this method fails
 843  * when not in fullscreen mode, but this is wrong. Windows 2000 happily sets
 844  * the display mode in DDSCL_NORMAL mode without an hwnd specified.
 845  * It seems to be valid to pass 0 for With and Height, this has to be tested
 846  * It could mean that the current video mode should be left as-is. (But why
 847  * call it then?)
 848  *
 849  * Params:
 850  *  Height, Width: Screen dimension
 851  *  BPP: Color depth in Bits per pixel
 852  *  Refreshrate: Screen refresh rate
 853  *  Flags: Other stuff
 854  *
 855  * Returns
 856  *  DD_OK on success
 857  *
 858  *****************************************************************************/
 859 static HRESULT WINAPI ddraw7_SetDisplayMode(IDirectDraw7 *iface, DWORD Width, DWORD Height,
 860         DWORD BPP, DWORD RefreshRate, DWORD Flags)
 861 {
 862     TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
 863             iface, Width, Height, BPP, RefreshRate, Flags);
 864
 865     if (force_refresh_rate != 0)
 866     {
 867         TRACE("ForceRefreshRate overriding passed-in refresh rate (%u Hz) to %u Hz\n",
 868                 RefreshRate, force_refresh_rate);
 869         RefreshRate = force_refresh_rate;
 870     }
 871
 872     return ddraw_set_display_mode(iface, Width, Height, BPP, RefreshRate, Flags);
 873 }
 874
 875 static HRESULT WINAPI ddraw4_SetDisplayMode(IDirectDraw4 *iface,
 876         DWORD width, DWORD height, DWORD bpp, DWORD refresh_rate, DWORD flags)
 877 {
 878     TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
 879             iface, width, height, bpp, refresh_rate, flags);
 880
 881     return ddraw7_SetDisplayMode((IDirectDraw7 *)ddraw_from_ddraw4(iface),
 882             width, height, bpp, refresh_rate, flags);
 883 }
 884
 885 static HRESULT WINAPI ddraw3_SetDisplayMode(IDirectDraw3 *iface,
 886         DWORD width, DWORD height, DWORD bpp, DWORD refresh_rate, DWORD flags)
 887 {
 888     TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
 889             iface, width, height, bpp, refresh_rate, flags);
 890
 891     return ddraw7_SetDisplayMode((IDirectDraw7 *)ddraw_from_ddraw3(iface),
 892             width, height, bpp, refresh_rate, flags);
 893 }
 894
 895 static HRESULT WINAPI ddraw2_SetDisplayMode(IDirectDraw2 *iface,
 896         DWORD width, DWORD height, DWORD bpp, DWORD refresh_rate, DWORD flags)
 897 {
 898     TRACE("iface %p, width %u, height %u, bpp %u, refresh_rate %u, flags %#x.\n",
 899             iface, width, height, bpp, refresh_rate, flags);
 900
 901     return ddraw7_SetDisplayMode((IDirectDraw7 *)ddraw_from_ddraw2(iface),
 902             width, height, bpp, refresh_rate, flags);
 903 }
 904
 905 static HRESULT WINAPI ddraw1_SetDisplayMode(IDirectDraw *iface, DWORD width, DWORD height, DWORD bpp)
 906 {
 907     TRACE("iface %p, width %u, height %u, bpp %u.\n", iface, width, height, bpp);
 908
 909     return ddraw7_SetDisplayMode((IDirectDraw7 *)ddraw_from_ddraw1(iface), width, height, bpp, 0, 0);
 910 }
 911
 912 /*****************************************************************************
 913  * IDirectDraw7::RestoreDisplayMode
 914  *
 915  * Restores the display mode to what it was at creation time. Basically.
 916  *
 917  * A problem arises when there are 2 DirectDraw objects using the same hwnd:
 918  *  -> DD_1 finds the screen at 1400x1050x32 when created, sets it to 640x480x16
 919  *  -> DD_2 is created, finds the screen at 640x480x16, sets it to 1024x768x32
 920  *  -> DD_1 is released. The screen should be left at 1024x768x32.
 921  *  -> DD_2 is released. The screen should be set to 1400x1050x32
 922  * This case is unhandled right now, but Empire Earth does it this way.
 923  * (But perhaps there is something in SetCooperativeLevel to prevent this)
 924  *
 925  * The msdn says that this method resets the display mode to what it was before
 926  * SetDisplayMode was called. What if SetDisplayModes is called 2 times??
 927  *
 928  * Returns
 929  *  DD_OK on success
 930  *  DDERR_NOEXCLUSIVE mode if the device isn't in fullscreen mode
 931  *
 932  *****************************************************************************/
 933 static HRESULT WINAPI ddraw7_RestoreDisplayMode(IDirectDraw7 *iface)
 934 {
 935     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
 936
 937     TRACE("iface %p.\n", iface);
 938
 939     return ddraw_set_display_mode(iface, This->orig_width, This->orig_height, This->orig_bpp, 0, 0);
 940 }
 941
 942 static HRESULT WINAPI ddraw4_RestoreDisplayMode(IDirectDraw4 *iface)
 943 {
 944     TRACE("iface %p.\n", iface);
 945
 946     return ddraw7_RestoreDisplayMode((IDirectDraw7 *)ddraw_from_ddraw4(iface));
 947 }
 948
 949 static HRESULT WINAPI ddraw3_RestoreDisplayMode(IDirectDraw3 *iface)
 950 {
 951     TRACE("iface %p.\n", iface);
 952
 953     return ddraw7_RestoreDisplayMode((IDirectDraw7 *)ddraw_from_ddraw3(iface));
 954 }
 955
 956 static HRESULT WINAPI ddraw2_RestoreDisplayMode(IDirectDraw2 *iface)
 957 {
 958     TRACE("iface %p.\n", iface);
 959
 960     return ddraw7_RestoreDisplayMode((IDirectDraw7 *)ddraw_from_ddraw2(iface));
 961 }
 962
 963 static HRESULT WINAPI ddraw1_RestoreDisplayMode(IDirectDraw *iface)
 964 {
 965     TRACE("iface %p.\n", iface);
 966
 967     return ddraw7_RestoreDisplayMode((IDirectDraw7 *)ddraw_from_ddraw1(iface));
 968 }
 969
 970 /*****************************************************************************
 971  * IDirectDraw7::GetCaps
 972  *
 973  * Returns the drives capabilities
 974  *
 975  * Used for version 1, 2, 4 and 7
 976  *
 977  * Params:
 978  *  DriverCaps: Structure to write the Hardware accelerated caps to
 979  *  HelCaps: Structure to write the emulation caps to
 980  *
 981  * Returns
 982  *  This implementation returns DD_OK only
 983  *
 984  *****************************************************************************/
 985 static HRESULT WINAPI ddraw7_GetCaps(IDirectDraw7 *iface, DDCAPS *DriverCaps, DDCAPS *HELCaps)
 986 {
 987     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
 988     DDCAPS caps;
 989     WINED3DCAPS winecaps;
 990     HRESULT hr;
 991     DDSCAPS2 ddscaps = {0, 0, 0, 0};
 992
 993     TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, DriverCaps, HELCaps);
 994
 995     /* One structure must be != NULL */
 996     if( (!DriverCaps) && (!HELCaps) )
 997     {
 998         ERR("(%p) Invalid params to ddraw7_GetCaps\n", This);
 999         return DDERR_INVALIDPARAMS;
1000     }
1001
1002     memset(&caps, 0, sizeof(caps));
1003     memset(&winecaps, 0, sizeof(winecaps));
1004     caps.dwSize = sizeof(caps);
1005     EnterCriticalSection(&ddraw_cs);
1006     hr = IWineD3DDevice_GetDeviceCaps(This->wineD3DDevice, &winecaps);
1007     if(FAILED(hr)) {
1008         WARN("IWineD3DDevice::GetDeviceCaps failed\n");
1009         LeaveCriticalSection(&ddraw_cs);
1010         return hr;
1011     }
1012
1013     hr = IDirectDraw7_GetAvailableVidMem(iface, &ddscaps, &caps.dwVidMemTotal, &caps.dwVidMemFree);
1014     LeaveCriticalSection(&ddraw_cs);
1015     if(FAILED(hr)) {
1016         WARN("IDirectDraw7::GetAvailableVidMem failed\n");
1017         return hr;
1018     }
1019
1020     caps.dwCaps = winecaps.DirectDrawCaps.Caps;
1021     caps.dwCaps2 = winecaps.DirectDrawCaps.Caps2;
1022     caps.dwCKeyCaps = winecaps.DirectDrawCaps.CKeyCaps;
1023     caps.dwFXCaps = winecaps.DirectDrawCaps.FXCaps;
1024     caps.dwPalCaps = winecaps.DirectDrawCaps.PalCaps;
1025     caps.ddsCaps.dwCaps = winecaps.DirectDrawCaps.ddsCaps;
1026     caps.dwSVBCaps = winecaps.DirectDrawCaps.SVBCaps;
1027     caps.dwSVBCKeyCaps = winecaps.DirectDrawCaps.SVBCKeyCaps;
1028     caps.dwSVBFXCaps = winecaps.DirectDrawCaps.SVBFXCaps;
1029     caps.dwVSBCaps = winecaps.DirectDrawCaps.VSBCaps;
1030     caps.dwVSBCKeyCaps = winecaps.DirectDrawCaps.VSBCKeyCaps;
1031     caps.dwVSBFXCaps = winecaps.DirectDrawCaps.VSBFXCaps;
1032     caps.dwSSBCaps = winecaps.DirectDrawCaps.SSBCaps;
1033     caps.dwSSBCKeyCaps = winecaps.DirectDrawCaps.SSBCKeyCaps;
1034     caps.dwSSBFXCaps = winecaps.DirectDrawCaps.SSBFXCaps;
1035
1036     /* Even if WineD3D supports 3D rendering, remove the cap if ddraw is configured
1037      * not to use it
1038      */
1039     if(DefaultSurfaceType == SURFACE_GDI) {
1040         caps.dwCaps &= ~DDCAPS_3D;
1041         caps.ddsCaps.dwCaps &= ~(DDSCAPS_3DDEVICE | DDSCAPS_MIPMAP | DDSCAPS_TEXTURE | DDSCAPS_ZBUFFER);
1042     }
1043     if(winecaps.DirectDrawCaps.StrideAlign != 0) {
1044         caps.dwCaps |= DDCAPS_ALIGNSTRIDE;
1045         caps.dwAlignStrideAlign = winecaps.DirectDrawCaps.StrideAlign;
1046     }
1047
1048     if(DriverCaps)
1049     {
1050         DD_STRUCT_COPY_BYSIZE(DriverCaps, &caps);
1051         if (TRACE_ON(ddraw))
1052         {
1053             TRACE("Driver Caps :\n");
1054             DDRAW_dump_DDCAPS(DriverCaps);
1055         }
1056
1057     }
1058     if(HELCaps)
1059     {
1060         DD_STRUCT_COPY_BYSIZE(HELCaps, &caps);
1061         if (TRACE_ON(ddraw))
1062         {
1063             TRACE("HEL Caps :\n");
1064             DDRAW_dump_DDCAPS(HELCaps);
1065         }
1066     }
1067
1068     return DD_OK;
1069 }
1070
1071 static HRESULT WINAPI ddraw4_GetCaps(IDirectDraw4 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1072 {
1073     TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1074
1075     return ddraw7_GetCaps((IDirectDraw7 *)ddraw_from_ddraw4(iface), driver_caps, hel_caps);
1076 }
1077
1078 static HRESULT WINAPI ddraw3_GetCaps(IDirectDraw3 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1079 {
1080     TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1081
1082     return ddraw7_GetCaps((IDirectDraw7 *)ddraw_from_ddraw3(iface), driver_caps, hel_caps);
1083 }
1084
1085 static HRESULT WINAPI ddraw2_GetCaps(IDirectDraw2 *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1086 {
1087     TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1088
1089     return ddraw7_GetCaps((IDirectDraw7 *)ddraw_from_ddraw2(iface), driver_caps, hel_caps);
1090 }
1091
1092 static HRESULT WINAPI ddraw1_GetCaps(IDirectDraw *iface, DDCAPS *driver_caps, DDCAPS *hel_caps)
1093 {
1094     TRACE("iface %p, driver_caps %p, hel_caps %p.\n", iface, driver_caps, hel_caps);
1095
1096     return ddraw7_GetCaps((IDirectDraw7 *)ddraw_from_ddraw1(iface), driver_caps, hel_caps);
1097 }
1098
1099 /*****************************************************************************
1100  * IDirectDraw7::Compact
1101  *
1102  * No idea what it does, MSDN says it's not implemented.
1103  *
1104  * Returns
1105  *  DD_OK, but this is unchecked
1106  *
1107  *****************************************************************************/
1108 static HRESULT WINAPI ddraw7_Compact(IDirectDraw7 *iface)
1109 {
1110     TRACE("iface %p.\n", iface);
1111
1112     return DD_OK;
1113 }
1114
1115 static HRESULT WINAPI ddraw4_Compact(IDirectDraw4 *iface)
1116 {
1117     TRACE("iface %p.\n", iface);
1118
1119     return ddraw7_Compact((IDirectDraw7 *)ddraw_from_ddraw4(iface));
1120 }
1121
1122 static HRESULT WINAPI ddraw3_Compact(IDirectDraw3 *iface)
1123 {
1124     TRACE("iface %p.\n", iface);
1125
1126     return ddraw7_Compact((IDirectDraw7 *)ddraw_from_ddraw3(iface));
1127 }
1128
1129 static HRESULT WINAPI ddraw2_Compact(IDirectDraw2 *iface)
1130 {
1131     TRACE("iface %p.\n", iface);
1132
1133     return ddraw7_Compact((IDirectDraw7 *)ddraw_from_ddraw2(iface));
1134 }
1135
1136 static HRESULT WINAPI ddraw1_Compact(IDirectDraw *iface)
1137 {
1138     TRACE("iface %p.\n", iface);
1139
1140     return ddraw7_Compact((IDirectDraw7 *)ddraw_from_ddraw1(iface));
1141 }
1142
1143 /*****************************************************************************
1144  * IDirectDraw7::GetDisplayMode
1145  *
1146  * Returns information about the current display mode
1147  *
1148  * Exists in Version 1, 2, 4 and 7
1149  *
1150  * Params:
1151  *  DDSD: Address of a surface description structure to write the info to
1152  *
1153  * Returns
1154  *  DD_OK
1155  *
1156  *****************************************************************************/
1157 static HRESULT WINAPI ddraw7_GetDisplayMode(IDirectDraw7 *iface, DDSURFACEDESC2 *DDSD)
1158 {
1159     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1160     HRESULT hr;
1161     WINED3DDISPLAYMODE Mode;
1162     DWORD Size;
1163
1164     TRACE("iface %p, surface_desc %p.\n", iface, DDSD);
1165
1166     EnterCriticalSection(&ddraw_cs);
1167     /* This seems sane */
1168     if (!DDSD)
1169     {
1170         LeaveCriticalSection(&ddraw_cs);
1171         return DDERR_INVALIDPARAMS;
1172     }
1173
1174     /* The necessary members of LPDDSURFACEDESC and LPDDSURFACEDESC2 are equal,
1175      * so one method can be used for all versions (Hopefully)
1176      */
1177     hr = IWineD3DDevice_GetDisplayMode(This->wineD3DDevice,
1178                                       0 /* swapchain 0 */,
1179                                       &Mode);
1180     if( hr != D3D_OK )
1181     {
1182         ERR(" (%p) IWineD3DDevice::GetDisplayMode returned %08x\n", This, hr);
1183         LeaveCriticalSection(&ddraw_cs);
1184         return hr;
1185     }
1186
1187     Size = DDSD->dwSize;
1188     memset(DDSD, 0, Size);
1189
1190     DDSD->dwSize = Size;
1191     DDSD->dwFlags |= DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE;
1192     DDSD->dwWidth = Mode.Width;
1193     DDSD->dwHeight = Mode.Height;
1194     DDSD->u2.dwRefreshRate = 60;
1195     DDSD->ddsCaps.dwCaps = 0;
1196     DDSD->u4.ddpfPixelFormat.dwSize = sizeof(DDSD->u4.ddpfPixelFormat);
1197     PixelFormat_WineD3DtoDD(&DDSD->u4.ddpfPixelFormat, Mode.Format);
1198     DDSD->u1.lPitch = Mode.Width * DDSD->u4.ddpfPixelFormat.u1.dwRGBBitCount / 8;
1199
1200     if(TRACE_ON(ddraw))
1201     {
1202         TRACE("Returning surface desc :\n");
1203         DDRAW_dump_surface_desc(DDSD);
1204     }
1205
1206     LeaveCriticalSection(&ddraw_cs);
1207     return DD_OK;
1208 }
1209
1210 static HRESULT WINAPI ddraw4_GetDisplayMode(IDirectDraw4 *iface, DDSURFACEDESC2 *surface_desc)
1211 {
1212     TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1213
1214     return ddraw7_GetDisplayMode((IDirectDraw7 *)ddraw_from_ddraw4(iface), surface_desc);
1215 }
1216
1217 static HRESULT WINAPI ddraw3_GetDisplayMode(IDirectDraw3 *iface, DDSURFACEDESC *surface_desc)
1218 {
1219     TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1220
1221     return ddraw7_GetDisplayMode((IDirectDraw7 *)ddraw_from_ddraw3(iface), (DDSURFACEDESC2 *)surface_desc);
1222 }
1223
1224 static HRESULT WINAPI ddraw2_GetDisplayMode(IDirectDraw2 *iface, DDSURFACEDESC *surface_desc)
1225 {
1226     TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1227
1228     return ddraw7_GetDisplayMode((IDirectDraw7 *)ddraw_from_ddraw2(iface), (DDSURFACEDESC2 *)surface_desc);
1229 }
1230
1231 static HRESULT WINAPI ddraw1_GetDisplayMode(IDirectDraw *iface, DDSURFACEDESC *surface_desc)
1232 {
1233     TRACE("iface %p, surface_desc %p.\n", iface, surface_desc);
1234
1235     return ddraw7_GetDisplayMode((IDirectDraw7 *)ddraw_from_ddraw1(iface), (DDSURFACEDESC2 *)surface_desc);
1236 }
1237
1238 /*****************************************************************************
1239  * IDirectDraw7::GetFourCCCodes
1240  *
1241  * Returns an array of supported FourCC codes.
1242  *
1243  * Exists in Version 1, 2, 4 and 7
1244  *
1245  * Params:
1246  *  NumCodes: Contains the number of Codes that Codes can carry. Returns the number
1247  *            of enumerated codes
1248  *  Codes: Pointer to an array of DWORDs where the supported codes are written
1249  *         to
1250  *
1251  * Returns
1252  *  Always returns DD_OK, as it's a stub for now
1253  *
1254  *****************************************************************************/
1255 static HRESULT WINAPI ddraw7_GetFourCCCodes(IDirectDraw7 *iface, DWORD *NumCodes, DWORD *Codes)
1256 {
1257     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1258     static const enum wined3d_format_id formats[] =
1259     {
1260         WINED3DFMT_YUY2, WINED3DFMT_UYVY, WINED3DFMT_YV12,
1261         WINED3DFMT_DXT1, WINED3DFMT_DXT2, WINED3DFMT_DXT3, WINED3DFMT_DXT4, WINED3DFMT_DXT5,
1262         WINED3DFMT_ATI2N, WINED3DFMT_NVHU, WINED3DFMT_NVHS
1263     };
1264     DWORD count = 0, i, outsize;
1265     HRESULT hr;
1266     WINED3DDISPLAYMODE d3ddm;
1267     WINED3DSURFTYPE type = This->ImplType;
1268
1269     TRACE("iface %p, codes_count %p, codes %p.\n", iface, NumCodes, Codes);
1270
1271     IWineD3DDevice_GetDisplayMode(This->wineD3DDevice,
1272                                   0 /* swapchain 0 */,
1273                                   &d3ddm);
1274
1275     outsize = NumCodes && Codes ? *NumCodes : 0;
1276
1277     if(type == SURFACE_UNKNOWN) type = SURFACE_GDI;
1278
1279     for(i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
1280         hr = IWineD3D_CheckDeviceFormat(This->wineD3D,
1281                                         WINED3DADAPTER_DEFAULT,
1282                                         WINED3DDEVTYPE_HAL,
1283                                         d3ddm.Format /* AdapterFormat */,
1284                                         0 /* usage */,
1285                                         WINED3DRTYPE_SURFACE,
1286                                         formats[i],
1287                                         type);
1288         if(SUCCEEDED(hr)) {
1289             if(count < outsize) {
1290                 Codes[count] = formats[i];
1291             }
1292             count++;
1293         }
1294     }
1295     if(NumCodes) {
1296         TRACE("Returning %u FourCC codes\n", count);
1297         *NumCodes = count;
1298     }
1299
1300     return DD_OK;
1301 }
1302
1303 static HRESULT WINAPI ddraw4_GetFourCCCodes(IDirectDraw4 *iface, DWORD *codes_count, DWORD *codes)
1304 {
1305     TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1306
1307     return ddraw7_GetFourCCCodes((IDirectDraw7 *)ddraw_from_ddraw4(iface), codes_count, codes);
1308 }
1309
1310 static HRESULT WINAPI ddraw3_GetFourCCCodes(IDirectDraw3 *iface, DWORD *codes_count, DWORD *codes)
1311 {
1312     TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1313
1314     return ddraw7_GetFourCCCodes((IDirectDraw7 *)ddraw_from_ddraw3(iface), codes_count, codes);
1315 }
1316
1317 static HRESULT WINAPI ddraw2_GetFourCCCodes(IDirectDraw2 *iface, DWORD *codes_count, DWORD *codes)
1318 {
1319     TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1320
1321     return ddraw7_GetFourCCCodes((IDirectDraw7 *)ddraw_from_ddraw2(iface), codes_count, codes);
1322 }
1323
1324 static HRESULT WINAPI ddraw1_GetFourCCCodes(IDirectDraw *iface, DWORD *codes_count, DWORD *codes)
1325 {
1326     TRACE("iface %p, codes_count %p, codes %p.\n", iface, codes_count, codes);
1327
1328     return ddraw7_GetFourCCCodes((IDirectDraw7 *)ddraw_from_ddraw1(iface), codes_count, codes);
1329 }
1330
1331 /*****************************************************************************
1332  * IDirectDraw7::GetMonitorFrequency
1333  *
1334  * Returns the monitor's frequency
1335  *
1336  * Exists in Version 1, 2, 4 and 7
1337  *
1338  * Params:
1339  *  Freq: Pointer to a DWORD to write the frequency to
1340  *
1341  * Returns
1342  *  Always returns DD_OK
1343  *
1344  *****************************************************************************/
1345 static HRESULT WINAPI ddraw7_GetMonitorFrequency(IDirectDraw7 *iface, DWORD *Freq)
1346 {
1347     FIXME("iface %p, frequency %p stub!\n", iface, Freq);
1348
1349     /* Ideally this should be in WineD3D, as it concerns the screen setup,
1350      * but for now this should make the games happy
1351      */
1352     *Freq = 60;
1353     return DD_OK;
1354 }
1355
1356 static HRESULT WINAPI ddraw4_GetMonitorFrequency(IDirectDraw4 *iface, DWORD *frequency)
1357 {
1358     TRACE("iface %p, frequency %p.\n", iface, frequency);
1359
1360     return ddraw7_GetMonitorFrequency((IDirectDraw7 *)ddraw_from_ddraw4(iface), frequency);
1361 }
1362
1363 static HRESULT WINAPI ddraw3_GetMonitorFrequency(IDirectDraw3 *iface, DWORD *frequency)
1364 {
1365     TRACE("iface %p, frequency %p.\n", iface, frequency);
1366
1367     return ddraw7_GetMonitorFrequency((IDirectDraw7 *)ddraw_from_ddraw3(iface), frequency);
1368 }
1369
1370 static HRESULT WINAPI ddraw2_GetMonitorFrequency(IDirectDraw2 *iface, DWORD *frequency)
1371 {
1372     TRACE("iface %p, frequency %p.\n", iface, frequency);
1373
1374     return ddraw7_GetMonitorFrequency((IDirectDraw7 *)ddraw_from_ddraw2(iface), frequency);
1375 }
1376
1377 static HRESULT WINAPI ddraw1_GetMonitorFrequency(IDirectDraw *iface, DWORD *frequency)
1378 {
1379     TRACE("iface %p, frequency %p.\n", iface, frequency);
1380
1381     return ddraw7_GetMonitorFrequency((IDirectDraw7 *)ddraw_from_ddraw1(iface), frequency);
1382 }
1383
1384 /*****************************************************************************
1385  * IDirectDraw7::GetVerticalBlankStatus
1386  *
1387  * Returns the Vertical blank status of the monitor. This should be in WineD3D
1388  * too basically, but as it's a semi stub, I didn't create a function there
1389  *
1390  * Params:
1391  *  status: Pointer to a BOOL to be filled with the vertical blank status
1392  *
1393  * Returns
1394  *  DD_OK on success
1395  *  DDERR_INVALIDPARAMS if status is NULL
1396  *
1397  *****************************************************************************/
1398 static HRESULT WINAPI ddraw7_GetVerticalBlankStatus(IDirectDraw7 *iface, BOOL *status)
1399 {
1400     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1401
1402     TRACE("iface %p, status %p.\n", iface, status);
1403
1404     /* This looks sane, the MSDN suggests it too */
1405     EnterCriticalSection(&ddraw_cs);
1406     if(!status)
1407     {
1408         LeaveCriticalSection(&ddraw_cs);
1409         return DDERR_INVALIDPARAMS;
1410     }
1411
1412     *status = This->fake_vblank;
1413     This->fake_vblank = !This->fake_vblank;
1414     LeaveCriticalSection(&ddraw_cs);
1415     return DD_OK;
1416 }
1417
1418 static HRESULT WINAPI ddraw4_GetVerticalBlankStatus(IDirectDraw4 *iface, BOOL *status)
1419 {
1420     TRACE("iface %p, status %p.\n", iface, status);
1421
1422     return ddraw7_GetVerticalBlankStatus((IDirectDraw7 *)ddraw_from_ddraw4(iface), status);
1423 }
1424
1425 static HRESULT WINAPI ddraw3_GetVerticalBlankStatus(IDirectDraw3 *iface, BOOL *status)
1426 {
1427     TRACE("iface %p, status %p.\n", iface, status);
1428
1429     return ddraw7_GetVerticalBlankStatus((IDirectDraw7 *)ddraw_from_ddraw3(iface), status);
1430 }
1431
1432 static HRESULT WINAPI ddraw2_GetVerticalBlankStatus(IDirectDraw2 *iface, BOOL *status)
1433 {
1434     TRACE("iface %p, status %p.\n", iface, status);
1435
1436     return ddraw7_GetVerticalBlankStatus((IDirectDraw7 *)ddraw_from_ddraw2(iface), status);
1437 }
1438
1439 static HRESULT WINAPI ddraw1_GetVerticalBlankStatus(IDirectDraw *iface, BOOL *status)
1440 {
1441     TRACE("iface %p, status %p.\n", iface, status);
1442
1443     return ddraw7_GetVerticalBlankStatus((IDirectDraw7 *)ddraw_from_ddraw1(iface), status);
1444 }
1445
1446 /*****************************************************************************
1447  * IDirectDraw7::GetAvailableVidMem
1448  *
1449  * Returns the total and free video memory
1450  *
1451  * Params:
1452  *  Caps: Specifies the memory type asked for
1453  *  total: Pointer to a DWORD to be filled with the total memory
1454  *  free: Pointer to a DWORD to be filled with the free memory
1455  *
1456  * Returns
1457  *  DD_OK on success
1458  *  DDERR_INVALIDPARAMS of free and total are NULL
1459  *
1460  *****************************************************************************/
1461 static HRESULT WINAPI ddraw7_GetAvailableVidMem(IDirectDraw7 *iface, DDSCAPS2 *Caps, DWORD *total, DWORD *free)
1462 {
1463     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1464
1465     TRACE("iface %p, caps %p, total %p, free %p.\n", iface, Caps, total, free);
1466
1467     if(TRACE_ON(ddraw))
1468     {
1469         TRACE("(%p) Asked for memory with description: ", This);
1470         DDRAW_dump_DDSCAPS2(Caps);
1471     }
1472     EnterCriticalSection(&ddraw_cs);
1473
1474     /* Todo: System memory vs local video memory vs non-local video memory
1475      * The MSDN also mentions differences between texture memory and other
1476      * resources, but that's not important
1477      */
1478
1479     if( (!total) && (!free) )
1480     {
1481         LeaveCriticalSection(&ddraw_cs);
1482         return DDERR_INVALIDPARAMS;
1483     }
1484
1485     if(total) *total = This->total_vidmem;
1486     if(free) *free = IWineD3DDevice_GetAvailableTextureMem(This->wineD3DDevice);
1487
1488     LeaveCriticalSection(&ddraw_cs);
1489     return DD_OK;
1490 }
1491
1492 static HRESULT WINAPI ddraw4_GetAvailableVidMem(IDirectDraw4 *iface,
1493         DDSCAPS2 *caps, DWORD *total, DWORD *free)
1494 {
1495     TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1496
1497     return ddraw7_GetAvailableVidMem((IDirectDraw7 *)ddraw_from_ddraw4(iface), caps, total, free);
1498 }
1499
1500 static HRESULT WINAPI ddraw3_GetAvailableVidMem(IDirectDraw3 *iface,
1501         DDSCAPS *caps, DWORD *total, DWORD *free)
1502 {
1503     DDSCAPS2 caps2;
1504
1505     TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1506
1507     DDRAW_Convert_DDSCAPS_1_To_2(caps, &caps2);
1508     return ddraw7_GetAvailableVidMem((IDirectDraw7 *)ddraw_from_ddraw3(iface), &caps2, total, free);
1509 }
1510
1511 static HRESULT WINAPI ddraw2_GetAvailableVidMem(IDirectDraw2 *iface,
1512         DDSCAPS *caps, DWORD *total, DWORD *free)
1513 {
1514     DDSCAPS2 caps2;
1515
1516     TRACE("iface %p, caps %p, total %p, free %p.\n", iface, caps, total, free);
1517
1518     DDRAW_Convert_DDSCAPS_1_To_2(caps, &caps2);
1519     return ddraw7_GetAvailableVidMem((IDirectDraw7 *)ddraw_from_ddraw2(iface), &caps2, total, free);
1520 }
1521
1522 /*****************************************************************************
1523  * IDirectDraw7::Initialize
1524  *
1525  * Initializes a DirectDraw interface.
1526  *
1527  * Params:
1528  *  GUID: Interface identifier. Well, don't know what this is really good
1529  *   for
1530  *
1531  * Returns
1532  *  Returns DD_OK on the first call,
1533  *  DDERR_ALREADYINITIALIZED on repeated calls
1534  *
1535  *****************************************************************************/
1536 static HRESULT WINAPI ddraw7_Initialize(IDirectDraw7 *iface, GUID *Guid)
1537 {
1538     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1539
1540     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(Guid));
1541
1542     if(This->initialized)
1543     {
1544         return DDERR_ALREADYINITIALIZED;
1545     }
1546     else
1547     {
1548         return DD_OK;
1549     }
1550 }
1551
1552 static HRESULT WINAPI ddraw4_Initialize(IDirectDraw4 *iface, GUID *guid)
1553 {
1554     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1555
1556     return ddraw7_Initialize((IDirectDraw7 *)ddraw_from_ddraw4(iface), guid);
1557 }
1558
1559 static HRESULT WINAPI ddraw3_Initialize(IDirectDraw3 *iface, GUID *guid)
1560 {
1561     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1562
1563     return ddraw7_Initialize((IDirectDraw7 *)ddraw_from_ddraw3(iface), guid);
1564 }
1565
1566 static HRESULT WINAPI ddraw2_Initialize(IDirectDraw2 *iface, GUID *guid)
1567 {
1568     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1569
1570     return ddraw7_Initialize((IDirectDraw7 *)ddraw_from_ddraw2(iface), guid);
1571 }
1572
1573 static HRESULT WINAPI ddraw1_Initialize(IDirectDraw *iface, GUID *guid)
1574 {
1575     TRACE("iface %p, guid %s.\n", iface, debugstr_guid(guid));
1576
1577     return ddraw7_Initialize((IDirectDraw7 *)ddraw_from_ddraw1(iface), guid);
1578 }
1579
1580 static HRESULT WINAPI d3d1_Initialize(IDirect3D *iface, REFIID riid)
1581 {
1582     TRACE("iface %p, riid %s.\n", iface, debugstr_guid(riid));
1583
1584     return D3D_OK;
1585 }
1586
1587 /*****************************************************************************
1588  * IDirectDraw7::FlipToGDISurface
1589  *
1590  * "Makes the surface that the GDI writes to the primary surface"
1591  * Looks like some windows specific thing we don't have to care about.
1592  * According to MSDN it permits GDI dialog boxes in FULLSCREEN mode. Good to
1593  * show error boxes ;)
1594  * Well, just return DD_OK.
1595  *
1596  * Returns:
1597  *  Always returns DD_OK
1598  *
1599  *****************************************************************************/
1600 static HRESULT WINAPI ddraw7_FlipToGDISurface(IDirectDraw7 *iface)
1601 {
1602     FIXME("iface %p stub!\n", iface);
1603
1604     return DD_OK;
1605 }
1606
1607 static HRESULT WINAPI ddraw4_FlipToGDISurface(IDirectDraw4 *iface)
1608 {
1609     TRACE("iface %p.\n", iface);
1610
1611     return ddraw7_FlipToGDISurface((IDirectDraw7 *)ddraw_from_ddraw4(iface));
1612 }
1613
1614 static HRESULT WINAPI ddraw3_FlipToGDISurface(IDirectDraw3 *iface)
1615 {
1616     TRACE("iface %p.\n", iface);
1617
1618     return ddraw7_FlipToGDISurface((IDirectDraw7 *)ddraw_from_ddraw3(iface));
1619 }
1620
1621 static HRESULT WINAPI ddraw2_FlipToGDISurface(IDirectDraw2 *iface)
1622 {
1623     TRACE("iface %p.\n", iface);
1624
1625     return ddraw7_FlipToGDISurface((IDirectDraw7 *)ddraw_from_ddraw2(iface));
1626 }
1627
1628 static HRESULT WINAPI ddraw1_FlipToGDISurface(IDirectDraw *iface)
1629 {
1630     TRACE("iface %p.\n", iface);
1631
1632     return ddraw7_FlipToGDISurface((IDirectDraw7 *)ddraw_from_ddraw1(iface));
1633 }
1634
1635 /*****************************************************************************
1636  * IDirectDraw7::WaitForVerticalBlank
1637  *
1638  * This method allows applications to get in sync with the vertical blank
1639  * interval.
1640  * The wormhole demo in the DirectX 7 sdk uses this call, and it doesn't
1641  * redraw the screen, most likely because of this stub
1642  *
1643  * Parameters:
1644  *  Flags: one of DDWAITVB_BLOCKBEGIN, DDWAITVB_BLOCKBEGINEVENT
1645  *         or DDWAITVB_BLOCKEND
1646  *  h: Not used, according to MSDN
1647  *
1648  * Returns:
1649  *  Always returns DD_OK
1650  *
1651  *****************************************************************************/
1652 static HRESULT WINAPI ddraw7_WaitForVerticalBlank(IDirectDraw7 *iface, DWORD Flags, HANDLE event)
1653 {
1654     static BOOL hide;
1655
1656     TRACE("iface %p, flags %#x, event %p.\n", iface, Flags, event);
1657
1658     /* This function is called often, so print the fixme only once */
1659     if(!hide)
1660     {
1661         FIXME("iface %p, flags %#x, event %p stub!\n", iface, Flags, event);
1662         hide = TRUE;
1663     }
1664
1665     /* MSDN says DDWAITVB_BLOCKBEGINEVENT is not supported */
1666     if(Flags & DDWAITVB_BLOCKBEGINEVENT)
1667         return DDERR_UNSUPPORTED; /* unchecked */
1668
1669     return DD_OK;
1670 }
1671
1672 static HRESULT WINAPI ddraw4_WaitForVerticalBlank(IDirectDraw4 *iface, DWORD flags, HANDLE event)
1673 {
1674     TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
1675
1676     return ddraw7_WaitForVerticalBlank((IDirectDraw7 *)ddraw_from_ddraw4(iface), flags, event);
1677 }
1678
1679 static HRESULT WINAPI ddraw3_WaitForVerticalBlank(IDirectDraw3 *iface, DWORD flags, HANDLE event)
1680 {
1681     TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
1682
1683     return ddraw7_WaitForVerticalBlank((IDirectDraw7 *)ddraw_from_ddraw3(iface), flags, event);
1684 }
1685
1686 static HRESULT WINAPI ddraw2_WaitForVerticalBlank(IDirectDraw2 *iface, DWORD flags, HANDLE event)
1687 {
1688     TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
1689
1690     return ddraw7_WaitForVerticalBlank((IDirectDraw7 *)ddraw_from_ddraw2(iface), flags, event);
1691 }
1692
1693 static HRESULT WINAPI ddraw1_WaitForVerticalBlank(IDirectDraw *iface, DWORD flags, HANDLE event)
1694 {
1695     TRACE("iface %p, flags %#x, event %p.\n", iface, flags, event);
1696
1697     return ddraw7_WaitForVerticalBlank((IDirectDraw7 *)ddraw_from_ddraw1(iface), flags, event);
1698 }
1699
1700 /*****************************************************************************
1701  * IDirectDraw7::GetScanLine
1702  *
1703  * Returns the scan line that is being drawn on the monitor
1704  *
1705  * Parameters:
1706  *  Scanline: Address to write the scan line value to
1707  *
1708  * Returns:
1709  *  Always returns DD_OK
1710  *
1711  *****************************************************************************/
1712 static HRESULT WINAPI ddraw7_GetScanLine(IDirectDraw7 *iface, DWORD *Scanline)
1713 {
1714     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1715     static BOOL hide = FALSE;
1716     WINED3DDISPLAYMODE Mode;
1717
1718     TRACE("iface %p, line %p.\n", iface, Scanline);
1719
1720     /* This function is called often, so print the fixme only once */
1721     EnterCriticalSection(&ddraw_cs);
1722     if(!hide)
1723     {
1724         FIXME("iface %p, line %p partial stub!\n", iface, Scanline);
1725         hide = TRUE;
1726     }
1727
1728     IWineD3DDevice_GetDisplayMode(This->wineD3DDevice,
1729                                   0,
1730                                   &Mode);
1731
1732     /* Fake the line sweeping of the monitor */
1733     /* FIXME: We should synchronize with a source to keep the refresh rate */
1734     *Scanline = This->cur_scanline++;
1735     /* Assume 20 scan lines in the vertical blank */
1736     if (This->cur_scanline >= Mode.Height + 20)
1737         This->cur_scanline = 0;
1738
1739     LeaveCriticalSection(&ddraw_cs);
1740     return DD_OK;
1741 }
1742
1743 static HRESULT WINAPI ddraw4_GetScanLine(IDirectDraw4 *iface, DWORD *line)
1744 {
1745     TRACE("iface %p, line %p.\n", iface, line);
1746
1747     return ddraw7_GetScanLine((IDirectDraw7 *)ddraw_from_ddraw4(iface), line);
1748 }
1749
1750 static HRESULT WINAPI ddraw3_GetScanLine(IDirectDraw3 *iface, DWORD *line)
1751 {
1752     TRACE("iface %p, line %p.\n", iface, line);
1753
1754     return ddraw7_GetScanLine((IDirectDraw7 *)ddraw_from_ddraw3(iface), line);
1755 }
1756
1757 static HRESULT WINAPI ddraw2_GetScanLine(IDirectDraw2 *iface, DWORD *line)
1758 {
1759     TRACE("iface %p, line %p.\n", iface, line);
1760
1761     return ddraw7_GetScanLine((IDirectDraw7 *)ddraw_from_ddraw2(iface), line);
1762 }
1763
1764 static HRESULT WINAPI ddraw1_GetScanLine(IDirectDraw *iface, DWORD *line)
1765 {
1766     TRACE("iface %p, line %p.\n", iface, line);
1767
1768     return ddraw7_GetScanLine((IDirectDraw7 *)ddraw_from_ddraw1(iface), line);
1769 }
1770
1771 /*****************************************************************************
1772  * IDirectDraw7::TestCooperativeLevel
1773  *
1774  * Informs the application about the state of the video adapter, depending
1775  * on the cooperative level
1776  *
1777  * Returns:
1778  *  DD_OK if the device is in a sane state
1779  *  DDERR_NOEXCLUSIVEMODE or DDERR_EXCLUSIVEMODEALREADYSET
1780  *  if the state is not correct(See below)
1781  *
1782  *****************************************************************************/
1783 static HRESULT WINAPI ddraw7_TestCooperativeLevel(IDirectDraw7 *iface)
1784 {
1785     TRACE("iface %p.\n", iface);
1786
1787     return DD_OK;
1788 }
1789
1790 static HRESULT WINAPI ddraw4_TestCooperativeLevel(IDirectDraw4 *iface)
1791 {
1792     TRACE("iface %p.\n", iface);
1793
1794     return ddraw7_TestCooperativeLevel((IDirectDraw7 *)ddraw_from_ddraw4(iface));
1795 }
1796
1797 /*****************************************************************************
1798  * IDirectDraw7::GetGDISurface
1799  *
1800  * Returns the surface that GDI is treating as the primary surface.
1801  * For Wine this is the front buffer
1802  *
1803  * Params:
1804  *  GDISurface: Address to write the surface pointer to
1805  *
1806  * Returns:
1807  *  DD_OK if the surface was found
1808  *  DDERR_NOTFOUND if the GDI surface wasn't found
1809  *
1810  *****************************************************************************/
1811 static HRESULT WINAPI ddraw7_GetGDISurface(IDirectDraw7 *iface, IDirectDrawSurface7 **GDISurface)
1812 {
1813     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1814     IWineD3DSurface *Surf;
1815     IDirectDrawSurface7 *ddsurf;
1816     HRESULT hr;
1817     DDSCAPS2 ddsCaps;
1818
1819     TRACE("iface %p, surface %p.\n", iface, GDISurface);
1820
1821     /* Get the back buffer from the wineD3DDevice and search its
1822      * attached surfaces for the front buffer
1823      */
1824     EnterCriticalSection(&ddraw_cs);
1825     hr = IWineD3DDevice_GetBackBuffer(This->wineD3DDevice,
1826                                       0, /* SwapChain */
1827                                       0, /* first back buffer*/
1828                                       WINED3DBACKBUFFER_TYPE_MONO,
1829                                       &Surf);
1830
1831     if( (hr != D3D_OK) ||
1832         (!Surf) )
1833     {
1834         ERR("IWineD3DDevice::GetBackBuffer failed\n");
1835         LeaveCriticalSection(&ddraw_cs);
1836         return DDERR_NOTFOUND;
1837     }
1838
1839     ddsurf = IWineD3DSurface_GetParent(Surf);
1840     IWineD3DSurface_Release(Surf);
1841
1842     /* Find the front buffer */
1843     ddsCaps.dwCaps = DDSCAPS_FRONTBUFFER;
1844     hr = IDirectDrawSurface7_GetAttachedSurface(ddsurf,
1845                                                 &ddsCaps,
1846                                                 GDISurface);
1847     if(hr != DD_OK)
1848     {
1849         ERR("IDirectDrawSurface7::GetAttachedSurface failed, hr = %x\n", hr);
1850     }
1851
1852     /* The AddRef is OK this time */
1853     LeaveCriticalSection(&ddraw_cs);
1854     return hr;
1855 }
1856
1857 static HRESULT WINAPI ddraw4_GetGDISurface(IDirectDraw4 *iface, IDirectDrawSurface4 **surface)
1858 {
1859     TRACE("iface %p, surface %p.\n", iface, surface);
1860
1861     return ddraw7_GetGDISurface((IDirectDraw7 *)ddraw_from_ddraw4(iface), (IDirectDrawSurface7 **)surface);
1862 }
1863
1864 static HRESULT WINAPI ddraw3_GetGDISurface(IDirectDraw3 *iface, IDirectDrawSurface **surface)
1865 {
1866     IDirectDrawSurface7 *surface7;
1867     HRESULT hr;
1868
1869     TRACE("iface %p, surface %p.\n", iface, surface);
1870
1871     hr = ddraw7_GetGDISurface((IDirectDraw7 *)ddraw_from_ddraw3(iface), &surface7);
1872     *surface = surface7 ? (IDirectDrawSurface *)&((IDirectDrawSurfaceImpl *)surface7)->IDirectDrawSurface3_vtbl : NULL;
1873
1874     return hr;
1875 }
1876
1877 static HRESULT WINAPI ddraw2_GetGDISurface(IDirectDraw2 *iface, IDirectDrawSurface **surface)
1878 {
1879     IDirectDrawSurface7 *surface7;
1880     HRESULT hr;
1881
1882     TRACE("iface %p, surface %p.\n", iface, surface);
1883
1884     hr = ddraw7_GetGDISurface((IDirectDraw7 *)ddraw_from_ddraw2(iface), &surface7);
1885     *surface = surface7 ? (IDirectDrawSurface *)&((IDirectDrawSurfaceImpl *)surface7)->IDirectDrawSurface3_vtbl : NULL;
1886
1887     return hr;
1888 }
1889
1890 static HRESULT WINAPI ddraw1_GetGDISurface(IDirectDraw *iface, IDirectDrawSurface **surface)
1891 {
1892     IDirectDrawSurface7 *surface7;
1893     HRESULT hr;
1894
1895     TRACE("iface %p, surface %p.\n", iface, surface);
1896
1897     hr = ddraw7_GetGDISurface((IDirectDraw7 *)ddraw_from_ddraw1(iface), &surface7);
1898     *surface = surface7 ? (IDirectDrawSurface *)&((IDirectDrawSurfaceImpl *)surface7)->IDirectDrawSurface3_vtbl : NULL;
1899
1900     return hr;
1901 }
1902
1903 struct displaymodescallback_context
1904 {
1905     LPDDENUMMODESCALLBACK func;
1906     void *context;
1907 };
1908
1909 static HRESULT CALLBACK EnumDisplayModesCallbackThunk(DDSURFACEDESC2 *surface_desc, void *context)
1910 {
1911     struct displaymodescallback_context *cbcontext = context;
1912     DDSURFACEDESC desc;
1913
1914     memcpy(&desc, surface_desc, sizeof(desc));
1915     desc.dwSize = sizeof(desc);
1916
1917     return cbcontext->func(&desc, cbcontext->context);
1918 }
1919
1920 /*****************************************************************************
1921  * IDirectDraw7::EnumDisplayModes
1922  *
1923  * Enumerates the supported Display modes. The modes can be filtered with
1924  * the DDSD parameter.
1925  *
1926  * Params:
1927  *  Flags: can be DDEDM_REFRESHRATES and DDEDM_STANDARDVGAMODES
1928  *  DDSD: Surface description to filter the modes
1929  *  Context: Pointer passed back to the callback function
1930  *  cb: Application-provided callback function
1931  *
1932  * Returns:
1933  *  DD_OK on success
1934  *  DDERR_INVALIDPARAMS if the callback wasn't set
1935  *
1936  *****************************************************************************/
1937 static HRESULT WINAPI ddraw7_EnumDisplayModes(IDirectDraw7 *iface, DWORD Flags,
1938         DDSURFACEDESC2 *DDSD, void *Context, LPDDENUMMODESCALLBACK2 cb)
1939 {
1940     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
1941     unsigned int modenum, fmt;
1942     enum wined3d_format_id pixelformat = WINED3DFMT_UNKNOWN;
1943     WINED3DDISPLAYMODE mode;
1944     DDSURFACEDESC2 callback_sd;
1945     WINED3DDISPLAYMODE *enum_modes = NULL;
1946     unsigned enum_mode_count = 0, enum_mode_array_size = 0;
1947
1948     static const enum wined3d_format_id checkFormatList[] =
1949     {
1950         WINED3DFMT_B8G8R8X8_UNORM,
1951         WINED3DFMT_B5G6R5_UNORM,
1952         WINED3DFMT_P8_UINT,
1953     };
1954
1955     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
1956             iface, Flags, DDSD, Context, cb);
1957
1958     EnterCriticalSection(&ddraw_cs);
1959     /* This looks sane */
1960     if(!cb)
1961     {
1962         LeaveCriticalSection(&ddraw_cs);
1963         return DDERR_INVALIDPARAMS;
1964     }
1965
1966     if(DDSD)
1967     {
1968         if ((DDSD->dwFlags & DDSD_PIXELFORMAT) && (DDSD->u4.ddpfPixelFormat.dwFlags & DDPF_RGB) )
1969             pixelformat = PixelFormat_DD2WineD3D(&DDSD->u4.ddpfPixelFormat);
1970     }
1971
1972     if(!(Flags & DDEDM_REFRESHRATES))
1973     {
1974         enum_mode_array_size = 16;
1975         enum_modes = HeapAlloc(GetProcessHeap(), 0, sizeof(WINED3DDISPLAYMODE) * enum_mode_array_size);
1976         if (!enum_modes)
1977         {
1978             ERR("Out of memory\n");
1979             LeaveCriticalSection(&ddraw_cs);
1980             return DDERR_OUTOFMEMORY;
1981         }
1982     }
1983
1984     for(fmt = 0; fmt < (sizeof(checkFormatList) / sizeof(checkFormatList[0])); fmt++)
1985     {
1986         if(pixelformat != WINED3DFMT_UNKNOWN && checkFormatList[fmt] != pixelformat)
1987         {
1988             continue;
1989         }
1990
1991         modenum = 0;
1992         while(IWineD3D_EnumAdapterModes(This->wineD3D,
1993                                         WINED3DADAPTER_DEFAULT,
1994                                         checkFormatList[fmt],
1995                                         modenum++,
1996                                         &mode) == WINED3D_OK)
1997         {
1998             if(DDSD)
1999             {
2000                 if(DDSD->dwFlags & DDSD_WIDTH && mode.Width != DDSD->dwWidth) continue;
2001                 if(DDSD->dwFlags & DDSD_HEIGHT && mode.Height != DDSD->dwHeight) continue;
2002             }
2003
2004             if(!(Flags & DDEDM_REFRESHRATES))
2005             {
2006                 /* DX docs state EnumDisplayMode should return only unique modes. If DDEDM_REFRESHRATES is not set, refresh
2007                  * rate doesn't matter when determining if the mode is unique. So modes only differing in refresh rate have
2008                  * to be reduced to a single unique result in such case.
2009                  */
2010                 BOOL found = FALSE;
2011                 unsigned i;
2012
2013                 for (i = 0; i < enum_mode_count; i++)
2014                 {
2015                     if(enum_modes[i].Width == mode.Width && enum_modes[i].Height == mode.Height &&
2016                        enum_modes[i].Format == mode.Format)
2017                     {
2018                         found = TRUE;
2019                         break;
2020                     }
2021                 }
2022
2023                 if(found) continue;
2024             }
2025
2026             memset(&callback_sd, 0, sizeof(callback_sd));
2027             callback_sd.dwSize = sizeof(callback_sd);
2028             callback_sd.u4.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
2029
2030             callback_sd.dwFlags = DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|DDSD_PITCH;
2031             if(Flags & DDEDM_REFRESHRATES)
2032             {
2033                 callback_sd.dwFlags |= DDSD_REFRESHRATE;
2034                 callback_sd.u2.dwRefreshRate = mode.RefreshRate;
2035             }
2036
2037             callback_sd.dwWidth = mode.Width;
2038             callback_sd.dwHeight = mode.Height;
2039
2040             PixelFormat_WineD3DtoDD(&callback_sd.u4.ddpfPixelFormat, mode.Format);
2041
2042             /* Calc pitch and DWORD align like MSDN says */
2043             callback_sd.u1.lPitch = (callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount / 8) * mode.Width;
2044             callback_sd.u1.lPitch = (callback_sd.u1.lPitch + 3) & ~3;
2045
2046             TRACE("Enumerating %dx%dx%d @%d\n", callback_sd.dwWidth, callback_sd.dwHeight, callback_sd.u4.ddpfPixelFormat.u1.dwRGBBitCount,
2047               callback_sd.u2.dwRefreshRate);
2048
2049             if(cb(&callback_sd, Context) == DDENUMRET_CANCEL)
2050             {
2051                 TRACE("Application asked to terminate the enumeration\n");
2052                 HeapFree(GetProcessHeap(), 0, enum_modes);
2053                 LeaveCriticalSection(&ddraw_cs);
2054                 return DD_OK;
2055             }
2056
2057             if(!(Flags & DDEDM_REFRESHRATES))
2058             {
2059                 if (enum_mode_count == enum_mode_array_size)
2060                 {
2061                     WINED3DDISPLAYMODE *new_enum_modes;
2062
2063                     enum_mode_array_size *= 2;
2064                     new_enum_modes = HeapReAlloc(GetProcessHeap(), 0, enum_modes, sizeof(WINED3DDISPLAYMODE) * enum_mode_array_size);
2065
2066                     if (!new_enum_modes)
2067                     {
2068                         ERR("Out of memory\n");
2069                         HeapFree(GetProcessHeap(), 0, enum_modes);
2070                         LeaveCriticalSection(&ddraw_cs);
2071                         return DDERR_OUTOFMEMORY;
2072                     }
2073
2074                     enum_modes = new_enum_modes;
2075                 }
2076
2077                 enum_modes[enum_mode_count++] = mode;
2078             }
2079         }
2080     }
2081
2082     TRACE("End of enumeration\n");
2083     HeapFree(GetProcessHeap(), 0, enum_modes);
2084     LeaveCriticalSection(&ddraw_cs);
2085     return DD_OK;
2086 }
2087
2088 static HRESULT WINAPI ddraw4_EnumDisplayModes(IDirectDraw4 *iface, DWORD flags,
2089         DDSURFACEDESC2 *surface_desc, void *context, LPDDENUMMODESCALLBACK2 callback)
2090 {
2091     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2092             iface, flags, surface_desc, context, callback);
2093
2094     return ddraw7_EnumDisplayModes((IDirectDraw7 *)ddraw_from_ddraw4(iface), flags,
2095             surface_desc, context, callback);
2096 }
2097
2098 static HRESULT WINAPI ddraw3_EnumDisplayModes(IDirectDraw3 *iface, DWORD flags,
2099         DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2100 {
2101     struct displaymodescallback_context cbcontext;
2102
2103     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2104             iface, flags, surface_desc, context, callback);
2105
2106     cbcontext.func = callback;
2107     cbcontext.context = context;
2108
2109     return ddraw7_EnumDisplayModes((IDirectDraw7 *)ddraw_from_ddraw3(iface), flags,
2110             (DDSURFACEDESC2 *)surface_desc, &cbcontext, EnumDisplayModesCallbackThunk);
2111 }
2112
2113 static HRESULT WINAPI ddraw2_EnumDisplayModes(IDirectDraw2 *iface, DWORD flags,
2114         DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2115 {
2116     struct displaymodescallback_context cbcontext;
2117
2118     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2119             iface, flags, surface_desc, context, callback);
2120
2121     cbcontext.func = callback;
2122     cbcontext.context = context;
2123
2124     return ddraw7_EnumDisplayModes((IDirectDraw7 *)ddraw_from_ddraw2(iface), flags,
2125             (DDSURFACEDESC2 *)surface_desc, &cbcontext, EnumDisplayModesCallbackThunk);
2126 }
2127
2128 static HRESULT WINAPI ddraw1_EnumDisplayModes(IDirectDraw *iface, DWORD flags,
2129         DDSURFACEDESC *surface_desc, void *context, LPDDENUMMODESCALLBACK callback)
2130 {
2131     struct displaymodescallback_context cbcontext;
2132
2133     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
2134             iface, flags, surface_desc, context, callback);
2135
2136     cbcontext.func = callback;
2137     cbcontext.context = context;
2138
2139     return ddraw7_EnumDisplayModes((IDirectDraw7 *)ddraw_from_ddraw1(iface), flags,
2140             (DDSURFACEDESC2 *)surface_desc, &cbcontext, EnumDisplayModesCallbackThunk);
2141 }
2142
2143 /*****************************************************************************
2144  * IDirectDraw7::EvaluateMode
2145  *
2146  * Used with IDirectDraw7::StartModeTest to test video modes.
2147  * EvaluateMode is used to pass or fail a mode, and continue with the next
2148  * mode
2149  *
2150  * Params:
2151  *  Flags: DDEM_MODEPASSED or DDEM_MODEFAILED
2152  *  Timeout: Returns the amount of seconds left before the mode would have
2153  *           been failed automatically
2154  *
2155  * Returns:
2156  *  This implementation always DD_OK, because it's a stub
2157  *
2158  *****************************************************************************/
2159 static HRESULT WINAPI ddraw7_EvaluateMode(IDirectDraw7 *iface, DWORD Flags, DWORD *Timeout)
2160 {
2161     FIXME("iface %p, flags %#x, timeout %p stub!\n", iface, Flags, Timeout);
2162
2163     /* When implementing this, implement it in WineD3D */
2164
2165     return DD_OK;
2166 }
2167
2168 /*****************************************************************************
2169  * IDirectDraw7::GetDeviceIdentifier
2170  *
2171  * Returns the device identifier, which gives information about the driver
2172  * Our device identifier is defined at the beginning of this file.
2173  *
2174  * Params:
2175  *  DDDI: Address for the returned structure
2176  *  Flags: Can be DDGDI_GETHOSTIDENTIFIER
2177  *
2178  * Returns:
2179  *  On success it returns DD_OK
2180  *  DDERR_INVALIDPARAMS if DDDI is NULL
2181  *
2182  *****************************************************************************/
2183 static HRESULT WINAPI ddraw7_GetDeviceIdentifier(IDirectDraw7 *iface,
2184         DDDEVICEIDENTIFIER2 *DDDI, DWORD Flags)
2185 {
2186     TRACE("iface %p, device_identifier %p, flags %#x.\n", iface, DDDI, Flags);
2187
2188     if(!DDDI)
2189         return DDERR_INVALIDPARAMS;
2190
2191     /* The DDGDI_GETHOSTIDENTIFIER returns the information about the 2D
2192      * host adapter, if there's a secondary 3D adapter. This doesn't apply
2193      * to any modern hardware, nor is it interesting for Wine, so ignore it.
2194      * Size of DDDEVICEIDENTIFIER2 may be aligned to 8 bytes and thus 4
2195      * bytes too long. So only copy the relevant part of the structure
2196      */
2197
2198     memcpy(DDDI, &deviceidentifier, FIELD_OFFSET(DDDEVICEIDENTIFIER2, dwWHQLLevel) + sizeof(DWORD));
2199     return DD_OK;
2200 }
2201
2202 static HRESULT WINAPI ddraw4_GetDeviceIdentifier(IDirectDraw4 *iface,
2203         DDDEVICEIDENTIFIER *identifier, DWORD flags)
2204 {
2205     DDDEVICEIDENTIFIER2 identifier2;
2206     HRESULT hr;
2207
2208     TRACE("iface %p, identifier %p, flags %#x.\n", iface, identifier, flags);
2209
2210     hr = ddraw7_GetDeviceIdentifier((IDirectDraw7 *)ddraw_from_ddraw4(iface), &identifier2, flags);
2211     DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1(&identifier2, identifier);
2212
2213     return hr;
2214 }
2215
2216 /*****************************************************************************
2217  * IDirectDraw7::GetSurfaceFromDC
2218  *
2219  * Returns the Surface for a GDI device context handle.
2220  * Is this related to IDirectDrawSurface::GetDC ???
2221  *
2222  * Params:
2223  *  hdc: hdc to return the surface for
2224  *  Surface: Address to write the surface pointer to
2225  *
2226  * Returns:
2227  *  Always returns DD_OK because it's a stub
2228  *
2229  *****************************************************************************/
2230 static HRESULT WINAPI ddraw7_GetSurfaceFromDC(IDirectDraw7 *iface, HDC hdc, IDirectDrawSurface7 **Surface)
2231 {
2232     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
2233     IWineD3DSurface *wined3d_surface;
2234     HRESULT hr;
2235
2236     TRACE("iface %p, dc %p, surface %p.\n", iface, hdc, Surface);
2237
2238     if (!Surface) return E_INVALIDARG;
2239
2240     hr = IWineD3DDevice_GetSurfaceFromDC(This->wineD3DDevice, hdc, &wined3d_surface);
2241     if (FAILED(hr))
2242     {
2243         TRACE("No surface found for dc %p.\n", hdc);
2244         *Surface = NULL;
2245         return DDERR_NOTFOUND;
2246     }
2247
2248     *Surface = IWineD3DSurface_GetParent(wined3d_surface);
2249     IDirectDrawSurface7_AddRef(*Surface);
2250     TRACE("Returning surface %p.\n", Surface);
2251     return DD_OK;
2252 }
2253
2254 static HRESULT WINAPI ddraw4_GetSurfaceFromDC(IDirectDraw4 *iface, HDC dc, IDirectDrawSurface4 **surface)
2255 {
2256     IDirectDrawSurface7 *surface7;
2257     HRESULT hr;
2258
2259     TRACE("iface %p, dc %p, surface %p.\n", iface, dc, surface);
2260
2261     if (!surface) return E_INVALIDARG;
2262
2263     hr = ddraw7_GetSurfaceFromDC((IDirectDraw7 *)ddraw_from_ddraw4(iface), dc, &surface7);
2264     *surface = surface7 ? (IDirectDrawSurface4 *)&((IDirectDrawSurfaceImpl *)surface7)->IDirectDrawSurface3_vtbl : NULL;
2265
2266     return hr;
2267 }
2268
2269 static HRESULT WINAPI ddraw3_GetSurfaceFromDC(IDirectDraw3 *iface, HDC dc, IDirectDrawSurface **surface)
2270 {
2271     TRACE("iface %p, dc %p, surface %p.\n", iface, dc, surface);
2272
2273     return ddraw7_GetSurfaceFromDC((IDirectDraw7 *)ddraw_from_ddraw3(iface),
2274             dc, (IDirectDrawSurface7 **)surface);
2275 }
2276
2277 /*****************************************************************************
2278  * IDirectDraw7::RestoreAllSurfaces
2279  *
2280  * Calls the restore method of all surfaces
2281  *
2282  * Params:
2283  *
2284  * Returns:
2285  *  Always returns DD_OK because it's a stub
2286  *
2287  *****************************************************************************/
2288 static HRESULT WINAPI ddraw7_RestoreAllSurfaces(IDirectDraw7 *iface)
2289 {
2290     FIXME("iface %p stub!\n", iface);
2291
2292     /* This isn't hard to implement: Enumerate all WineD3D surfaces,
2293      * get their parent and call their restore method. Do not implement
2294      * it in WineD3D, as restoring a surface means re-creating the
2295      * WineD3DDSurface
2296      */
2297     return DD_OK;
2298 }
2299
2300 static HRESULT WINAPI ddraw4_RestoreAllSurfaces(IDirectDraw4 *iface)
2301 {
2302     TRACE("iface %p.\n", iface);
2303
2304     return ddraw7_RestoreAllSurfaces((IDirectDraw7 *)ddraw_from_ddraw4(iface));
2305 }
2306
2307 /*****************************************************************************
2308  * IDirectDraw7::StartModeTest
2309  *
2310  * Tests the specified video modes to update the system registry with
2311  * refresh rate information. StartModeTest starts the mode test,
2312  * EvaluateMode is used to fail or pass a mode. If EvaluateMode
2313  * isn't called within 15 seconds, the mode is failed automatically
2314  *
2315  * As refresh rates are handled by the X server, I don't think this
2316  * Method is important
2317  *
2318  * Params:
2319  *  Modes: An array of mode specifications
2320  *  NumModes: The number of modes in Modes
2321  *  Flags: Some flags...
2322  *
2323  * Returns:
2324  *  Returns DDERR_TESTFINISHED if flags contains DDSMT_ISTESTREQUIRED,
2325  *  if no modes are passed, DDERR_INVALIDPARAMS is returned,
2326  *  otherwise DD_OK
2327  *
2328  *****************************************************************************/
2329 static HRESULT WINAPI ddraw7_StartModeTest(IDirectDraw7 *iface, SIZE *Modes, DWORD NumModes, DWORD Flags)
2330 {
2331     FIXME("iface %p, modes %p, mode_count %u, flags %#x partial stub!\n",
2332             iface, Modes, NumModes, Flags);
2333
2334     /* This looks sane */
2335     if( (!Modes) || (NumModes == 0) ) return DDERR_INVALIDPARAMS;
2336
2337     /* DDSMT_ISTESTREQUIRED asks if a mode test is necessary.
2338      * As it is not, DDERR_TESTFINISHED is returned
2339      * (hopefully that's correct
2340      *
2341     if(Flags & DDSMT_ISTESTREQUIRED) return DDERR_TESTFINISHED;
2342      * well, that value doesn't (yet) exist in the wine headers, so ignore it
2343      */
2344
2345     return DD_OK;
2346 }
2347
2348 /*****************************************************************************
2349  * ddraw_recreate_surfaces_cb
2350  *
2351  * Enumeration callback for ddraw_recreate_surface.
2352  * It re-recreates the WineD3DSurface. It's pretty straightforward
2353  *
2354  *****************************************************************************/
2355 HRESULT WINAPI ddraw_recreate_surfaces_cb(IDirectDrawSurface7 *surf, DDSURFACEDESC2 *desc, void *Context)
2356 {
2357     IDirectDrawSurfaceImpl *surfImpl = (IDirectDrawSurfaceImpl *)surf;
2358     IDirectDrawImpl *This = surfImpl->ddraw;
2359     IWineD3DSurface *wineD3DSurface;
2360     IWineD3DSwapChain *swapchain;
2361     void *parent;
2362     HRESULT hr;
2363     IWineD3DClipper *clipper = NULL;
2364
2365     WINED3DSURFACE_DESC     Desc;
2366     enum wined3d_format_id Format;
2367     DWORD                   Usage;
2368     WINED3DPOOL             Pool;
2369
2370     WINED3DMULTISAMPLE_TYPE MultiSampleType;
2371     DWORD                   MultiSampleQuality;
2372     UINT                    Width;
2373     UINT                    Height;
2374
2375     TRACE("surface %p, surface_desc %p, context %p.\n",
2376             surf, desc, Context);
2377
2378     /* For the enumeration */
2379     IDirectDrawSurface7_Release(surf);
2380
2381     if(surfImpl->ImplType == This->ImplType) return DDENUMRET_OK; /* Continue */
2382
2383     /* Get the objects */
2384     swapchain = surfImpl->wineD3DSwapChain;
2385     surfImpl->wineD3DSwapChain = NULL;
2386     wineD3DSurface = surfImpl->WineD3DSurface;
2387
2388     /* get the clipper */
2389     IWineD3DSurface_GetClipper(wineD3DSurface, &clipper);
2390
2391     /* Get the surface properties */
2392     IWineD3DSurface_GetDesc(wineD3DSurface, &Desc);
2393
2394     Format = Desc.format;
2395     Usage = Desc.usage;
2396     Pool = Desc.pool;
2397     MultiSampleType = Desc.multisample_type;
2398     MultiSampleQuality = Desc.multisample_quality;
2399     Width = Desc.width;
2400     Height = Desc.height;
2401
2402     parent = IWineD3DSurface_GetParent(wineD3DSurface);
2403     hr = IWineD3DDevice_CreateSurface(This->wineD3DDevice, Width, Height, Format, TRUE /* Lockable */,
2404             FALSE /* Discard */, surfImpl->mipmap_level, Usage, Pool, MultiSampleType, MultiSampleQuality,
2405             This->ImplType, parent, &ddraw_null_wined3d_parent_ops, &surfImpl->WineD3DSurface);
2406     if (FAILED(hr))
2407     {
2408         surfImpl->WineD3DSurface = wineD3DSurface;
2409         return hr;
2410     }
2411
2412     IWineD3DSurface_SetClipper(surfImpl->WineD3DSurface, clipper);
2413
2414     /* TODO: Copy the surface content, except for render targets */
2415
2416     /* If there's a swapchain, it owns the wined3d surfaces. So Destroy
2417      * the swapchain
2418      */
2419     if(swapchain) {
2420         /* The backbuffers have the swapchain set as well, but the primary
2421          * owns it and destroys it
2422          */
2423         if(surfImpl->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) {
2424             IWineD3DDevice_UninitGDI(This->wineD3DDevice, D3D7CB_DestroySwapChain);
2425         }
2426         surfImpl->isRenderTarget = FALSE;
2427     } else {
2428         if(IWineD3DSurface_Release(wineD3DSurface) == 0)
2429             TRACE("Surface released successful, next surface\n");
2430         else
2431             ERR("Something's still holding the old WineD3DSurface\n");
2432     }
2433
2434     surfImpl->ImplType = This->ImplType;
2435
2436     if(clipper)
2437     {
2438         IWineD3DClipper_Release(clipper);
2439     }
2440     return DDENUMRET_OK;
2441 }
2442
2443 /*****************************************************************************
2444  * ddraw_recreate_surfaces
2445  *
2446  * A function, that converts all wineD3DSurfaces to the new implementation type
2447  * It enumerates all surfaces with IWineD3DDevice::EnumSurfaces, creates a
2448  * new WineD3DSurface, copies the content and releases the old surface
2449  *
2450  *****************************************************************************/
2451 static HRESULT ddraw_recreate_surfaces(IDirectDrawImpl *This)
2452 {
2453     DDSURFACEDESC2 desc;
2454     TRACE("(%p): Switch to implementation %d\n", This, This->ImplType);
2455
2456     if(This->ImplType != SURFACE_OPENGL && This->d3d_initialized)
2457     {
2458         /* Should happen almost never */
2459         FIXME("(%p) Switching to non-opengl surfaces with d3d started. Is this a bug?\n", This);
2460         /* Shutdown d3d */
2461         IWineD3DDevice_Uninit3D(This->wineD3DDevice, D3D7CB_DestroySwapChain);
2462     }
2463     /* Contrary: D3D starting is handled by the caller, because it knows the render target */
2464
2465     memset(&desc, 0, sizeof(desc));
2466     desc.dwSize = sizeof(desc);
2467
2468     return IDirectDraw7_EnumSurfaces((IDirectDraw7 *)This, 0, &desc, This, ddraw_recreate_surfaces_cb);
2469 }
2470
2471 ULONG WINAPI D3D7CB_DestroySwapChain(IWineD3DSwapChain *pSwapChain)
2472 {
2473     IUnknown *swapChainParent;
2474
2475     TRACE("swapchain %p.\n", pSwapChain);
2476
2477     swapChainParent = IWineD3DSwapChain_GetParent(pSwapChain);
2478     return IUnknown_Release(swapChainParent);
2479 }
2480
2481 /*****************************************************************************
2482  * ddraw_create_surface
2483  *
2484  * A helper function for IDirectDraw7::CreateSurface. It creates a new surface
2485  * with the passed parameters.
2486  *
2487  * Params:
2488  *  DDSD: Description of the surface to create
2489  *  Surf: Address to store the interface pointer at
2490  *
2491  * Returns:
2492  *  DD_OK on success
2493  *
2494  *****************************************************************************/
2495 static HRESULT ddraw_create_surface(IDirectDrawImpl *This, DDSURFACEDESC2 *pDDSD,
2496         IDirectDrawSurfaceImpl **ppSurf, UINT level)
2497 {
2498     WINED3DSURFTYPE ImplType = This->ImplType;
2499     HRESULT hr;
2500
2501     TRACE("ddraw %p, surface_desc %p, surface %p, level %u.\n",
2502             This, pDDSD, ppSurf, level);
2503
2504     if (TRACE_ON(ddraw))
2505     {
2506         TRACE(" (%p) Requesting surface desc :\n", This);
2507         DDRAW_dump_surface_desc(pDDSD);
2508     }
2509
2510     /* Select the surface type, if it wasn't choosen yet */
2511     if(ImplType == SURFACE_UNKNOWN)
2512     {
2513         /* Use GL Surfaces if a D3DDEVICE Surface is requested */
2514         if(pDDSD->ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
2515         {
2516             TRACE("(%p) Choosing GL surfaces because a 3DDEVICE Surface was requested\n", This);
2517             ImplType = SURFACE_OPENGL;
2518         }
2519
2520         /* Otherwise use GDI surfaces for now */
2521         else
2522         {
2523             TRACE("(%p) Choosing GDI surfaces for 2D rendering\n", This);
2524             ImplType = SURFACE_GDI;
2525         }
2526
2527         /* Policy if all surface implementations are available:
2528          * First, check if a default type was set with winecfg. If not,
2529          * try Xrender surfaces, and use them if they work. Next, check if
2530          * accelerated OpenGL is available, and use GL surfaces in this
2531          * case. If all else fails, use GDI surfaces. If a 3DDEVICE surface
2532          * was created, always use OpenGL surfaces.
2533          *
2534          * (Note: Xrender surfaces are not implemented for now, the
2535          * unaccelerated implementation uses GDI to render in Software)
2536          */
2537
2538         /* Store the type. If it needs to be changed, all WineD3DSurfaces have to
2539          * be re-created. This could be done with IDirectDrawSurface7::Restore
2540          */
2541         This->ImplType = ImplType;
2542     }
2543     else
2544     {
2545         if ((pDDSD->ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
2546                 && (This->ImplType != SURFACE_OPENGL)
2547                 && DefaultSurfaceType == SURFACE_UNKNOWN)
2548         {
2549             /* We have to change to OpenGL,
2550              * and re-create all WineD3DSurfaces
2551              */
2552             ImplType = SURFACE_OPENGL;
2553             This->ImplType = ImplType;
2554             TRACE("(%p) Re-creating all surfaces\n", This);
2555             ddraw_recreate_surfaces(This);
2556             TRACE("(%p) Done recreating all surfaces\n", This);
2557         }
2558         else if(This->ImplType != SURFACE_OPENGL && pDDSD->ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
2559         {
2560             WARN("The application requests a 3D capable surface, but a non-opengl surface was set in the registry\n");
2561             /* Do not fail surface creation, only fail 3D device creation */
2562         }
2563     }
2564
2565     /* Create the Surface object */
2566     *ppSurf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawSurfaceImpl));
2567     if(!*ppSurf)
2568     {
2569         ERR("(%p) Error allocating memory for a surface\n", This);
2570         return DDERR_OUTOFVIDEOMEMORY;
2571     }
2572
2573     hr = ddraw_surface_init(*ppSurf, This, pDDSD, level, ImplType);
2574     if (FAILED(hr))
2575     {
2576         WARN("Failed to initialize surface, hr %#x.\n", hr);
2577         HeapFree(GetProcessHeap(), 0, *ppSurf);
2578         return hr;
2579     }
2580
2581     /* Increase the surface counter, and attach the surface */
2582     InterlockedIncrement(&This->surfaces);
2583     list_add_head(&This->surface_list, &(*ppSurf)->surface_list_entry);
2584
2585     TRACE("Created surface %p.\n", *ppSurf);
2586
2587     return DD_OK;
2588 }
2589 /*****************************************************************************
2590  * CreateAdditionalSurfaces
2591  *
2592  * Creates a new mipmap chain.
2593  *
2594  * Params:
2595  *  root: Root surface to attach the newly created chain to
2596  *  count: number of surfaces to create
2597  *  DDSD: Description of the surface. Intentionally not a pointer to avoid side
2598  *        effects on the caller
2599  *  CubeFaceRoot: Whether the new surface is a root of a cube map face. This
2600  *                creates an additional surface without the mipmapping flags
2601  *
2602  *****************************************************************************/
2603 static HRESULT
2604 CreateAdditionalSurfaces(IDirectDrawImpl *This,
2605                          IDirectDrawSurfaceImpl *root,
2606                          UINT count,
2607                          DDSURFACEDESC2 DDSD,
2608                          BOOL CubeFaceRoot)
2609 {
2610     UINT i, j, level = 0;
2611     HRESULT hr;
2612     IDirectDrawSurfaceImpl *last = root;
2613
2614     for(i = 0; i < count; i++)
2615     {
2616         IDirectDrawSurfaceImpl *object2 = NULL;
2617
2618         /* increase the mipmap level, but only if a mipmap is created
2619          * In this case, also halve the size
2620          */
2621         if(DDSD.ddsCaps.dwCaps & DDSCAPS_MIPMAP && !CubeFaceRoot)
2622         {
2623             level++;
2624             if(DDSD.dwWidth > 1) DDSD.dwWidth /= 2;
2625             if(DDSD.dwHeight > 1) DDSD.dwHeight /= 2;
2626             /* Set the mipmap sublevel flag according to msdn */
2627             DDSD.ddsCaps.dwCaps2 |= DDSCAPS2_MIPMAPSUBLEVEL;
2628         }
2629         else
2630         {
2631             DDSD.ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
2632         }
2633         CubeFaceRoot = FALSE;
2634
2635         hr = ddraw_create_surface(This, &DDSD, &object2, level);
2636         if(hr != DD_OK)
2637         {
2638             return hr;
2639         }
2640
2641         /* Add the new surface to the complex attachment array */
2642         for(j = 0; j < MAX_COMPLEX_ATTACHED; j++)
2643         {
2644             if(last->complex_array[j]) continue;
2645             last->complex_array[j] = object2;
2646             break;
2647         }
2648         last = object2;
2649
2650         /* Remove the (possible) back buffer cap from the new surface description,
2651          * because only one surface in the flipping chain is a back buffer, one
2652          * is a front buffer, the others are just primary surfaces.
2653          */
2654         DDSD.ddsCaps.dwCaps &= ~DDSCAPS_BACKBUFFER;
2655     }
2656     return DD_OK;
2657 }
2658
2659 /* Must set all attached surfaces (e.g. mipmaps) versions as well */
2660 static void ddraw_set_surface_version(IDirectDrawSurfaceImpl *surface, UINT version)
2661 {
2662     unsigned int i;
2663
2664     TRACE("surface %p, version %u -> %u.\n", surface, surface->version, version);
2665
2666     surface->version = version;
2667     for (i = 0; i < MAX_COMPLEX_ATTACHED; ++i)
2668     {
2669         if (!surface->complex_array[i]) break;
2670         ddraw_set_surface_version(surface->complex_array[i], version);
2671     }
2672     while ((surface = surface->next_attached))
2673     {
2674         ddraw_set_surface_version(surface, version);
2675     }
2676 }
2677
2678 /*****************************************************************************
2679  * ddraw_attach_d3d_device
2680  *
2681  * Initializes the D3D capabilities of WineD3D
2682  *
2683  * Params:
2684  *  primary: The primary surface for D3D
2685  *
2686  * Returns
2687  *  DD_OK on success,
2688  *  DDERR_* otherwise
2689  *
2690  *****************************************************************************/
2691 static HRESULT ddraw_attach_d3d_device(IDirectDrawImpl *ddraw, IDirectDrawSurfaceImpl *primary)
2692 {
2693     WINED3DPRESENT_PARAMETERS localParameters;
2694     HWND window = ddraw->dest_window;
2695     HRESULT hr;
2696
2697     TRACE("ddraw %p, primary %p.\n", ddraw, primary);
2698
2699     if (!window || window == GetDesktopWindow())
2700     {
2701         window = CreateWindowExA(0, DDRAW_WINDOW_CLASS_NAME, "Hidden D3D Window",
2702                 WS_DISABLED, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
2703                 NULL, NULL, NULL, NULL);
2704         if (!window)
2705         {
2706             ERR("Failed to create window, last error %#x.\n", GetLastError());
2707             return E_FAIL;
2708         }
2709
2710         ShowWindow(window, SW_HIDE);   /* Just to be sure */
2711         WARN("No window for the Direct3DDevice, created hidden window %p.\n", window);
2712     }
2713     else
2714     {
2715         TRACE("Using existing window %p for Direct3D rendering.\n", window);
2716     }
2717     ddraw->d3d_window = window;
2718
2719     /* Store the future Render Target surface */
2720     ddraw->d3d_target = primary;
2721
2722     /* Use the surface description for the device parameters, not the device
2723      * settings. The application might render to an offscreen surface. */
2724     localParameters.BackBufferWidth = primary->surface_desc.dwWidth;
2725     localParameters.BackBufferHeight = primary->surface_desc.dwHeight;
2726     localParameters.BackBufferFormat = PixelFormat_DD2WineD3D(&primary->surface_desc.u4.ddpfPixelFormat);
2727     localParameters.BackBufferCount = (primary->surface_desc.dwFlags & DDSD_BACKBUFFERCOUNT)
2728             ? primary->surface_desc.dwBackBufferCount : 0;
2729     localParameters.MultiSampleType = WINED3DMULTISAMPLE_NONE;
2730     localParameters.MultiSampleQuality = 0;
2731     localParameters.SwapEffect = WINED3DSWAPEFFECT_COPY;
2732     localParameters.hDeviceWindow = window;
2733     localParameters.Windowed = !(ddraw->cooperative_level & DDSCL_FULLSCREEN);
2734     localParameters.EnableAutoDepthStencil = TRUE;
2735     localParameters.AutoDepthStencilFormat = WINED3DFMT_D16_UNORM;
2736     localParameters.Flags = 0;
2737     localParameters.FullScreen_RefreshRateInHz = WINED3DPRESENT_RATE_DEFAULT;
2738     localParameters.PresentationInterval = WINED3DPRESENT_INTERVAL_DEFAULT;
2739
2740     /* Set this NOW, otherwise creating the depth stencil surface will cause a
2741      * recursive loop until ram or emulated video memory is full. */
2742     ddraw->d3d_initialized = TRUE;
2743     hr = IWineD3DDevice_Init3D(ddraw->wineD3DDevice, &localParameters);
2744     if (FAILED(hr))
2745     {
2746         ddraw->d3d_target = NULL;
2747         ddraw->d3d_initialized = FALSE;
2748         return hr;
2749     }
2750
2751     ddraw->declArraySize = 2;
2752     ddraw->decls = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ddraw->decls) * ddraw->declArraySize);
2753     if (!ddraw->decls)
2754     {
2755         ERR("Error allocating an array for the converted vertex decls.\n");
2756         ddraw->declArraySize = 0;
2757         hr = IWineD3DDevice_Uninit3D(ddraw->wineD3DDevice, D3D7CB_DestroySwapChain);
2758         return E_OUTOFMEMORY;
2759     }
2760
2761     TRACE("Successfully initialized 3D.\n");
2762
2763     return DD_OK;
2764 }
2765
2766 static HRESULT ddraw_create_gdi_swapchain(IDirectDrawImpl *ddraw, IDirectDrawSurfaceImpl *primary)
2767 {
2768     WINED3DPRESENT_PARAMETERS presentation_parameters;
2769     HWND window;
2770     HRESULT hr;
2771
2772     window = ddraw->dest_window;
2773
2774     memset(&presentation_parameters, 0, sizeof(presentation_parameters));
2775
2776     /* Use the surface description for the device parameters, not the device
2777      * settings. The application might render to an offscreen surface. */
2778     presentation_parameters.BackBufferWidth = primary->surface_desc.dwWidth;
2779     presentation_parameters.BackBufferHeight = primary->surface_desc.dwHeight;
2780     presentation_parameters.BackBufferFormat = PixelFormat_DD2WineD3D(&primary->surface_desc.u4.ddpfPixelFormat);
2781     presentation_parameters.BackBufferCount = (primary->surface_desc.dwFlags & DDSD_BACKBUFFERCOUNT)
2782             ? primary->surface_desc.dwBackBufferCount : 0;
2783     presentation_parameters.MultiSampleType = WINED3DMULTISAMPLE_NONE;
2784     presentation_parameters.MultiSampleQuality = 0;
2785     presentation_parameters.SwapEffect = WINED3DSWAPEFFECT_FLIP;
2786     presentation_parameters.hDeviceWindow = window;
2787     presentation_parameters.Windowed = !(ddraw->cooperative_level & DDSCL_FULLSCREEN);
2788     presentation_parameters.EnableAutoDepthStencil = FALSE; /* Not on GDI swapchains */
2789     presentation_parameters.AutoDepthStencilFormat = 0;
2790     presentation_parameters.Flags = 0;
2791     presentation_parameters.FullScreen_RefreshRateInHz = WINED3DPRESENT_RATE_DEFAULT;
2792     presentation_parameters.PresentationInterval = WINED3DPRESENT_INTERVAL_DEFAULT;
2793
2794     ddraw->d3d_target = primary;
2795     hr = IWineD3DDevice_InitGDI(ddraw->wineD3DDevice, &presentation_parameters);
2796     ddraw->d3d_target = NULL;
2797     if (FAILED(hr))
2798     {
2799         WARN("Failed to initialize GDI ddraw implementation, hr %#x.\n", hr);
2800         primary->wineD3DSwapChain = NULL;
2801     }
2802
2803     return hr;
2804 }
2805
2806 /*****************************************************************************
2807  * IDirectDraw7::CreateSurface
2808  *
2809  * Creates a new IDirectDrawSurface object and returns its interface.
2810  *
2811  * The surface connections with wined3d are a bit tricky. Basically it works
2812  * like this:
2813  *
2814  * |------------------------|               |-----------------|
2815  * | DDraw surface          |               | WineD3DSurface  |
2816  * |                        |               |                 |
2817  * |        WineD3DSurface  |-------------->|                 |
2818  * |        Child           |<------------->| Parent          |
2819  * |------------------------|               |-----------------|
2820  *
2821  * The DDraw surface is the parent of the wined3d surface, and it releases
2822  * the WineD3DSurface when the ddraw surface is destroyed.
2823  *
2824  * However, for all surfaces which can be in a container in WineD3D,
2825  * we have to do this. These surfaces are usually complex surfaces,
2826  * so this concerns primary surfaces with a front and a back buffer,
2827  * and textures.
2828  *
2829  * |------------------------|               |-----------------|
2830  * | DDraw surface          |               | Container       |
2831  * |                        |               |                 |
2832  * |                  Child |<------------->| Parent          |
2833  * |                Texture |<------------->|                 |
2834  * |         WineD3DSurface |<----|         |          Levels |<--|
2835  * | Complex connection     |     |         |                 |   |
2836  * |------------------------|     |         |-----------------|   |
2837  *  ^                             |                               |
2838  *  |                             |                               |
2839  *  |                             |                               |
2840  *  |    |------------------|     |         |-----------------|   |
2841  *  |    | IParent          |     |-------->| WineD3DSurface  |   |
2842  *  |    |                  |               |                 |   |
2843  *  |    |            Child |<------------->| Parent          |   |
2844  *  |    |                  |               |       Container |<--|
2845  *  |    |------------------|               |-----------------|   |
2846  *  |                                                             |
2847  *  |   |----------------------|                                  |
2848  *  |   | DDraw surface 2      |                                  |
2849  *  |   |                      |                                  |
2850  *  |<->| Complex root   Child |                                  |
2851  *  |   |              Texture |                                  |
2852  *  |   |       WineD3DSurface |<----|                            |
2853  *  |   |----------------------|     |                            |
2854  *  |                                |                            |
2855  *  |    |---------------------|     |      |-----------------|   |
2856  *  |    | IParent             |     |----->| WineD3DSurface  |   |
2857  *  |    |                     |            |                 |   |
2858  *  |    |               Child |<---------->| Parent          |   |
2859  *  |    |---------------------|            |       Container |<--|
2860  *  |                                       |-----------------|   |
2861  *  |                                                             |
2862  *  |             ---More surfaces can follow---                  |
2863  *
2864  * The reason is that the IWineD3DSwapchain(render target container)
2865  * and the IWineD3DTexure(Texture container) release the parents
2866  * of their surface's children, but by releasing the complex root
2867  * the surfaces which are complexly attached to it are destroyed
2868  * too. See IDirectDrawSurface::Release for a more detailed
2869  * explanation.
2870  *
2871  * Params:
2872  *  DDSD: Description of the surface to create
2873  *  Surf: Address to store the interface pointer at
2874  *  UnkOuter: Basically for aggregation support, but ddraw doesn't support
2875  *            aggregation, so it has to be NULL
2876  *
2877  * Returns:
2878  *  DD_OK on success
2879  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
2880  *  DDERR_* if an error occurs
2881  *
2882  *****************************************************************************/
2883 static HRESULT CreateSurface(IDirectDraw7 *iface,
2884         DDSURFACEDESC2 *DDSD, IDirectDrawSurface7 **Surf, IUnknown *UnkOuter)
2885 {
2886     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
2887     IDirectDrawSurfaceImpl *object = NULL;
2888     HRESULT hr;
2889     LONG extra_surfaces = 0;
2890     DDSURFACEDESC2 desc2;
2891     WINED3DDISPLAYMODE Mode;
2892     const DWORD sysvidmem = DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY;
2893
2894     TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
2895             iface, DDSD, Surf, UnkOuter);
2896
2897     /* Some checks before we start */
2898     if (TRACE_ON(ddraw))
2899     {
2900         TRACE(" (%p) Requesting surface desc :\n", This);
2901         DDRAW_dump_surface_desc(DDSD);
2902     }
2903     EnterCriticalSection(&ddraw_cs);
2904
2905     if (UnkOuter != NULL)
2906     {
2907         FIXME("(%p) : outer != NULL?\n", This);
2908         LeaveCriticalSection(&ddraw_cs);
2909         return CLASS_E_NOAGGREGATION; /* unchecked */
2910     }
2911
2912     if (Surf == NULL)
2913     {
2914         FIXME("(%p) You want to get back a surface? Don't give NULL ptrs!\n", This);
2915         LeaveCriticalSection(&ddraw_cs);
2916         return E_POINTER; /* unchecked */
2917     }
2918
2919     if (!(DDSD->dwFlags & DDSD_CAPS))
2920     {
2921         /* DVIDEO.DLL does forget the DDSD_CAPS flag ... *sigh* */
2922         DDSD->dwFlags |= DDSD_CAPS;
2923     }
2924
2925     if (DDSD->ddsCaps.dwCaps & DDSCAPS_ALLOCONLOAD)
2926     {
2927         /* If the surface is of the 'alloconload' type, ignore the LPSURFACE field */
2928         DDSD->dwFlags &= ~DDSD_LPSURFACE;
2929     }
2930
2931     if ((DDSD->dwFlags & DDSD_LPSURFACE) && (DDSD->lpSurface == NULL))
2932     {
2933         /* Frank Herbert's Dune specifies a null pointer for the surface, ignore the LPSURFACE field */
2934         WARN("(%p) Null surface pointer specified, ignore it!\n", This);
2935         DDSD->dwFlags &= ~DDSD_LPSURFACE;
2936     }
2937
2938     if((DDSD->ddsCaps.dwCaps & (DDSCAPS_FLIP | DDSCAPS_PRIMARYSURFACE)) == (DDSCAPS_FLIP | DDSCAPS_PRIMARYSURFACE) &&
2939        !(This->cooperative_level & DDSCL_EXCLUSIVE))
2940     {
2941         TRACE("(%p): Attempt to create a flipable primary surface without DDSCL_EXCLUSIVE set\n", This);
2942         *Surf = NULL;
2943         LeaveCriticalSection(&ddraw_cs);
2944         return DDERR_NOEXCLUSIVEMODE;
2945     }
2946
2947     if((DDSD->ddsCaps.dwCaps & (DDSCAPS_BACKBUFFER | DDSCAPS_PRIMARYSURFACE)) == (DDSCAPS_BACKBUFFER | DDSCAPS_PRIMARYSURFACE))
2948     {
2949         WARN("Application wanted to create back buffer primary surface\n");
2950         LeaveCriticalSection(&ddraw_cs);
2951         return DDERR_INVALIDCAPS;
2952     }
2953
2954     if((DDSD->ddsCaps.dwCaps & sysvidmem) == sysvidmem)
2955     {
2956         /* This is a special switch in ddrawex.dll, but not allowed in ddraw.dll */
2957         WARN("Application tries to put the surface in both system and video memory\n");
2958         LeaveCriticalSection(&ddraw_cs);
2959         *Surf = NULL;
2960         return DDERR_INVALIDCAPS;
2961     }
2962
2963     /* Check cube maps but only if the size includes them */
2964     if (DDSD->dwSize >= sizeof(DDSURFACEDESC2))
2965     {
2966         if(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES &&
2967            !(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP))
2968         {
2969             WARN("Cube map faces requested without cube map flag\n");
2970             LeaveCriticalSection(&ddraw_cs);
2971             return DDERR_INVALIDCAPS;
2972         }
2973         if(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP &&
2974            (DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) == 0)
2975         {
2976             WARN("Cube map without faces requested\n");
2977             LeaveCriticalSection(&ddraw_cs);
2978             return DDERR_INVALIDPARAMS;
2979         }
2980
2981         /* Quick tests confirm those can be created, but we don't do that yet */
2982         if(DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP &&
2983            (DDSD->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) != DDSCAPS2_CUBEMAP_ALLFACES)
2984         {
2985             FIXME("Partial cube maps not supported yet\n");
2986         }
2987     }
2988
2989     /* According to the msdn this flag is ignored by CreateSurface */
2990     if (DDSD->dwSize >= sizeof(DDSURFACEDESC2))
2991         DDSD->ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
2992
2993     /* Modify some flags */
2994     memset(&desc2, 0, sizeof(desc2));
2995     desc2.dwSize = sizeof(desc2);   /* For the struct copy */
2996     DD_STRUCT_COPY_BYSIZE(&desc2, DDSD);
2997     desc2.dwSize = sizeof(desc2);   /* To override a possibly smaller size */
2998     desc2.u4.ddpfPixelFormat.dwSize=sizeof(DDPIXELFORMAT); /* Just to be sure */
2999
3000     /* Get the video mode from WineD3D - we will need it */
3001     hr = IWineD3DDevice_GetDisplayMode(This->wineD3DDevice,
3002                                        0, /* Swapchain 0 */
3003                                        &Mode);
3004     if(FAILED(hr))
3005     {
3006         ERR("Failed to read display mode from wined3d\n");
3007         switch(This->orig_bpp)
3008         {
3009             case 8:
3010                 Mode.Format = WINED3DFMT_P8_UINT;
3011                 break;
3012
3013             case 15:
3014                 Mode.Format = WINED3DFMT_B5G5R5X1_UNORM;
3015                 break;
3016
3017             case 16:
3018                 Mode.Format = WINED3DFMT_B5G6R5_UNORM;
3019                 break;
3020
3021             case 24:
3022                 Mode.Format = WINED3DFMT_B8G8R8_UNORM;
3023                 break;
3024
3025             case 32:
3026                 Mode.Format = WINED3DFMT_B8G8R8X8_UNORM;
3027                 break;
3028         }
3029         Mode.Width = This->orig_width;
3030         Mode.Height = This->orig_height;
3031     }
3032
3033     /* No pixelformat given? Use the current screen format */
3034     if(!(desc2.dwFlags & DDSD_PIXELFORMAT))
3035     {
3036         desc2.dwFlags |= DDSD_PIXELFORMAT;
3037         desc2.u4.ddpfPixelFormat.dwSize=sizeof(DDPIXELFORMAT);
3038
3039         /* Wait: It could be a Z buffer */
3040         if(desc2.ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
3041         {
3042             switch(desc2.u2.dwMipMapCount) /* Who had this glorious idea? */
3043             {
3044                 case 15:
3045                     PixelFormat_WineD3DtoDD(&desc2.u4.ddpfPixelFormat, WINED3DFMT_S1_UINT_D15_UNORM);
3046                     break;
3047                 case 16:
3048                     PixelFormat_WineD3DtoDD(&desc2.u4.ddpfPixelFormat, WINED3DFMT_D16_UNORM);
3049                     break;
3050                 case 24:
3051                     PixelFormat_WineD3DtoDD(&desc2.u4.ddpfPixelFormat, WINED3DFMT_X8D24_UNORM);
3052                     break;
3053                 case 32:
3054                     PixelFormat_WineD3DtoDD(&desc2.u4.ddpfPixelFormat, WINED3DFMT_D32_UNORM);
3055                     break;
3056                 default:
3057                     ERR("Unknown Z buffer bit depth\n");
3058             }
3059         }
3060         else
3061         {
3062             PixelFormat_WineD3DtoDD(&desc2.u4.ddpfPixelFormat, Mode.Format);
3063         }
3064     }
3065
3066     /* No Width or no Height? Use the original screen size
3067      */
3068     if(!(desc2.dwFlags & DDSD_WIDTH) ||
3069        !(desc2.dwFlags & DDSD_HEIGHT) )
3070     {
3071         /* Invalid for non-render targets */
3072         if(!(desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
3073         {
3074             WARN("Creating a non-Primary surface without Width or Height info, returning DDERR_INVALIDPARAMS\n");
3075             *Surf = NULL;
3076             LeaveCriticalSection(&ddraw_cs);
3077             return DDERR_INVALIDPARAMS;
3078         }
3079
3080         desc2.dwFlags |= DDSD_WIDTH | DDSD_HEIGHT;
3081         desc2.dwWidth = Mode.Width;
3082         desc2.dwHeight = Mode.Height;
3083     }
3084
3085     /* Mipmap count fixes */
3086     if(desc2.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
3087     {
3088         if(desc2.ddsCaps.dwCaps & DDSCAPS_COMPLEX)
3089         {
3090             if(desc2.dwFlags & DDSD_MIPMAPCOUNT)
3091             {
3092                 /* Mipmap count is given, should not be 0 */
3093                 if( desc2.u2.dwMipMapCount == 0 )
3094                 {
3095                     LeaveCriticalSection(&ddraw_cs);
3096                     return DDERR_INVALIDPARAMS;
3097                 }
3098             }
3099             else
3100             {
3101                 /* Undocumented feature: Create sublevels until
3102                  * either the width or the height is 1
3103                  */
3104                 DWORD min = desc2.dwWidth < desc2.dwHeight ?
3105                             desc2.dwWidth : desc2.dwHeight;
3106                 desc2.u2.dwMipMapCount = 0;
3107                 while( min )
3108                 {
3109                     desc2.u2.dwMipMapCount += 1;
3110                     min >>= 1;
3111                 }
3112             }
3113         }
3114         else
3115         {
3116             /* Not-complex mipmap -> Mipmapcount = 1 */
3117             desc2.u2.dwMipMapCount = 1;
3118         }
3119         extra_surfaces = desc2.u2.dwMipMapCount - 1;
3120
3121         /* There's a mipmap count in the created surface in any case */
3122         desc2.dwFlags |= DDSD_MIPMAPCOUNT;
3123     }
3124     /* If no mipmap is given, the texture has only one level */
3125
3126     /* The first surface is a front buffer, the back buffer is created afterwards */
3127     if( (desc2.dwFlags & DDSD_CAPS) && (desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) )
3128     {
3129         desc2.ddsCaps.dwCaps |= DDSCAPS_FRONTBUFFER;
3130     }
3131
3132     /* The root surface in a cube map is positive x */
3133     if(desc2.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
3134     {
3135         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
3136         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_POSITIVEX;
3137     }
3138
3139     /* Create the first surface */
3140     hr = ddraw_create_surface(This, &desc2, &object, 0);
3141     if (FAILED(hr))
3142     {
3143         WARN("ddraw_create_surface failed, hr %#x.\n", hr);
3144         LeaveCriticalSection(&ddraw_cs);
3145         return hr;
3146     }
3147     object->is_complex_root = TRUE;
3148
3149     *Surf = (IDirectDrawSurface7 *)object;
3150
3151     /* Create Additional surfaces if necessary
3152      * This applies to Primary surfaces which have a back buffer count
3153      * set, but not to mipmap textures. In case of Mipmap textures,
3154      * wineD3D takes care of the creation of additional surfaces
3155      */
3156     if(DDSD->dwFlags & DDSD_BACKBUFFERCOUNT)
3157     {
3158         extra_surfaces = DDSD->dwBackBufferCount;
3159         desc2.ddsCaps.dwCaps &= ~DDSCAPS_FRONTBUFFER; /* It's not a front buffer */
3160         desc2.ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
3161         desc2.dwBackBufferCount = 0;
3162     }
3163
3164     hr = DD_OK;
3165     if(desc2.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
3166     {
3167         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
3168         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_NEGATIVEZ;
3169         hr |= CreateAdditionalSurfaces(This, object, extra_surfaces + 1, desc2, TRUE);
3170         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_NEGATIVEZ;
3171         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_POSITIVEZ;
3172         hr |= CreateAdditionalSurfaces(This, object, extra_surfaces + 1, desc2, TRUE);
3173         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_POSITIVEZ;
3174         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_NEGATIVEY;
3175         hr |= CreateAdditionalSurfaces(This, object, extra_surfaces + 1, desc2, TRUE);
3176         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_NEGATIVEY;
3177         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_POSITIVEY;
3178         hr |= CreateAdditionalSurfaces(This, object, extra_surfaces + 1, desc2, TRUE);
3179         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_POSITIVEY;
3180         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_NEGATIVEX;
3181         hr |= CreateAdditionalSurfaces(This, object, extra_surfaces + 1, desc2, TRUE);
3182         desc2.ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_NEGATIVEX;
3183         desc2.ddsCaps.dwCaps2 |=  DDSCAPS2_CUBEMAP_POSITIVEX;
3184     }
3185
3186     hr |= CreateAdditionalSurfaces(This, object, extra_surfaces, desc2, FALSE);
3187     if(hr != DD_OK)
3188     {
3189         /* This destroys and possibly created surfaces too */
3190         IDirectDrawSurface_Release((IDirectDrawSurface7 *)object);
3191         LeaveCriticalSection(&ddraw_cs);
3192         return hr;
3193     }
3194
3195     /* If the implementation is OpenGL and there's no d3ddevice, attach a d3ddevice
3196      * But attach the d3ddevice only if the currently created surface was
3197      * a primary surface (2D app in 3D mode) or a 3DDEVICE surface (3D app)
3198      * The only case I can think of where this doesn't apply is when a
3199      * 2D app was configured by the user to run with OpenGL and it didn't create
3200      * the render target as first surface. In this case the render target creation
3201      * will cause the 3D init.
3202      */
3203     if( (This->ImplType == SURFACE_OPENGL) && !(This->d3d_initialized) &&
3204         desc2.ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE) )
3205     {
3206         IDirectDrawSurfaceImpl *target = object, *surface;
3207         struct list *entry;
3208
3209         /* Search for the primary to use as render target */
3210         LIST_FOR_EACH(entry, &This->surface_list)
3211         {
3212             surface = LIST_ENTRY(entry, IDirectDrawSurfaceImpl, surface_list_entry);
3213             if((surface->surface_desc.ddsCaps.dwCaps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER)) ==
3214                (DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER))
3215             {
3216                 /* found */
3217                 target = surface;
3218                 TRACE("Using primary %p as render target\n", target);
3219                 break;
3220             }
3221         }
3222
3223         TRACE("(%p) Attaching a D3DDevice, rendertarget = %p\n", This, target);
3224         hr = ddraw_attach_d3d_device(This, target);
3225         if (hr != D3D_OK)
3226         {
3227             IDirectDrawSurfaceImpl *release_surf;
3228             ERR("ddraw_attach_d3d_device failed, hr %#x\n", hr);
3229             *Surf = NULL;
3230
3231             /* The before created surface structures are in an incomplete state here.
3232              * WineD3D holds the reference on the IParents, and it released them on the failure
3233              * already. So the regular release method implementation would fail on the attempt
3234              * to destroy either the IParents or the swapchain. So free the surface here.
3235              * The surface structure here is a list, not a tree, because onscreen targets
3236              * cannot be cube textures
3237              */
3238             while(object)
3239             {
3240                 release_surf = object;
3241                 object = object->complex_array[0];
3242                 ddraw_surface_destroy(release_surf);
3243             }
3244             LeaveCriticalSection(&ddraw_cs);
3245             return hr;
3246         }
3247     }
3248     else if(!(This->d3d_initialized) && desc2.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
3249     {
3250         ddraw_create_gdi_swapchain(This, object);
3251     }
3252
3253     /* Addref the ddraw interface to keep an reference for each surface */
3254     IDirectDraw7_AddRef(iface);
3255     object->ifaceToRelease = (IUnknown *) iface;
3256
3257     /* Create a WineD3DTexture if a texture was requested */
3258     if(desc2.ddsCaps.dwCaps & DDSCAPS_TEXTURE)
3259     {
3260         enum wined3d_format_id Format;
3261         UINT levels;
3262         WINED3DPOOL Pool = WINED3DPOOL_DEFAULT;
3263
3264         This->tex_root = object;
3265
3266         if(desc2.ddsCaps.dwCaps & DDSCAPS_MIPMAP)
3267         {
3268             /* a mipmap is created, create enough levels */
3269             levels = desc2.u2.dwMipMapCount;
3270         }
3271         else
3272         {
3273             /* No mipmap is created, create one level */
3274             levels = 1;
3275         }
3276
3277         /* DDSCAPS_SYSTEMMEMORY textures are in WINED3DPOOL_SYSTEMMEM */
3278         if(DDSD->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)
3279         {
3280             Pool = WINED3DPOOL_SYSTEMMEM;
3281         }
3282         /* Should I forward the MANAGED cap to the managed pool ? */
3283
3284         /* Get the format. It's set already by CreateNewSurface */
3285         Format = PixelFormat_DD2WineD3D(&object->surface_desc.u4.ddpfPixelFormat);
3286
3287         /* The surfaces are already created, the callback only
3288          * passes the IWineD3DSurface to WineD3D
3289          */
3290         if(desc2.ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
3291         {
3292             hr = IWineD3DDevice_CreateCubeTexture(This->wineD3DDevice, DDSD->dwWidth /* Edgelength */, levels,
3293                     0 /* usage */, Format, Pool, object, &ddraw_null_wined3d_parent_ops,
3294                     (IWineD3DCubeTexture **)&object->wineD3DTexture);
3295         }
3296         else
3297         {
3298             hr = IWineD3DDevice_CreateTexture(This->wineD3DDevice, DDSD->dwWidth, DDSD->dwHeight, levels,
3299                     0 /* usage */, Format, Pool, object, &ddraw_null_wined3d_parent_ops,
3300                     (IWineD3DTexture **)&object->wineD3DTexture);
3301         }
3302         This->tex_root = NULL;
3303     }
3304
3305     LeaveCriticalSection(&ddraw_cs);
3306     return hr;
3307 }
3308
3309 static HRESULT WINAPI ddraw7_CreateSurface(IDirectDraw7 *iface,
3310         DDSURFACEDESC2 *surface_desc, IDirectDrawSurface7 **surface, IUnknown *outer_unknown)
3311 {
3312     TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3313             iface, surface_desc, surface, outer_unknown);
3314
3315     if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC2))
3316     {
3317         WARN("Application supplied invalid surface descriptor\n");
3318         return DDERR_INVALIDPARAMS;
3319     }
3320
3321     if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
3322     {
3323         if (TRACE_ON(ddraw))
3324         {
3325             TRACE(" (%p) Requesting surface desc :\n", iface);
3326             DDRAW_dump_surface_desc(surface_desc);
3327         }
3328
3329         WARN("Application tried to create an explicit front or back buffer\n");
3330         return DDERR_INVALIDCAPS;
3331     }
3332
3333     return CreateSurface(iface, surface_desc, surface, outer_unknown);
3334 }
3335
3336 static HRESULT WINAPI ddraw4_CreateSurface(IDirectDraw4 *iface,
3337         DDSURFACEDESC2 *surface_desc, IDirectDrawSurface4 **surface, IUnknown *outer_unknown)
3338 {
3339     IDirectDrawImpl *ddraw = ddraw_from_ddraw4(iface);
3340     IDirectDrawSurfaceImpl *impl;
3341     HRESULT hr;
3342
3343     TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3344             iface, surface_desc, surface, outer_unknown);
3345
3346     if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC2))
3347     {
3348         WARN("Application supplied invalid surface descriptor\n");
3349         return DDERR_INVALIDPARAMS;
3350     }
3351
3352     if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
3353     {
3354         if (TRACE_ON(ddraw))
3355         {
3356             TRACE(" (%p) Requesting surface desc :\n", iface);
3357             DDRAW_dump_surface_desc(surface_desc);
3358         }
3359
3360         WARN("Application tried to create an explicit front or back buffer\n");
3361         return DDERR_INVALIDCAPS;
3362     }
3363
3364     hr = CreateSurface((IDirectDraw7 *)ddraw, surface_desc, (IDirectDrawSurface7 **)surface, outer_unknown);
3365     impl = (IDirectDrawSurfaceImpl *)*surface;
3366     if (SUCCEEDED(hr) && impl)
3367     {
3368         ddraw_set_surface_version(impl, 4);
3369         IDirectDraw7_Release((IDirectDraw7 *)ddraw);
3370         IDirectDraw4_AddRef(iface);
3371         impl->ifaceToRelease = (IUnknown *)iface;
3372     }
3373
3374     return hr;
3375 }
3376
3377 static HRESULT WINAPI ddraw3_CreateSurface(IDirectDraw3 *iface,
3378         DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
3379 {
3380     IDirectDrawImpl *ddraw = ddraw_from_ddraw3(iface);
3381     IDirectDrawSurface7 *surface7;
3382     IDirectDrawSurfaceImpl *impl;
3383     HRESULT hr;
3384
3385     TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3386             iface, surface_desc, surface, outer_unknown);
3387
3388     if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
3389     {
3390         WARN("Application supplied invalid surface descriptor\n");
3391         return DDERR_INVALIDPARAMS;
3392     }
3393
3394     if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
3395     {
3396         if (TRACE_ON(ddraw))
3397         {
3398             TRACE(" (%p) Requesting surface desc :\n", iface);
3399             DDRAW_dump_surface_desc((LPDDSURFACEDESC2)surface_desc);
3400         }
3401
3402         WARN("Application tried to create an explicit front or back buffer\n");
3403         return DDERR_INVALIDCAPS;
3404     }
3405
3406     hr = CreateSurface((IDirectDraw7 *)ddraw, (DDSURFACEDESC2 *)surface_desc, &surface7, outer_unknown);
3407     if (FAILED(hr))
3408     {
3409         *surface = NULL;
3410         return hr;
3411     }
3412
3413     impl = (IDirectDrawSurfaceImpl *)surface7;
3414     *surface = (IDirectDrawSurface *)&impl->IDirectDrawSurface3_vtbl;
3415     ddraw_set_surface_version(impl, 3);
3416     IDirectDraw7_Release((IDirectDraw7 *)ddraw);
3417     IDirectDraw3_AddRef(iface);
3418     impl->ifaceToRelease = (IUnknown *)iface;
3419
3420     return hr;
3421 }
3422
3423 static HRESULT WINAPI ddraw2_CreateSurface(IDirectDraw2 *iface,
3424         DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
3425 {
3426     IDirectDrawImpl *ddraw = ddraw_from_ddraw2(iface);
3427     IDirectDrawSurface7 *surface7;
3428     IDirectDrawSurfaceImpl *impl;
3429     HRESULT hr;
3430
3431     TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3432             iface, surface_desc, surface, outer_unknown);
3433
3434     if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
3435     {
3436         WARN("Application supplied invalid surface descriptor\n");
3437         return DDERR_INVALIDPARAMS;
3438     }
3439
3440     if(surface_desc->ddsCaps.dwCaps & (DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER))
3441     {
3442         if (TRACE_ON(ddraw))
3443         {
3444             TRACE(" (%p) Requesting surface desc :\n", iface);
3445             DDRAW_dump_surface_desc((LPDDSURFACEDESC2)surface_desc);
3446         }
3447
3448         WARN("Application tried to create an explicit front or back buffer\n");
3449         return DDERR_INVALIDCAPS;
3450     }
3451
3452     hr = CreateSurface((IDirectDraw7 *)ddraw, (DDSURFACEDESC2 *)surface_desc, &surface7, outer_unknown);
3453     if (FAILED(hr))
3454     {
3455         *surface = NULL;
3456         return hr;
3457     }
3458
3459     impl = (IDirectDrawSurfaceImpl *)surface7;
3460     *surface = (IDirectDrawSurface *)&impl->IDirectDrawSurface3_vtbl;
3461     ddraw_set_surface_version(impl, 2);
3462     IDirectDraw7_Release((IDirectDraw7 *)ddraw);
3463     impl->ifaceToRelease = NULL;
3464
3465     return hr;
3466 }
3467
3468 static HRESULT WINAPI ddraw1_CreateSurface(IDirectDraw *iface,
3469         DDSURFACEDESC *surface_desc, IDirectDrawSurface **surface, IUnknown *outer_unknown)
3470 {
3471     IDirectDrawImpl *ddraw = ddraw_from_ddraw1(iface);
3472     IDirectDrawSurface7 *surface7;
3473     IDirectDrawSurfaceImpl *impl;
3474     HRESULT hr;
3475
3476     TRACE("iface %p, surface_desc %p, surface %p, outer_unknown %p.\n",
3477             iface, surface_desc, surface, outer_unknown);
3478
3479     if(surface_desc == NULL || surface_desc->dwSize != sizeof(DDSURFACEDESC))
3480     {
3481         WARN("Application supplied invalid surface descriptor\n");
3482         return DDERR_INVALIDPARAMS;
3483     }
3484
3485     /* Remove front buffer flag, this causes failure in v7, and its added to normal
3486      * primaries anyway. */
3487     surface_desc->ddsCaps.dwCaps &= ~DDSCAPS_FRONTBUFFER;
3488     hr = CreateSurface((IDirectDraw7 *)ddraw, (DDSURFACEDESC2 *)surface_desc, &surface7, outer_unknown);
3489     if (FAILED(hr))
3490     {
3491         *surface = NULL;
3492         return hr;
3493     }
3494
3495     impl = (IDirectDrawSurfaceImpl *)surface7;
3496     *surface = (IDirectDrawSurface *)&impl->IDirectDrawSurface3_vtbl;
3497     ddraw_set_surface_version(impl, 1);
3498     IDirectDraw7_Release((IDirectDraw7 *)ddraw);
3499     impl->ifaceToRelease = NULL;
3500
3501     return hr;
3502 }
3503
3504 #define DDENUMSURFACES_SEARCHTYPE (DDENUMSURFACES_CANBECREATED|DDENUMSURFACES_DOESEXIST)
3505 #define DDENUMSURFACES_MATCHTYPE (DDENUMSURFACES_ALL|DDENUMSURFACES_MATCH|DDENUMSURFACES_NOMATCH)
3506
3507 static BOOL
3508 Main_DirectDraw_DDPIXELFORMAT_Match(const DDPIXELFORMAT *requested,
3509                                     const DDPIXELFORMAT *provided)
3510 {
3511     /* Some flags must be present in both or neither for a match. */
3512     static const DWORD must_match = DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2
3513         | DDPF_PALETTEINDEXED4 | DDPF_PALETTEINDEXED8 | DDPF_FOURCC
3514         | DDPF_ZBUFFER | DDPF_STENCILBUFFER;
3515
3516     if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
3517         return FALSE;
3518
3519     if ((requested->dwFlags & must_match) != (provided->dwFlags & must_match))
3520         return FALSE;
3521
3522     if (requested->dwFlags & DDPF_FOURCC)
3523         if (requested->dwFourCC != provided->dwFourCC)
3524             return FALSE;
3525
3526     if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_ALPHA
3527                               |DDPF_LUMINANCE|DDPF_BUMPDUDV))
3528         if (requested->u1.dwRGBBitCount != provided->u1.dwRGBBitCount)
3529             return FALSE;
3530
3531     if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
3532                               |DDPF_LUMINANCE|DDPF_BUMPDUDV))
3533         if (requested->u2.dwRBitMask != provided->u2.dwRBitMask)
3534             return FALSE;
3535
3536     if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_ZBUFFER|DDPF_BUMPDUDV))
3537         if (requested->u3.dwGBitMask != provided->u3.dwGBitMask)
3538             return FALSE;
3539
3540     /* I could be wrong about the bumpmapping. MSDN docs are vague. */
3541     if (requested->dwFlags & (DDPF_RGB|DDPF_YUV|DDPF_STENCILBUFFER
3542                               |DDPF_BUMPDUDV))
3543         if (requested->u4.dwBBitMask != provided->u4.dwBBitMask)
3544             return FALSE;
3545
3546     if (requested->dwFlags & (DDPF_ALPHAPIXELS|DDPF_ZPIXELS))
3547         if (requested->u5.dwRGBAlphaBitMask != provided->u5.dwRGBAlphaBitMask)
3548             return FALSE;
3549
3550     return TRUE;
3551 }
3552
3553 static BOOL ddraw_match_surface_desc(const DDSURFACEDESC2 *requested, const DDSURFACEDESC2 *provided)
3554 {
3555     struct compare_info
3556     {
3557         DWORD flag;
3558         ptrdiff_t offset;
3559         size_t size;
3560     };
3561
3562 #define CMP(FLAG, FIELD)                                \
3563         { DDSD_##FLAG, offsetof(DDSURFACEDESC2, FIELD), \
3564           sizeof(((DDSURFACEDESC2 *)(NULL))->FIELD) }
3565
3566     static const struct compare_info compare[] =
3567     {
3568         CMP(ALPHABITDEPTH, dwAlphaBitDepth),
3569         CMP(BACKBUFFERCOUNT, dwBackBufferCount),
3570         CMP(CAPS, ddsCaps),
3571         CMP(CKDESTBLT, ddckCKDestBlt),
3572         CMP(CKDESTOVERLAY, u3 /* ddckCKDestOverlay */),
3573         CMP(CKSRCBLT, ddckCKSrcBlt),
3574         CMP(CKSRCOVERLAY, ddckCKSrcOverlay),
3575         CMP(HEIGHT, dwHeight),
3576         CMP(LINEARSIZE, u1 /* dwLinearSize */),
3577         CMP(LPSURFACE, lpSurface),
3578         CMP(MIPMAPCOUNT, u2 /* dwMipMapCount */),
3579         CMP(PITCH, u1 /* lPitch */),
3580         /* PIXELFORMAT: manual */
3581         CMP(REFRESHRATE, u2 /* dwRefreshRate */),
3582         CMP(TEXTURESTAGE, dwTextureStage),
3583         CMP(WIDTH, dwWidth),
3584         /* ZBUFFERBITDEPTH: "obsolete" */
3585     };
3586
3587 #undef CMP
3588
3589     unsigned int i;
3590
3591     if ((requested->dwFlags & provided->dwFlags) != requested->dwFlags)
3592         return FALSE;
3593
3594     for (i=0; i < sizeof(compare)/sizeof(compare[0]); i++)
3595     {
3596         if (requested->dwFlags & compare[i].flag
3597             && memcmp((const char *)provided + compare[i].offset,
3598                       (const char *)requested + compare[i].offset,
3599                       compare[i].size) != 0)
3600             return FALSE;
3601     }
3602
3603     if (requested->dwFlags & DDSD_PIXELFORMAT)
3604     {
3605         if (!Main_DirectDraw_DDPIXELFORMAT_Match(&requested->u4.ddpfPixelFormat,
3606                                                 &provided->u4.ddpfPixelFormat))
3607             return FALSE;
3608     }
3609
3610     return TRUE;
3611 }
3612
3613 #undef DDENUMSURFACES_SEARCHTYPE
3614 #undef DDENUMSURFACES_MATCHTYPE
3615
3616 struct surfacescallback_context
3617 {
3618     LPDDENUMSURFACESCALLBACK func;
3619     void *context;
3620 };
3621
3622 static HRESULT CALLBACK EnumSurfacesCallbackThunk(IDirectDrawSurface7 *surface,
3623         DDSURFACEDESC2 *surface_desc, void *context)
3624 {
3625     struct surfacescallback_context *cbcontext = context;
3626
3627     return cbcontext->func((IDirectDrawSurface *)&((IDirectDrawSurfaceImpl *)surface)->IDirectDrawSurface3_vtbl,
3628             (DDSURFACEDESC *)surface_desc, cbcontext->context);
3629 }
3630
3631 /*****************************************************************************
3632  * IDirectDraw7::EnumSurfaces
3633  *
3634  * Loops through all surfaces attached to this device and calls the
3635  * application callback. This can't be relayed to WineD3DDevice,
3636  * because some WineD3DSurfaces' parents are IParent objects
3637  *
3638  * Params:
3639  *  Flags: Some filtering flags. See IDirectDrawImpl_EnumSurfacesCallback
3640  *  DDSD: Description to filter for
3641  *  Context: Application-provided pointer, it's passed unmodified to the
3642  *           Callback function
3643  *  Callback: Address to call for each surface
3644  *
3645  * Returns:
3646  *  DDERR_INVALIDPARAMS if the callback is NULL
3647  *  DD_OK on success
3648  *
3649  *****************************************************************************/
3650 static HRESULT WINAPI ddraw7_EnumSurfaces(IDirectDraw7 *iface, DWORD Flags,
3651         DDSURFACEDESC2 *DDSD, void *Context, LPDDENUMSURFACESCALLBACK7 Callback)
3652 {
3653     /* The surface enumeration is handled by WineDDraw,
3654      * because it keeps track of all surfaces attached to
3655      * it. The filtering is done by our callback function,
3656      * because WineDDraw doesn't handle ddraw-like surface
3657      * caps structures
3658      */
3659     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
3660     IDirectDrawSurfaceImpl *surf;
3661     BOOL all, nomatch;
3662     DDSURFACEDESC2 desc;
3663     struct list *entry, *entry2;
3664
3665     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3666             iface, Flags, DDSD, Context, Callback);
3667
3668     all = Flags & DDENUMSURFACES_ALL;
3669     nomatch = Flags & DDENUMSURFACES_NOMATCH;
3670
3671     EnterCriticalSection(&ddraw_cs);
3672
3673     if(!Callback)
3674     {
3675         LeaveCriticalSection(&ddraw_cs);
3676         return DDERR_INVALIDPARAMS;
3677     }
3678
3679     /* Use the _SAFE enumeration, the app may destroy enumerated surfaces */
3680     LIST_FOR_EACH_SAFE(entry, entry2, &This->surface_list)
3681     {
3682         surf = LIST_ENTRY(entry, IDirectDrawSurfaceImpl, surface_list_entry);
3683         if (all || (nomatch != ddraw_match_surface_desc(DDSD, &surf->surface_desc)))
3684         {
3685             desc = surf->surface_desc;
3686             IDirectDrawSurface7_AddRef((IDirectDrawSurface7 *)surf);
3687             if (Callback((IDirectDrawSurface7 *)surf, &desc, Context) != DDENUMRET_OK)
3688             {
3689                 LeaveCriticalSection(&ddraw_cs);
3690                 return DD_OK;
3691             }
3692         }
3693     }
3694     LeaveCriticalSection(&ddraw_cs);
3695     return DD_OK;
3696 }
3697
3698 static HRESULT WINAPI ddraw4_EnumSurfaces(IDirectDraw4 *iface, DWORD flags,
3699         DDSURFACEDESC2 *surface_desc, void *context, LPDDENUMSURFACESCALLBACK2 callback)
3700 {
3701     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3702             iface, flags, surface_desc, context, callback);
3703
3704     return ddraw7_EnumSurfaces((IDirectDraw7 *)ddraw_from_ddraw4(iface),
3705             flags, surface_desc, context, (LPDDENUMSURFACESCALLBACK7)callback);
3706 }
3707
3708 static HRESULT WINAPI ddraw3_EnumSurfaces(IDirectDraw3 *iface, DWORD flags,
3709         DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3710 {
3711     struct surfacescallback_context cbcontext;
3712
3713     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3714             iface, flags, surface_desc, context, callback);
3715
3716     cbcontext.func = callback;
3717     cbcontext.context = context;
3718
3719     return ddraw7_EnumSurfaces((IDirectDraw7 *)ddraw_from_ddraw3(iface), flags,
3720             (DDSURFACEDESC2 *)surface_desc, &cbcontext, EnumSurfacesCallbackThunk);
3721 }
3722
3723 static HRESULT WINAPI ddraw2_EnumSurfaces(IDirectDraw2 *iface, DWORD flags,
3724         DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3725 {
3726     struct surfacescallback_context cbcontext;
3727
3728     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3729             iface, flags, surface_desc, context, callback);
3730
3731     cbcontext.func = callback;
3732     cbcontext.context = context;
3733
3734     return ddraw7_EnumSurfaces((IDirectDraw7 *)ddraw_from_ddraw2(iface), flags,
3735             (DDSURFACEDESC2 *)surface_desc, &cbcontext, EnumSurfacesCallbackThunk);
3736 }
3737
3738 static HRESULT WINAPI ddraw1_EnumSurfaces(IDirectDraw *iface, DWORD flags,
3739         DDSURFACEDESC *surface_desc, void *context, LPDDENUMSURFACESCALLBACK callback)
3740 {
3741     struct surfacescallback_context cbcontext;
3742
3743     TRACE("iface %p, flags %#x, surface_desc %p, context %p, callback %p.\n",
3744             iface, flags, surface_desc, context, callback);
3745
3746     cbcontext.func = callback;
3747     cbcontext.context = context;
3748
3749     return ddraw7_EnumSurfaces((IDirectDraw7 *)ddraw_from_ddraw1(iface), flags,
3750             (DDSURFACEDESC2 *)surface_desc, &cbcontext, EnumSurfacesCallbackThunk);
3751 }
3752
3753 /*****************************************************************************
3754  * DirectDrawCreateClipper (DDRAW.@)
3755  *
3756  * Creates a new IDirectDrawClipper object.
3757  *
3758  * Params:
3759  *  Clipper: Address to write the interface pointer to
3760  *  UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3761  *            NULL
3762  *
3763  * Returns:
3764  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
3765  *  E_OUTOFMEMORY if allocating the object failed
3766  *
3767  *****************************************************************************/
3768 HRESULT WINAPI
3769 DirectDrawCreateClipper(DWORD Flags,
3770                         LPDIRECTDRAWCLIPPER *Clipper,
3771                         IUnknown *UnkOuter)
3772 {
3773     IDirectDrawClipperImpl* object;
3774     HRESULT hr;
3775
3776     TRACE("flags %#x, clipper %p, outer_unknown %p.\n",
3777             Flags, Clipper, UnkOuter);
3778
3779     EnterCriticalSection(&ddraw_cs);
3780     if (UnkOuter != NULL)
3781     {
3782         LeaveCriticalSection(&ddraw_cs);
3783         return CLASS_E_NOAGGREGATION;
3784     }
3785
3786     if (!LoadWineD3D())
3787     {
3788         LeaveCriticalSection(&ddraw_cs);
3789         return DDERR_NODIRECTDRAWSUPPORT;
3790     }
3791
3792     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3793                      sizeof(IDirectDrawClipperImpl));
3794     if (object == NULL)
3795     {
3796         LeaveCriticalSection(&ddraw_cs);
3797         return E_OUTOFMEMORY;
3798     }
3799
3800     hr = ddraw_clipper_init(object);
3801     if (FAILED(hr))
3802     {
3803         WARN("Failed to initialize clipper, hr %#x.\n", hr);
3804         HeapFree(GetProcessHeap(), 0, object);
3805         LeaveCriticalSection(&ddraw_cs);
3806         return hr;
3807     }
3808
3809     TRACE("Created clipper %p.\n", object);
3810     *Clipper = (IDirectDrawClipper *) object;
3811     LeaveCriticalSection(&ddraw_cs);
3812     return DD_OK;
3813 }
3814
3815 /*****************************************************************************
3816  * IDirectDraw7::CreateClipper
3817  *
3818  * Creates a DDraw clipper. See DirectDrawCreateClipper for details
3819  *
3820  *****************************************************************************/
3821 static HRESULT WINAPI ddraw7_CreateClipper(IDirectDraw7 *iface, DWORD Flags,
3822         IDirectDrawClipper **Clipper, IUnknown *UnkOuter)
3823 {
3824     TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3825             iface, Flags, Clipper, UnkOuter);
3826
3827     return DirectDrawCreateClipper(Flags, Clipper, UnkOuter);
3828 }
3829
3830 static HRESULT WINAPI ddraw4_CreateClipper(IDirectDraw4 *iface,
3831         DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3832 {
3833     TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3834             iface, flags, clipper, outer_unknown);
3835
3836     return ddraw7_CreateClipper((IDirectDraw7 *)ddraw_from_ddraw4(iface), flags, clipper, outer_unknown);
3837 }
3838
3839 static HRESULT WINAPI ddraw3_CreateClipper(IDirectDraw3 *iface,
3840         DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3841 {
3842     TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3843             iface, flags, clipper, outer_unknown);
3844
3845     return ddraw7_CreateClipper((IDirectDraw7 *)ddraw_from_ddraw3(iface), flags, clipper, outer_unknown);
3846 }
3847
3848 static HRESULT WINAPI ddraw2_CreateClipper(IDirectDraw2 *iface,
3849         DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3850 {
3851     TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3852             iface, flags, clipper, outer_unknown);
3853
3854     return ddraw7_CreateClipper((IDirectDraw7 *)ddraw_from_ddraw2(iface), flags, clipper, outer_unknown);
3855 }
3856
3857 static HRESULT WINAPI ddraw1_CreateClipper(IDirectDraw *iface,
3858         DWORD flags, IDirectDrawClipper **clipper, IUnknown *outer_unknown)
3859 {
3860     TRACE("iface %p, flags %#x, clipper %p, outer_unknown %p.\n",
3861             iface, flags, clipper, outer_unknown);
3862
3863     return ddraw7_CreateClipper((IDirectDraw7 *)ddraw_from_ddraw1(iface), flags, clipper, outer_unknown);
3864 }
3865
3866 /*****************************************************************************
3867  * IDirectDraw7::CreatePalette
3868  *
3869  * Creates a new IDirectDrawPalette object
3870  *
3871  * Params:
3872  *  Flags: The flags for the new clipper
3873  *  ColorTable: Color table to assign to the new clipper
3874  *  Palette: Address to write the interface pointer to
3875  *  UnkOuter: For aggregation support, which ddraw doesn't have. Has to be
3876  *            NULL
3877  *
3878  * Returns:
3879  *  CLASS_E_NOAGGREGATION if UnkOuter != NULL
3880  *  E_OUTOFMEMORY if allocating the object failed
3881  *
3882  *****************************************************************************/
3883 static HRESULT WINAPI ddraw7_CreatePalette(IDirectDraw7 *iface, DWORD Flags,
3884         PALETTEENTRY *ColorTable, IDirectDrawPalette **Palette, IUnknown *pUnkOuter)
3885 {
3886     IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
3887     IDirectDrawPaletteImpl *object;
3888     HRESULT hr;
3889
3890     TRACE("iface %p, flags %#x, color_table %p, palette %p, outer_unknown %p.\n",
3891             iface, Flags, ColorTable, Palette, pUnkOuter);
3892
3893     EnterCriticalSection(&ddraw_cs);
3894     if(pUnkOuter != NULL)
3895     {
3896         WARN("pUnkOuter is %p, returning CLASS_E_NOAGGREGATION\n", pUnkOuter);
3897         LeaveCriticalSection(&ddraw_cs);
3898         return CLASS_E_NOAGGREGATION;
3899     }
3900
3901     /* The refcount test shows that a cooplevel is required for this */
3902     if(!This->cooperative_level)
3903     {
3904         WARN("No cooperative level set, returning DDERR_NOCOOPERATIVELEVELSET\n");
3905         LeaveCriticalSection(&ddraw_cs);
3906         return DDERR_NOCOOPERATIVELEVELSET;
3907     }
3908
3909     object = HeapAlloc(GetProcessHeap(), 0, sizeof(IDirectDrawPaletteImpl));
3910     if(!object)
3911     {
3912         ERR("Out of memory when allocating memory for a palette implementation\n");
3913         LeaveCriticalSection(&ddraw_cs);
3914         return E_OUTOFMEMORY;
3915     }
3916
3917     hr = ddraw_palette_init(object, This, Flags, ColorTable);
3918     if (FAILED(hr))
3919     {
3920         WARN("Failed to initialize palette, hr %#x.\n", hr);
3921         HeapFree(GetProcessHeap(), 0, object);
3922         LeaveCriticalSection(&ddraw_cs);
3923         return hr;
3924     }
3925
3926     TRACE("Created palette %p.\n", object);
3927     *Palette = (IDirectDrawPalette *)object;
3928     LeaveCriticalSection(&ddraw_cs);
3929     return DD_OK;
3930 }
3931
3932 static HRESULT WINAPI ddraw4_CreatePalette(IDirectDraw4 *iface, DWORD flags,
3933         PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3934 {
3935     IDirectDrawImpl *ddraw = ddraw_from_ddraw4(iface);
3936     HRESULT hr;
3937
3938     TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3939             iface, flags, entries, palette, outer_unknown);
3940
3941     hr = ddraw7_CreatePalette((IDirectDraw7 *)ddraw, flags, entries, palette, outer_unknown);
3942     if (SUCCEEDED(hr) && *palette)
3943     {
3944         IDirectDrawPaletteImpl *impl = (IDirectDrawPaletteImpl *)*palette;
3945         IDirectDraw7_Release((IDirectDraw7 *)ddraw);
3946         IDirectDraw4_AddRef(iface);
3947         impl->ifaceToRelease = (IUnknown *)iface;
3948     }
3949     return hr;
3950 }
3951
3952 static HRESULT WINAPI ddraw3_CreatePalette(IDirectDraw3 *iface, DWORD flags,
3953         PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3954 {
3955     IDirectDrawImpl *ddraw = ddraw_from_ddraw3(iface);
3956     HRESULT hr;
3957
3958     TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3959             iface, flags, entries, palette, outer_unknown);
3960
3961     hr = ddraw7_CreatePalette((IDirectDraw7 *)ddraw, flags, entries, palette, outer_unknown);
3962     if (SUCCEEDED(hr) && *palette)
3963     {
3964         IDirectDrawPaletteImpl *impl = (IDirectDrawPaletteImpl *)*palette;
3965         IDirectDraw7_Release((IDirectDraw7 *)ddraw);
3966         IDirectDraw4_AddRef(iface);
3967         impl->ifaceToRelease = (IUnknown *)iface;
3968     }
3969
3970     return hr;
3971 }
3972
3973 static HRESULT WINAPI ddraw2_CreatePalette(IDirectDraw2 *iface, DWORD flags,
3974         PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3975 {
3976     IDirectDrawImpl *ddraw = ddraw_from_ddraw2(iface);
3977     HRESULT hr;
3978
3979     TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
3980             iface, flags, entries, palette, outer_unknown);
3981
3982     hr = ddraw7_CreatePalette((IDirectDraw7 *)ddraw, flags, entries, palette, outer_unknown);
3983     if (SUCCEEDED(hr) && *palette)
3984     {
3985         IDirectDrawPaletteImpl *impl = (IDirectDrawPaletteImpl *)*palette;
3986         IDirectDraw7_Release((IDirectDraw7 *)ddraw);
3987         impl->ifaceToRelease = NULL;
3988     }
3989
3990     return hr;
3991 }
3992
3993 static HRESULT WINAPI ddraw1_CreatePalette(IDirectDraw *iface, DWORD flags,
3994         PALETTEENTRY *entries, IDirectDrawPalette **palette, IUnknown *outer_unknown)
3995 {
3996     IDirectDrawImpl *ddraw = ddraw_from_ddraw1(iface);
3997     HRESULT hr;
3998
3999     TRACE("iface %p, flags %#x, entries %p, palette %p, outer_unknown %p.\n",
4000             iface, flags, entries, palette, outer_unknown);
4001
4002     hr = ddraw7_CreatePalette((IDirectDraw7 *)ddraw, flags, entries, palette, outer_unknown);
4003     if (SUCCEEDED(hr) && *palette)
4004     {
4005         IDirectDrawPaletteImpl *impl = (IDirectDrawPaletteImpl *)*palette;
4006         IDirectDraw7_Release((IDirectDraw7 *)ddraw);
4007         impl->ifaceToRelease = NULL;
4008     }
4009
4010     return hr;
4011 }
4012
4013 /*****************************************************************************
4014  * IDirectDraw7::DuplicateSurface
4015  *
4016  * Duplicates a surface. The surface memory points to the same memory as
4017  * the original surface, and it's released when the last surface referencing
4018  * it is released. I guess that's beyond Wine's surface management right now
4019  * (Idea: create a new DDraw surface with the same WineD3DSurface. I need a
4020  * test application to implement this)
4021  *
4022  * Params:
4023  *  Src: Address of the source surface
4024  *  Dest: Address to write the new surface pointer to
4025  *
4026  * Returns:
4027  *  See IDirectDraw7::CreateSurface
4028  *
4029  *****************************************************************************/
4030 static HRESULT WINAPI ddraw7_DuplicateSurface(IDirectDraw7 *iface,
4031         IDirectDrawSurface7 *Src, IDirectDrawSurface7 **Dest)
4032 {
4033     IDirectDrawSurfaceImpl *Surf = (IDirectDrawSurfaceImpl *)Src;
4034
4035     FIXME("iface %p, src %p, dst %p partial stub!\n", iface, Src, Dest);
4036
4037     /* For now, simply create a new, independent surface */
4038     return IDirectDraw7_CreateSurface(iface,
4039                                       &Surf->surface_desc,
4040                                       Dest,
4041                                       NULL);
4042 }
4043
4044 static HRESULT WINAPI ddraw4_DuplicateSurface(IDirectDraw4 *iface,
4045         IDirectDrawSurface4 *src, IDirectDrawSurface4 **dst)
4046 {
4047     TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
4048
4049     return ddraw7_DuplicateSurface((IDirectDraw7 *)ddraw_from_ddraw4(iface),
4050             (IDirectDrawSurface7 *)src, (IDirectDrawSurface7 **)dst);
4051 }
4052
4053 static HRESULT WINAPI ddraw3_DuplicateSurface(IDirectDraw3 *iface,
4054         IDirectDrawSurface *src, IDirectDrawSurface **dst)
4055 {
4056     IDirectDrawSurface7 *src7, *dst7;
4057     HRESULT hr;
4058
4059     TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
4060     src7 = (IDirectDrawSurface7 *)surface_from_surface3((IDirectDrawSurface3 *)src);
4061     hr = ddraw7_DuplicateSurface((IDirectDraw7 *)ddraw_from_ddraw3(iface), src7, &dst7);
4062     if (FAILED(hr))
4063         return hr;
4064     *dst = (IDirectDrawSurface *)&((IDirectDrawSurfaceImpl *)dst7)->IDirectDrawSurface3_vtbl;
4065     return hr;
4066 }
4067
4068 static HRESULT WINAPI ddraw2_DuplicateSurface(IDirectDraw2 *iface,
4069         IDirectDrawSurface *src, IDirectDrawSurface **dst)
4070 {
4071     IDirectDrawSurface7 *src7, *dst7;
4072     HRESULT hr;
4073
4074     TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
4075     src7 = (IDirectDrawSurface7 *)surface_from_surface3((IDirectDrawSurface3 *)src);
4076     hr = ddraw7_DuplicateSurface((IDirectDraw7 *)ddraw_from_ddraw2(iface), src7, &dst7);
4077     if (FAILED(hr))
4078         return hr;
4079     *dst = (IDirectDrawSurface *)&((IDirectDrawSurfaceImpl *)dst7)->IDirectDrawSurface3_vtbl;
4080     return hr;
4081 }
4082
4083 static HRESULT WINAPI ddraw1_DuplicateSurface(IDirectDraw *iface,
4084         IDirectDrawSurface *src, IDirectDrawSurface **dst)
4085 {
4086     IDirectDrawSurface7 *src7, *dst7;
4087     HRESULT hr;
4088
4089     TRACE("iface %p, src %p, dst %p.\n", iface, src, dst);
4090     src7 = (IDirectDrawSurface7 *)surface_from_surface3((IDirectDrawSurface3 *)src);
4091     hr = ddraw7_DuplicateSurface((IDirectDraw7 *)ddraw_from_ddraw1(iface), src7, &dst7);
4092     if (FAILED(hr))
4093         return hr;
4094     *dst = (IDirectDrawSurface *)&((IDirectDrawSurfaceImpl *)dst7)->IDirectDrawSurface3_vtbl;
4095     return hr;
4096 }
4097
4098 /*****************************************************************************
4099  * IDirect3D7::EnumDevices
4100  *
4101  * The EnumDevices method for IDirect3D7. It enumerates all supported
4102  * D3D7 devices. Currently the T&L, HAL and RGB devices are enumerated.
4103  *
4104  * Params:
4105  *  callback: Function to call for each enumerated device
4106  *  context: Pointer to pass back to the app
4107  *
4108  * Returns:
4109  *  D3D_OK, or the return value of the GetCaps call
4110  *
4111  *****************************************************************************/
4112 static HRESULT WINAPI d3d7_EnumDevices(IDirect3D7 *iface, LPD3DENUMDEVICESCALLBACK7 callback, void *context)
4113 {
4114     char interface_name_tnl[] = "WINE Direct3D7 Hardware Transform and Lighting acceleration using WineD3D";
4115     char device_name_tnl[] = "Wine D3D7 T&L HAL";
4116     char interface_name_hal[] = "WINE Direct3D7 Hardware acceleration using WineD3D";
4117     char device_name_hal[] = "Wine D3D7 HAL";
4118     char interface_name_rgb[] = "WINE Direct3D7 RGB Software Emulation using WineD3D";
4119     char device_name_rgb[] = "Wine D3D7 RGB";
4120
4121     IDirectDrawImpl *ddraw = ddraw_from_d3d7(iface);
4122     D3DDEVICEDESC7 device_desc7;
4123     D3DDEVICEDESC device_desc1;
4124     HRESULT hr;
4125
4126     TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
4127
4128     EnterCriticalSection(&ddraw_cs);
4129
4130     hr = IDirect3DImpl_GetCaps(ddraw->wineD3D, &device_desc1, &device_desc7);
4131     if (hr != D3D_OK)
4132     {
4133         LeaveCriticalSection(&ddraw_cs);
4134         return hr;
4135     }
4136     callback(interface_name_tnl, device_name_tnl, &device_desc7, context);
4137
4138     device_desc7.deviceGUID = IID_IDirect3DHALDevice;
4139     callback(interface_name_hal, device_name_hal, &device_desc7, context);
4140
4141     device_desc7.deviceGUID = IID_IDirect3DRGBDevice;
4142     callback(interface_name_rgb, device_name_rgb, &device_desc7, context);
4143
4144     TRACE("End of enumeration.\n");
4145
4146     LeaveCriticalSection(&ddraw_cs);
4147
4148     return D3D_OK;
4149 }
4150
4151 /*****************************************************************************
4152  * IDirect3D3::EnumDevices
4153  *
4154  * Enumerates all supported Direct3DDevice interfaces. This is the
4155  * implementation for Direct3D 1 to Direc3D 3, Version 7 has its own.
4156  *
4157  * Version 1, 2 and 3
4158  *
4159  * Params:
4160  *  callback: Application-provided routine to call for each enumerated device
4161  *  Context: Pointer to pass to the callback
4162  *
4163  * Returns:
4164  *  D3D_OK on success,
4165  *  The result of IDirect3DImpl_GetCaps if it failed
4166  *
4167  *****************************************************************************/
4168 static HRESULT WINAPI d3d3_EnumDevices(IDirect3D3 *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
4169 {
4170     static CHAR wined3d_description[] = "Wine D3DDevice using WineD3D and OpenGL";
4171
4172     IDirectDrawImpl *ddraw = ddraw_from_d3d3(iface);
4173     D3DDEVICEDESC device_desc1, hal_desc, hel_desc;
4174     D3DDEVICEDESC7 device_desc7;
4175     HRESULT hr;
4176
4177     /* Some games (Motoracer 2 demo) have the bad idea to modify the device
4178      * name string. Let's put the string in a sufficiently sized array in
4179      * writable memory. */
4180     char device_name[50];
4181     strcpy(device_name,"Direct3D HEL");
4182
4183     TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
4184
4185     EnterCriticalSection(&ddraw_cs);
4186
4187     hr = IDirect3DImpl_GetCaps(ddraw->wineD3D, &device_desc1, &device_desc7);
4188     if (hr != D3D_OK)
4189     {
4190         LeaveCriticalSection(&ddraw_cs);
4191         return hr;
4192     }
4193
4194     /* Do I have to enumerate the reference id? Note from old d3d7:
4195      * "It seems that enumerating the reference IID on Direct3D 1 games
4196      * (AvP / Motoracer2) breaks them". So do not enumerate this iid in V1
4197      *
4198      * There's a registry key HKLM\Software\Microsoft\Direct3D\Drivers,
4199      * EnumReference which enables / disables enumerating the reference
4200      * rasterizer. It's a DWORD, 0 means disabled, 2 means enabled. The
4201      * enablerefrast.reg and disablerefrast.reg files in the DirectX 7.0 sdk
4202      * demo directory suggest this.
4203      *
4204      * Some games(GTA 2) seem to use the second enumerated device, so I have
4205      * to enumerate at least 2 devices. So enumerate the reference device to
4206      * have 2 devices.
4207      *
4208      * Other games (Rollcage) tell emulation and hal device apart by certain
4209      * flags. Rollcage expects D3DPTEXTURECAPS_POW2 to be set (yeah, it is a
4210      * limitation flag), and it refuses all devices that have the perspective
4211      * flag set. This way it refuses the emulation device, and HAL devices
4212      * never have POW2 unset in d3d7 on windows. */
4213     if (ddraw->d3dversion != 1)
4214     {
4215         static CHAR reference_description[] = "RGB Direct3D emulation";
4216
4217         TRACE("Enumerating WineD3D D3DDevice interface.\n");
4218         hal_desc = device_desc1;
4219         hel_desc = device_desc1;
4220         /* The rgb device has the pow2 flag set in the hel caps, but not in the hal caps. */
4221         hal_desc.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
4222                 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
4223         hal_desc.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
4224                 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
4225         hr = callback((GUID *)&IID_IDirect3DRGBDevice, reference_description,
4226                 device_name, &hal_desc, &hel_desc, context);
4227         if (hr != D3DENUMRET_OK)
4228         {
4229             TRACE("Application cancelled the enumeration.\n");
4230             LeaveCriticalSection(&ddraw_cs);
4231             return D3D_OK;
4232         }
4233     }
4234
4235     strcpy(device_name,"Direct3D HAL");
4236
4237     TRACE("Enumerating HAL Direct3D device.\n");
4238     hal_desc = device_desc1;
4239     hel_desc = device_desc1;
4240     /* The hal device does not have the pow2 flag set in hel, but in hal. */
4241     hel_desc.dpcLineCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
4242             | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
4243     hel_desc.dpcTriCaps.dwTextureCaps &= ~(D3DPTEXTURECAPS_POW2
4244             | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PERSPECTIVE);
4245     hr = callback((GUID *)&IID_IDirect3DHALDevice, wined3d_description,
4246             device_name, &hal_desc, &hel_desc, context);
4247     if (hr != D3DENUMRET_OK)
4248     {
4249         TRACE("Application cancelled the enumeration.\n");
4250         LeaveCriticalSection(&ddraw_cs);
4251         return D3D_OK;
4252     }
4253
4254     TRACE("End of enumeration.\n");
4255
4256     LeaveCriticalSection(&ddraw_cs);
4257     return D3D_OK;
4258 }
4259
4260 static HRESULT WINAPI d3d2_EnumDevices(IDirect3D2 *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
4261 {
4262     TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
4263
4264     return d3d3_EnumDevices((IDirect3D3 *)&ddraw_from_d3d2(iface)->IDirect3D3_vtbl, callback, context);
4265 }
4266
4267 static HRESULT WINAPI d3d1_EnumDevices(IDirect3D *iface, LPD3DENUMDEVICESCALLBACK callback, void *context)
4268 {
4269     TRACE("iface %p, callback %p, context %p.\n", iface, callback, context);
4270
4271     return d3d3_EnumDevices((IDirect3D3 *)&ddraw_from_d3d1(iface)->IDirect3D3_vtbl, callback, context);
4272 }
4273
4274 /*****************************************************************************
4275  * IDirect3D3::CreateLight
4276  *
4277  * Creates an IDirect3DLight interface. This interface is used in
4278  * Direct3D3 or earlier for lighting. In Direct3D7 it has been replaced
4279  * by the DIRECT3DLIGHT7 structure. Wine's Direct3DLight implementation
4280  * uses the IDirect3DDevice7 interface with D3D7 lights.
4281  *
4282  * Version 1, 2 and 3
4283  *
4284  * Params:
4285  *  light: Address to store the new interface pointer
4286  *  outer_unknown: Basically for aggregation, but ddraw doesn't support it.
4287  *                 Must be NULL
4288  *
4289  * Returns:
4290  *  D3D_OK on success
4291  *  DDERR_OUTOFMEMORY if memory allocation failed
4292  *  CLASS_E_NOAGGREGATION if outer_unknown != NULL
4293  *
4294  *****************************************************************************/
4295 static HRESULT WINAPI d3d3_CreateLight(IDirect3D3 *iface, IDirect3DLight **light, IUnknown *outer_unknown)
4296 {
4297     IDirect3DLightImpl *object;
4298
4299     TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
4300
4301     if (outer_unknown) return CLASS_E_NOAGGREGATION;
4302
4303     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4304     if (!object)
4305     {
4306         ERR("Failed to allocate light memory.\n");
4307         return DDERR_OUTOFMEMORY;
4308     }
4309
4310     d3d_light_init(object, ddraw_from_d3d3(iface));
4311
4312     TRACE("Created light %p.\n", object);
4313     *light = (IDirect3DLight *)object;
4314
4315     return D3D_OK;
4316 }
4317
4318 static HRESULT WINAPI d3d2_CreateLight(IDirect3D2 *iface, IDirect3DLight **light, IUnknown *outer_unknown)
4319 {
4320     TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
4321
4322     return d3d3_CreateLight((IDirect3D3 *)&ddraw_from_d3d2(iface)->IDirect3D3_vtbl, light, outer_unknown);
4323 }
4324
4325 static HRESULT WINAPI d3d1_CreateLight(IDirect3D *iface, IDirect3DLight **light, IUnknown *outer_unknown)
4326 {
4327     TRACE("iface %p, light %p, outer_unknown %p.\n", iface, light, outer_unknown);
4328
4329     return d3d3_CreateLight((IDirect3D3 *)&ddraw_from_d3d1(iface)->IDirect3D3_vtbl, light, outer_unknown);
4330 }
4331
4332 /*****************************************************************************
4333  * IDirect3D3::CreateMaterial
4334  *
4335  * Creates an IDirect3DMaterial interface. This interface is used by Direct3D3
4336  * and older versions. The IDirect3DMaterial implementation wraps its
4337  * functionality to IDirect3DDevice7::SetMaterial and friends.
4338  *
4339  * Version 1, 2 and 3
4340  *
4341  * Params:
4342  *  material: Address to store the new interface's pointer to
4343  *  outer_unknown: Basically for aggregation, but ddraw doesn't support it.
4344  *                 Must be NULL
4345  *
4346  * Returns:
4347  *  D3D_OK on success
4348  *  DDERR_OUTOFMEMORY if memory allocation failed
4349  *  CLASS_E_NOAGGREGATION if outer_unknown != NULL
4350  *
4351  *****************************************************************************/
4352 static HRESULT WINAPI d3d3_CreateMaterial(IDirect3D3 *iface, IDirect3DMaterial3 **material, IUnknown *outer_unknown)
4353 {
4354     IDirect3DMaterialImpl *object;
4355
4356     TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
4357
4358     if (outer_unknown) return CLASS_E_NOAGGREGATION;
4359
4360     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4361     if (!object)
4362     {
4363         ERR("Failed to allocate material memory.\n");
4364         return DDERR_OUTOFMEMORY;
4365     }
4366
4367     d3d_material_init(object, ddraw_from_d3d3(iface));
4368
4369     TRACE("Created material %p.\n", object);
4370     *material = (IDirect3DMaterial3 *)object;
4371
4372     return D3D_OK;
4373 }
4374
4375 static HRESULT WINAPI d3d2_CreateMaterial(IDirect3D2 *iface, IDirect3DMaterial2 **material, IUnknown *outer_unknown)
4376 {
4377     IDirect3DMaterial3 *material3;
4378     HRESULT hr;
4379
4380     TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
4381
4382     hr = d3d3_CreateMaterial((IDirect3D3 *)&ddraw_from_d3d2(iface)->IDirect3D3_vtbl, &material3, outer_unknown);
4383     *material = material3 ? (IDirect3DMaterial2 *)&((IDirect3DMaterialImpl *)material3)->IDirect3DMaterial2_vtbl : NULL;
4384
4385     TRACE("Returning material %p.\n", *material);
4386
4387     return hr;
4388 }
4389
4390 static HRESULT WINAPI d3d1_CreateMaterial(IDirect3D *iface, IDirect3DMaterial **material, IUnknown *outer_unknown)
4391 {
4392     IDirect3DMaterial3 *material3;
4393     HRESULT hr;
4394
4395     TRACE("iface %p, material %p, outer_unknown %p.\n", iface, material, outer_unknown);
4396
4397     hr = d3d3_CreateMaterial((IDirect3D3 *)&ddraw_from_d3d1(iface)->IDirect3D3_vtbl, &material3, outer_unknown);
4398     *material = material3 ? (IDirect3DMaterial *)&((IDirect3DMaterialImpl *)material3)->IDirect3DMaterial_vtbl : NULL;
4399
4400     TRACE("Returning material %p.\n", *material);
4401
4402     return hr;
4403 }
4404
4405 /*****************************************************************************
4406  * IDirect3D3::CreateViewport
4407  *
4408  * Creates an IDirect3DViewport interface. This interface is used
4409  * by Direct3D and earlier versions for Viewport management. In Direct3D7
4410  * it has been replaced by a viewport structure and
4411  * IDirect3DDevice7::*Viewport. Wine's IDirect3DViewport implementation
4412  * uses the IDirect3DDevice7 methods for its functionality
4413  *
4414  * Params:
4415  *  Viewport: Address to store the new interface pointer
4416  *  outer_unknown: Basically for aggregation, but ddraw doesn't support it.
4417  *                 Must be NULL
4418  *
4419  * Returns:
4420  *  D3D_OK on success
4421  *  DDERR_OUTOFMEMORY if memory allocation failed
4422  *  CLASS_E_NOAGGREGATION if outer_unknown != NULL
4423  *
4424  *****************************************************************************/
4425 static HRESULT WINAPI d3d3_CreateViewport(IDirect3D3 *iface, IDirect3DViewport3 **viewport, IUnknown *outer_unknown)
4426 {
4427     IDirect3DViewportImpl *object;
4428
4429     TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4430
4431     if (outer_unknown) return CLASS_E_NOAGGREGATION;
4432
4433     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4434     if (!object)
4435     {
4436         ERR("Failed to allocate viewport memory.\n");
4437         return DDERR_OUTOFMEMORY;
4438     }
4439
4440     d3d_viewport_init(object, ddraw_from_d3d3(iface));
4441
4442     TRACE("Created viewport %p.\n", object);
4443     *viewport = (IDirect3DViewport3 *)object;
4444
4445     return D3D_OK;
4446 }
4447
4448 static HRESULT WINAPI d3d2_CreateViewport(IDirect3D2 *iface, IDirect3DViewport2 **viewport, IUnknown *outer_unknown)
4449 {
4450     TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4451
4452     return d3d3_CreateViewport((IDirect3D3 *)&ddraw_from_d3d2(iface)->IDirect3D3_vtbl,
4453             (IDirect3DViewport3 **)viewport, outer_unknown);
4454 }
4455
4456 static HRESULT WINAPI d3d1_CreateViewport(IDirect3D *iface, IDirect3DViewport **viewport, IUnknown *outer_unknown)
4457 {
4458     TRACE("iface %p, viewport %p, outer_unknown %p.\n", iface, viewport, outer_unknown);
4459
4460     return d3d3_CreateViewport((IDirect3D3 *)&ddraw_from_d3d1(iface)->IDirect3D3_vtbl,
4461             (IDirect3DViewport3 **)viewport, outer_unknown);
4462 }
4463
4464 /*****************************************************************************
4465  * IDirect3D3::FindDevice
4466  *
4467  * This method finds a device with the requested properties and returns a
4468  * device description
4469  *
4470  * Verion 1, 2 and 3
4471  * Params:
4472  *  fds: Describes the requested device characteristics
4473  *  fdr: Returns the device description
4474  *
4475  * Returns:
4476  *  D3D_OK on success
4477  *  DDERR_INVALIDPARAMS if no device was found
4478  *
4479  *****************************************************************************/
4480 static HRESULT WINAPI d3d3_FindDevice(IDirect3D3 *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4481 {
4482     IDirectDrawImpl *ddraw = ddraw_from_d3d3(iface);
4483     D3DDEVICEDESC7 desc7;
4484     D3DDEVICEDESC desc1;
4485     HRESULT hr;
4486
4487     TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4488
4489     if (!fds || !fdr) return DDERR_INVALIDPARAMS;
4490
4491     if (fds->dwSize != sizeof(D3DFINDDEVICESEARCH)
4492             || fdr->dwSize != sizeof(D3DFINDDEVICERESULT))
4493         return DDERR_INVALIDPARAMS;
4494
4495     if ((fds->dwFlags & D3DFDS_COLORMODEL)
4496             && fds->dcmColorModel != D3DCOLOR_RGB)
4497     {
4498         WARN("Trying to request a non-RGB D3D color model. Not supported.\n");
4499         return DDERR_INVALIDPARAMS; /* No real idea what to return here :-) */
4500     }
4501
4502     if (fds->dwFlags & D3DFDS_GUID)
4503     {
4504         TRACE("Trying to match guid %s.\n", debugstr_guid(&(fds->guid)));
4505         if (!IsEqualGUID(&IID_D3DDEVICE_WineD3D, &fds->guid)
4506                 && !IsEqualGUID(&IID_IDirect3DHALDevice, &fds->guid)
4507                 && !IsEqualGUID(&IID_IDirect3DRGBDevice, &fds->guid))
4508         {
4509             WARN("No match for this GUID.\n");
4510             return DDERR_NOTFOUND;
4511         }
4512     }
4513
4514     /* Get the caps */
4515     hr = IDirect3DImpl_GetCaps(ddraw->wineD3D, &desc1, &desc7);
4516     if (hr != D3D_OK) return hr;
4517
4518     /* Now return our own GUID */
4519     fdr->guid = IID_D3DDEVICE_WineD3D;
4520     fdr->ddHwDesc = desc1;
4521     fdr->ddSwDesc = desc1;
4522
4523     TRACE("Returning Wine's wined3d device with (undumped) capabilities.\n");
4524
4525     return D3D_OK;
4526 }
4527
4528 static HRESULT WINAPI d3d2_FindDevice(IDirect3D2 *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4529 {
4530     TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4531
4532     return d3d3_FindDevice((IDirect3D3 *)&ddraw_from_d3d2(iface)->IDirect3D3_vtbl, fds, fdr);
4533 }
4534
4535 static HRESULT WINAPI d3d1_FindDevice(IDirect3D *iface, D3DFINDDEVICESEARCH *fds, D3DFINDDEVICERESULT *fdr)
4536 {
4537     TRACE("iface %p, fds %p, fdr %p.\n", iface, fds, fdr);
4538
4539     return d3d3_FindDevice((IDirect3D3 *)&ddraw_from_d3d1(iface)->IDirect3D3_vtbl, fds, fdr);
4540 }
4541
4542 /*****************************************************************************
4543  * IDirect3D7::CreateDevice
4544  *
4545  * Creates an IDirect3DDevice7 interface.
4546  *
4547  * Version 2, 3 and 7. IDirect3DDevice 1 interfaces are interfaces to
4548  * DirectDraw surfaces and are created with
4549  * IDirectDrawSurface::QueryInterface. This method uses CreateDevice to
4550  * create the device object and QueryInterfaces for IDirect3DDevice
4551  *
4552  * Params:
4553  *  refiid: IID of the device to create
4554  *  Surface: Initial rendertarget
4555  *  Device: Address to return the interface pointer
4556  *
4557  * Returns:
4558  *  D3D_OK on success
4559  *  DDERR_OUTOFMEMORY if memory allocation failed
4560  *  DDERR_INVALIDPARAMS if a device exists already
4561  *
4562  *****************************************************************************/
4563 static HRESULT WINAPI d3d7_CreateDevice(IDirect3D7 *iface, REFCLSID riid,
4564         IDirectDrawSurface7 *surface, IDirect3DDevice7 **device)
4565 {
4566     IDirectDrawSurfaceImpl *target = (IDirectDrawSurfaceImpl *)surface;
4567     IDirectDrawImpl *ddraw = ddraw_from_d3d7(iface);
4568     IDirect3DDeviceImpl *object;
4569     HRESULT hr;
4570
4571     TRACE("iface %p, riid %s, surface %p, device %p.\n", iface, debugstr_guid(riid), surface, device);
4572
4573     EnterCriticalSection(&ddraw_cs);
4574     *device = NULL;
4575
4576     /* Fail device creation if non-opengl surfaces are used. */
4577     if (ddraw->ImplType != SURFACE_OPENGL)
4578     {
4579         ERR("The application wants to create a Direct3D device, but non-opengl surfaces are set in the registry.\n");
4580         ERR("Please set the surface implementation to opengl or autodetection to allow 3D rendering.\n");
4581
4582         /* We only hit this path if a default surface is set in the registry. Incorrect autodetection
4583          * is caught in CreateSurface or QueryInterface. */
4584         LeaveCriticalSection(&ddraw_cs);
4585         return DDERR_NO3D;
4586     }
4587
4588     if (ddraw->d3ddevice)
4589     {
4590         FIXME("Only one Direct3D device per DirectDraw object supported.\n");
4591         LeaveCriticalSection(&ddraw_cs);
4592         return DDERR_INVALIDPARAMS;
4593     }
4594
4595     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4596     if (!object)
4597     {
4598         ERR("Failed to allocate device memory.\n");
4599         LeaveCriticalSection(&ddraw_cs);
4600         return DDERR_OUTOFMEMORY;
4601     }
4602
4603     hr = d3d_device_init(object, ddraw, target);
4604     if (FAILED(hr))
4605     {
4606         WARN("Failed to initialize device, hr %#x.\n", hr);
4607         HeapFree(GetProcessHeap(), 0, object);
4608         LeaveCriticalSection(&ddraw_cs);
4609         return hr;
4610     }
4611
4612     TRACE("Created device %p.\n", object);
4613     *device = (IDirect3DDevice7 *)object;
4614
4615     LeaveCriticalSection(&ddraw_cs);
4616     return D3D_OK;
4617 }
4618
4619 static HRESULT WINAPI d3d3_CreateDevice(IDirect3D3 *iface, REFCLSID riid,
4620         IDirectDrawSurface4 *surface, IDirect3DDevice3 **device, IUnknown *outer_unknown)
4621 {
4622     HRESULT hr;
4623
4624     TRACE("iface %p, riid %s, surface %p, device %p, outer_unknown %p.\n",
4625             iface, debugstr_guid(riid), surface, device, outer_unknown);
4626
4627     if (outer_unknown) return CLASS_E_NOAGGREGATION;
4628
4629     hr = d3d7_CreateDevice((IDirect3D7 *)&ddraw_from_d3d3(iface)->IDirect3D7_vtbl, riid,
4630             (IDirectDrawSurface7 *)surface, (IDirect3DDevice7 **)device);
4631     if (*device) *device = (IDirect3DDevice3 *)&((IDirect3DDeviceImpl *)*device)->IDirect3DDevice3_vtbl;
4632
4633     return hr;
4634 }
4635
4636 static HRESULT WINAPI d3d2_CreateDevice(IDirect3D2 *iface, REFCLSID riid,
4637         IDirectDrawSurface *surface, IDirect3DDevice2 **device)
4638 {
4639     HRESULT hr;
4640
4641     TRACE("iface %p, riid %s, surface %p, device %p.\n",
4642             iface, debugstr_guid(riid), surface, device);
4643
4644     hr = d3d7_CreateDevice((IDirect3D7 *)&ddraw_from_d3d2(iface)->IDirect3D7_vtbl, riid,
4645             surface ? (IDirectDrawSurface7 *)surface_from_surface3((IDirectDrawSurface3 *)surface) : NULL,
4646             (IDirect3DDevice7 **)device);
4647     if (*device) *device = (IDirect3DDevice2 *)&((IDirect3DDeviceImpl *)*device)->IDirect3DDevice2_vtbl;
4648
4649     return hr;
4650 }
4651
4652 /*****************************************************************************
4653  * IDirect3D7::CreateVertexBuffer
4654  *
4655  * Creates a new vertex buffer object and returns a IDirect3DVertexBuffer7
4656  * interface.
4657  *
4658  * Version 3 and 7
4659  *
4660  * Params:
4661  *  desc: Requested Vertex buffer properties
4662  *  vertex_buffer: Address to return the interface pointer at
4663  *  flags: Some flags, should be 0
4664  *
4665  * Returns
4666  *  D3D_OK on success
4667  *  DDERR_OUTOFMEMORY if memory allocation failed
4668  *  The return value of IWineD3DDevice::CreateVertexBuffer if this call fails
4669  *  DDERR_INVALIDPARAMS if desc or vertex_buffer are NULL
4670  *
4671  *****************************************************************************/
4672 static HRESULT WINAPI d3d7_CreateVertexBuffer(IDirect3D7 *iface, D3DVERTEXBUFFERDESC *desc,
4673         IDirect3DVertexBuffer7 **vertex_buffer, DWORD flags)
4674 {
4675     IDirect3DVertexBufferImpl *object;
4676     HRESULT hr;
4677
4678     TRACE("iface %p, desc %p, vertex_buffer %p, flags %#x.\n",
4679             iface, desc, vertex_buffer, flags);
4680
4681     if (!vertex_buffer || !desc) return DDERR_INVALIDPARAMS;
4682
4683     TRACE("Vertex buffer description:\n");
4684     TRACE("    dwSize %u\n", desc->dwSize);
4685     TRACE("    dwCaps %#x\n", desc->dwCaps);
4686     TRACE("    FVF %#x\n", desc->dwFVF);
4687     TRACE("    dwNumVertices %u\n", desc->dwNumVertices);
4688
4689     /* Now create the vertex buffer */
4690     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
4691     if (!object)
4692     {
4693         ERR("Failed to allocate vertex buffer memory.\n");
4694         return DDERR_OUTOFMEMORY;
4695     }
4696
4697     hr = d3d_vertex_buffer_init(object, ddraw_from_d3d7(iface), desc);
4698     if (FAILED(hr))
4699     {
4700         WARN("Failed to initialize vertex buffer, hr %#x.\n", hr);
4701         HeapFree(GetProcessHeap(), 0, object);
4702         return hr;
4703     }
4704
4705     TRACE("Created vertex buffer %p.\n", object);
4706     *vertex_buffer = (IDirect3DVertexBuffer7 *)object;
4707
4708     return D3D_OK;
4709 }
4710
4711 static HRESULT WINAPI d3d3_CreateVertexBuffer(IDirect3D3 *iface, D3DVERTEXBUFFERDESC *desc,
4712         IDirect3DVertexBuffer **vertex_buffer, DWORD flags, IUnknown *outer_unknown)
4713 {
4714     IDirectDrawImpl *This = ddraw_from_d3d3(iface);
4715     HRESULT hr;
4716
4717     TRACE("iface %p, desc %p, vertex_buffer %p, flags %#x, outer_unknown %p.\n",
4718             iface, desc, vertex_buffer, flags, outer_unknown);
4719
4720     if (outer_unknown) return CLASS_E_NOAGGREGATION;
4721
4722     hr = d3d7_CreateVertexBuffer((IDirect3D7 *)&This->IDirect3D7_vtbl,
4723             desc, (IDirect3DVertexBuffer7 **)vertex_buffer, flags);
4724     if (*vertex_buffer)
4725         *vertex_buffer = (IDirect3DVertexBuffer *)&((IDirect3DVertexBufferImpl *)*vertex_buffer)->IDirect3DVertexBuffer_vtbl;
4726
4727     return hr;
4728 }
4729
4730 /*****************************************************************************
4731  * IDirect3D7::EnumZBufferFormats
4732  *
4733  * Enumerates all supported Z buffer pixel formats
4734  *
4735  * Version 3 and 7
4736  *
4737  * Params:
4738  *  device_iid:
4739  *  callback: callback to call for each pixel format
4740  *  context: Pointer to pass back to the callback
4741  *
4742  * Returns:
4743  *  D3D_OK on success
4744  *  DDERR_INVALIDPARAMS if callback is NULL
4745  *  For details, see IWineD3DDevice::EnumZBufferFormats
4746  *
4747  *****************************************************************************/
4748 static HRESULT WINAPI d3d7_EnumZBufferFormats(IDirect3D7 *iface, REFCLSID device_iid,
4749         LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
4750 {
4751     IDirectDrawImpl *ddraw = ddraw_from_d3d7(iface);
4752     WINED3DDISPLAYMODE d3ddm;
4753     WINED3DDEVTYPE type;
4754     unsigned int i;
4755     HRESULT hr;
4756
4757     /* Order matters. Specifically, BattleZone II (full version) expects the
4758      * 16-bit depth formats to be listed before the 24 and 32 ones. */
4759     static const enum wined3d_format_id formats[] =
4760     {
4761         WINED3DFMT_S1_UINT_D15_UNORM,
4762         WINED3DFMT_D16_UNORM,
4763         WINED3DFMT_X8D24_UNORM,
4764         WINED3DFMT_S4X4_UINT_D24_UNORM,
4765         WINED3DFMT_D24_UNORM_S8_UINT,
4766         WINED3DFMT_D32_UNORM,
4767     };
4768
4769     TRACE("iface %p, device_iid %s, callback %p, context %p.\n",
4770             iface, debugstr_guid(device_iid), callback, context);
4771
4772     if (!callback) return DDERR_INVALIDPARAMS;
4773
4774     if (IsEqualGUID(device_iid, &IID_IDirect3DHALDevice)
4775             || IsEqualGUID(device_iid, &IID_IDirect3DTnLHalDevice)
4776             || IsEqualGUID(device_iid, &IID_D3DDEVICE_WineD3D))
4777     {
4778         TRACE("Asked for HAL device.\n");
4779         type = WINED3DDEVTYPE_HAL;
4780     }
4781     else if (IsEqualGUID(device_iid, &IID_IDirect3DRGBDevice)
4782             || IsEqualGUID(device_iid, &IID_IDirect3DMMXDevice))
4783     {
4784         TRACE("Asked for SW device.\n");
4785         type = WINED3DDEVTYPE_SW;
4786     }
4787     else if (IsEqualGUID(device_iid, &IID_IDirect3DRefDevice))
4788     {
4789         TRACE("Asked for REF device.\n");
4790         type = WINED3DDEVTYPE_REF;
4791     }
4792     else if (IsEqualGUID(device_iid, &IID_IDirect3DNullDevice))
4793     {
4794         TRACE("Asked for NULLREF device.\n");
4795         type = WINED3DDEVTYPE_NULLREF;
4796     }
4797     else
4798     {
4799         FIXME("Unexpected device GUID %s.\n", debugstr_guid(device_iid));
4800         type = WINED3DDEVTYPE_HAL;
4801     }
4802
4803     EnterCriticalSection(&ddraw_cs);
4804     /* We need an adapter format from somewhere to please wined3d and WGL.
4805      * Use the current display mode. So far all cards offer the same depth
4806      * stencil format for all modes, but if some do not and applications do
4807      * not like that we'll have to find some workaround, like iterating over
4808      * all imaginable formats and collecting all the depth stencil formats we
4809      * can get. */
4810     hr = IWineD3DDevice_GetDisplayMode(ddraw->wineD3DDevice, 0, &d3ddm);
4811
4812     for (i = 0; i < (sizeof(formats) / sizeof(*formats)); ++i)
4813     {
4814         hr = IWineD3D_CheckDeviceFormat(ddraw->wineD3D, WINED3DADAPTER_DEFAULT, type, d3ddm.Format,
4815                 WINED3DUSAGE_DEPTHSTENCIL, WINED3DRTYPE_SURFACE, formats[i], SURFACE_OPENGL);
4816         if (SUCCEEDED(hr))
4817         {
4818             DDPIXELFORMAT pformat;
4819
4820             memset(&pformat, 0, sizeof(pformat));
4821             pformat.dwSize = sizeof(pformat);
4822             PixelFormat_WineD3DtoDD(&pformat, formats[i]);
4823
4824             TRACE("Enumerating wined3d format %#x.\n", formats[i]);
4825             hr = callback(&pformat, context);
4826             if (hr != DDENUMRET_OK)
4827             {
4828                 TRACE("Format enumeration cancelled by application.\n");
4829                 LeaveCriticalSection(&ddraw_cs);
4830                 return D3D_OK;
4831             }
4832         }
4833     }
4834     TRACE("End of enumeration.\n");
4835
4836     LeaveCriticalSection(&ddraw_cs);
4837     return D3D_OK;
4838 }
4839
4840 static HRESULT WINAPI d3d3_EnumZBufferFormats(IDirect3D3 *iface, REFCLSID device_iid,
4841         LPD3DENUMPIXELFORMATSCALLBACK callback, void *context)
4842 {
4843     TRACE("iface %p, device_iid %s, callback %p, context %p.\n",
4844             iface, debugstr_guid(device_iid), callback, context);
4845
4846     return d3d7_EnumZBufferFormats((IDirect3D7 *)&ddraw_from_d3d3(iface)->IDirect3D7_vtbl,
4847             device_iid, callback, context);
4848 }
4849
4850 /*****************************************************************************
4851  * IDirect3D7::EvictManagedTextures
4852  *
4853  * Removes all managed textures (=surfaces with DDSCAPS2_TEXTUREMANAGE or
4854  * DDSCAPS2_D3DTEXTUREMANAGE caps) to be removed from video memory.
4855  *
4856  * Version 3 and 7
4857  *
4858  * Returns:
4859  *  D3D_OK, because it's a stub
4860  *
4861  *****************************************************************************/
4862 static HRESULT WINAPI d3d7_EvictManagedTextures(IDirect3D7 *iface)
4863 {
4864     FIXME("iface %p stub!\n", iface);
4865
4866     /* TODO: Just enumerate resources using IWineD3DDevice_EnumResources(),
4867      * then unload surfaces / textures. */
4868
4869     return D3D_OK;
4870 }
4871
4872 static HRESULT WINAPI d3d3_EvictManagedTextures(IDirect3D3 *iface)
4873 {
4874     TRACE("iface %p.\n", iface);
4875
4876     return d3d7_EvictManagedTextures((IDirect3D7 *)&ddraw_from_d3d3(iface)->IDirect3D7_vtbl);
4877 }
4878
4879 /*****************************************************************************
4880  * IDirect3DImpl_GetCaps
4881  *
4882  * This function retrieves the device caps from wined3d
4883  * and converts it into a D3D7 and D3D - D3D3 structure
4884  * This is a helper function called from various places in ddraw
4885  *
4886  * Params:
4887  *  wined3d: The interface to get the caps from
4888  *  desc1: Old D3D <3 structure to fill (needed)
4889  *  desc7: D3D7 device desc structure to fill (needed)
4890  *
4891  * Returns
4892  *  D3D_OK on success, or the return value of IWineD3D::GetCaps
4893  *
4894  *****************************************************************************/
4895 HRESULT IDirect3DImpl_GetCaps(IWineD3D *wined3d, D3DDEVICEDESC *desc1, D3DDEVICEDESC7 *desc7)
4896 {
4897     WINED3DCAPS wined3d_caps;
4898     HRESULT hr;
4899
4900     TRACE("wined3d %p, desc1 %p, desc7 %p.\n", wined3d, desc1, desc7);
4901
4902     memset(&wined3d_caps, 0, sizeof(wined3d_caps));
4903
4904     EnterCriticalSection(&ddraw_cs);
4905     hr = IWineD3D_GetDeviceCaps(wined3d, 0, WINED3DDEVTYPE_HAL, &wined3d_caps);
4906     LeaveCriticalSection(&ddraw_cs);
4907     if (FAILED(hr))
4908     {
4909         WARN("Failed to get device caps, hr %#x.\n", hr);
4910         return hr;
4911     }
4912
4913     /* Copy the results into the d3d7 and d3d3 structures */
4914     desc7->dwDevCaps = wined3d_caps.DevCaps;
4915     desc7->dpcLineCaps.dwMiscCaps = wined3d_caps.PrimitiveMiscCaps;
4916     desc7->dpcLineCaps.dwRasterCaps = wined3d_caps.RasterCaps;
4917     desc7->dpcLineCaps.dwZCmpCaps = wined3d_caps.ZCmpCaps;
4918     desc7->dpcLineCaps.dwSrcBlendCaps = wined3d_caps.SrcBlendCaps;
4919     desc7->dpcLineCaps.dwDestBlendCaps = wined3d_caps.DestBlendCaps;
4920     desc7->dpcLineCaps.dwAlphaCmpCaps = wined3d_caps.AlphaCmpCaps;
4921     desc7->dpcLineCaps.dwShadeCaps = wined3d_caps.ShadeCaps;
4922     desc7->dpcLineCaps.dwTextureCaps = wined3d_caps.TextureCaps;
4923     desc7->dpcLineCaps.dwTextureFilterCaps = wined3d_caps.TextureFilterCaps;
4924     desc7->dpcLineCaps.dwTextureAddressCaps = wined3d_caps.TextureAddressCaps;
4925
4926     desc7->dwMaxTextureWidth = wined3d_caps.MaxTextureWidth;
4927     desc7->dwMaxTextureHeight = wined3d_caps.MaxTextureHeight;
4928
4929     desc7->dwMaxTextureRepeat = wined3d_caps.MaxTextureRepeat;
4930     desc7->dwMaxTextureAspectRatio = wined3d_caps.MaxTextureAspectRatio;
4931     desc7->dwMaxAnisotropy = wined3d_caps.MaxAnisotropy;
4932     desc7->dvMaxVertexW = wined3d_caps.MaxVertexW;
4933
4934     desc7->dvGuardBandLeft = wined3d_caps.GuardBandLeft;
4935     desc7->dvGuardBandTop = wined3d_caps.GuardBandTop;
4936     desc7->dvGuardBandRight = wined3d_caps.GuardBandRight;
4937     desc7->dvGuardBandBottom = wined3d_caps.GuardBandBottom;
4938
4939     desc7->dvExtentsAdjust = wined3d_caps.ExtentsAdjust;
4940     desc7->dwStencilCaps = wined3d_caps.StencilCaps;
4941
4942     desc7->dwFVFCaps = wined3d_caps.FVFCaps;
4943     desc7->dwTextureOpCaps = wined3d_caps.TextureOpCaps;
4944
4945     desc7->dwVertexProcessingCaps = wined3d_caps.VertexProcessingCaps;
4946     desc7->dwMaxActiveLights = wined3d_caps.MaxActiveLights;
4947
4948     /* Remove all non-d3d7 caps */
4949     desc7->dwDevCaps &= (
4950         D3DDEVCAPS_FLOATTLVERTEX         | D3DDEVCAPS_SORTINCREASINGZ          | D3DDEVCAPS_SORTDECREASINGZ          |
4951         D3DDEVCAPS_SORTEXACT             | D3DDEVCAPS_EXECUTESYSTEMMEMORY      | D3DDEVCAPS_EXECUTEVIDEOMEMORY       |
4952         D3DDEVCAPS_TLVERTEXSYSTEMMEMORY  | D3DDEVCAPS_TLVERTEXVIDEOMEMORY      | D3DDEVCAPS_TEXTURESYSTEMMEMORY      |
4953         D3DDEVCAPS_TEXTUREVIDEOMEMORY    | D3DDEVCAPS_DRAWPRIMTLVERTEX         | D3DDEVCAPS_CANRENDERAFTERFLIP       |
4954         D3DDEVCAPS_TEXTURENONLOCALVIDMEM | D3DDEVCAPS_DRAWPRIMITIVES2          | D3DDEVCAPS_SEPARATETEXTUREMEMORIES  |
4955         D3DDEVCAPS_DRAWPRIMITIVES2EX     | D3DDEVCAPS_HWTRANSFORMANDLIGHT      | D3DDEVCAPS_CANBLTSYSTONONLOCAL      |
4956         D3DDEVCAPS_HWRASTERIZATION);
4957
4958     desc7->dwStencilCaps &= (
4959         D3DSTENCILCAPS_KEEP              | D3DSTENCILCAPS_ZERO                 | D3DSTENCILCAPS_REPLACE              |
4960         D3DSTENCILCAPS_INCRSAT           | D3DSTENCILCAPS_DECRSAT              | D3DSTENCILCAPS_INVERT               |
4961         D3DSTENCILCAPS_INCR              | D3DSTENCILCAPS_DECR);
4962
4963     /* FVF caps ?*/
4964
4965     desc7->dwTextureOpCaps &= (
4966         D3DTEXOPCAPS_DISABLE             | D3DTEXOPCAPS_SELECTARG1             | D3DTEXOPCAPS_SELECTARG2             |
4967         D3DTEXOPCAPS_MODULATE            | D3DTEXOPCAPS_MODULATE2X             | D3DTEXOPCAPS_MODULATE4X             |
4968         D3DTEXOPCAPS_ADD                 | D3DTEXOPCAPS_ADDSIGNED              | D3DTEXOPCAPS_ADDSIGNED2X            |
4969         D3DTEXOPCAPS_SUBTRACT            | D3DTEXOPCAPS_ADDSMOOTH              | D3DTEXOPCAPS_BLENDTEXTUREALPHA      |
4970         D3DTEXOPCAPS_BLENDFACTORALPHA    | D3DTEXOPCAPS_BLENDTEXTUREALPHAPM    | D3DTEXOPCAPS_BLENDCURRENTALPHA      |
4971         D3DTEXOPCAPS_PREMODULATE         | D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
4972         D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA | D3DTEXOPCAPS_BUMPENVMAP    |
4973         D3DTEXOPCAPS_BUMPENVMAPLUMINANCE | D3DTEXOPCAPS_DOTPRODUCT3);
4974
4975     desc7->dwVertexProcessingCaps &= (
4976         D3DVTXPCAPS_TEXGEN               | D3DVTXPCAPS_MATERIALSOURCE7         | D3DVTXPCAPS_VERTEXFOG               |
4977         D3DVTXPCAPS_DIRECTIONALLIGHTS    | D3DVTXPCAPS_POSITIONALLIGHTS        | D3DVTXPCAPS_LOCALVIEWER);
4978
4979     desc7->dpcLineCaps.dwMiscCaps &= (
4980         D3DPMISCCAPS_MASKPLANES          | D3DPMISCCAPS_MASKZ                  | D3DPMISCCAPS_LINEPATTERNREP         |
4981         D3DPMISCCAPS_CONFORMANT          | D3DPMISCCAPS_CULLNONE               | D3DPMISCCAPS_CULLCW                 |
4982         D3DPMISCCAPS_CULLCCW);
4983
4984     desc7->dpcLineCaps.dwRasterCaps &= (
4985         D3DPRASTERCAPS_DITHER            | D3DPRASTERCAPS_ROP2                 | D3DPRASTERCAPS_XOR                  |
4986         D3DPRASTERCAPS_PAT               | D3DPRASTERCAPS_ZTEST                | D3DPRASTERCAPS_SUBPIXEL             |
4987         D3DPRASTERCAPS_SUBPIXELX         | D3DPRASTERCAPS_FOGVERTEX            | D3DPRASTERCAPS_FOGTABLE             |
4988         D3DPRASTERCAPS_STIPPLE           | D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT | D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT |
4989         D3DPRASTERCAPS_ANTIALIASEDGES    | D3DPRASTERCAPS_MIPMAPLODBIAS        | D3DPRASTERCAPS_ZBIAS                |
4990         D3DPRASTERCAPS_ZBUFFERLESSHSR    | D3DPRASTERCAPS_FOGRANGE             | D3DPRASTERCAPS_ANISOTROPY           |
4991         D3DPRASTERCAPS_WBUFFER           | D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT | D3DPRASTERCAPS_WFOG           |
4992         D3DPRASTERCAPS_ZFOG);
4993
4994     desc7->dpcLineCaps.dwZCmpCaps &= (
4995         D3DPCMPCAPS_NEVER                | D3DPCMPCAPS_LESS                    | D3DPCMPCAPS_EQUAL                   |
4996         D3DPCMPCAPS_LESSEQUAL            | D3DPCMPCAPS_GREATER                 | D3DPCMPCAPS_NOTEQUAL                |
4997         D3DPCMPCAPS_GREATEREQUAL         | D3DPCMPCAPS_ALWAYS);
4998
4999     desc7->dpcLineCaps.dwSrcBlendCaps &= (
5000         D3DPBLENDCAPS_ZERO               | D3DPBLENDCAPS_ONE                   | D3DPBLENDCAPS_SRCCOLOR              |
5001         D3DPBLENDCAPS_INVSRCCOLOR        | D3DPBLENDCAPS_SRCALPHA              | D3DPBLENDCAPS_INVSRCALPHA           |
5002         D3DPBLENDCAPS_DESTALPHA          | D3DPBLENDCAPS_INVDESTALPHA          | D3DPBLENDCAPS_DESTCOLOR             |
5003         D3DPBLENDCAPS_INVDESTCOLOR       | D3DPBLENDCAPS_SRCALPHASAT           | D3DPBLENDCAPS_BOTHSRCALPHA          |
5004         D3DPBLENDCAPS_BOTHINVSRCALPHA);
5005
5006     desc7->dpcLineCaps.dwDestBlendCaps &= (
5007         D3DPBLENDCAPS_ZERO               | D3DPBLENDCAPS_ONE                   | D3DPBLENDCAPS_SRCCOLOR              |
5008         D3DPBLENDCAPS_INVSRCCOLOR        | D3DPBLENDCAPS_SRCALPHA              | D3DPBLENDCAPS_INVSRCALPHA           |
5009         D3DPBLENDCAPS_DESTALPHA          | D3DPBLENDCAPS_INVDESTALPHA          | D3DPBLENDCAPS_DESTCOLOR             |
5010         D3DPBLENDCAPS_INVDESTCOLOR       | D3DPBLENDCAPS_SRCALPHASAT           | D3DPBLENDCAPS_BOTHSRCALPHA          |
5011         D3DPBLENDCAPS_BOTHINVSRCALPHA);
5012
5013     desc7->dpcLineCaps.dwAlphaCmpCaps &= (
5014         D3DPCMPCAPS_NEVER                | D3DPCMPCAPS_LESS                    | D3DPCMPCAPS_EQUAL                   |
5015         D3DPCMPCAPS_LESSEQUAL            | D3DPCMPCAPS_GREATER                 | D3DPCMPCAPS_NOTEQUAL                |
5016         D3DPCMPCAPS_GREATEREQUAL         | D3DPCMPCAPS_ALWAYS);
5017
5018     desc7->dpcLineCaps.dwShadeCaps &= (
5019         D3DPSHADECAPS_COLORFLATMONO      | D3DPSHADECAPS_COLORFLATRGB          | D3DPSHADECAPS_COLORGOURAUDMONO      |
5020         D3DPSHADECAPS_COLORGOURAUDRGB    | D3DPSHADECAPS_COLORPHONGMONO        | D3DPSHADECAPS_COLORPHONGRGB         |
5021         D3DPSHADECAPS_SPECULARFLATMONO   | D3DPSHADECAPS_SPECULARFLATRGB       | D3DPSHADECAPS_SPECULARGOURAUDMONO   |
5022         D3DPSHADECAPS_SPECULARGOURAUDRGB | D3DPSHADECAPS_SPECULARPHONGMONO     | D3DPSHADECAPS_SPECULARPHONGRGB      |
5023         D3DPSHADECAPS_ALPHAFLATBLEND     | D3DPSHADECAPS_ALPHAFLATSTIPPLED     | D3DPSHADECAPS_ALPHAGOURAUDBLEND     |
5024         D3DPSHADECAPS_ALPHAGOURAUDSTIPPLED | D3DPSHADECAPS_ALPHAPHONGBLEND     | D3DPSHADECAPS_ALPHAPHONGSTIPPLED    |
5025         D3DPSHADECAPS_FOGFLAT            | D3DPSHADECAPS_FOGGOURAUD            | D3DPSHADECAPS_FOGPHONG);
5026
5027     desc7->dpcLineCaps.dwTextureCaps &= (
5028         D3DPTEXTURECAPS_PERSPECTIVE      | D3DPTEXTURECAPS_POW2                | D3DPTEXTURECAPS_ALPHA               |
5029         D3DPTEXTURECAPS_TRANSPARENCY     | D3DPTEXTURECAPS_BORDER              | D3DPTEXTURECAPS_SQUAREONLY          |
5030         D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE | D3DPTEXTURECAPS_ALPHAPALETTE| D3DPTEXTURECAPS_NONPOW2CONDITIONAL  |
5031         D3DPTEXTURECAPS_PROJECTED        | D3DPTEXTURECAPS_CUBEMAP             | D3DPTEXTURECAPS_COLORKEYBLEND);
5032
5033     desc7->dpcLineCaps.dwTextureFilterCaps &= (
5034         D3DPTFILTERCAPS_NEAREST          | D3DPTFILTERCAPS_LINEAR              | D3DPTFILTERCAPS_MIPNEAREST          |
5035         D3DPTFILTERCAPS_MIPLINEAR        | D3DPTFILTERCAPS_LINEARMIPNEAREST    | D3DPTFILTERCAPS_LINEARMIPLINEAR     |
5036         D3DPTFILTERCAPS_MINFPOINT        | D3DPTFILTERCAPS_MINFLINEAR          | D3DPTFILTERCAPS_MINFANISOTROPIC     |
5037         D3DPTFILTERCAPS_MIPFPOINT        | D3DPTFILTERCAPS_MIPFLINEAR          | D3DPTFILTERCAPS_MAGFPOINT           |
5038         D3DPTFILTERCAPS_MAGFLINEAR       | D3DPTFILTERCAPS_MAGFANISOTROPIC     | D3DPTFILTERCAPS_MAGFAFLATCUBIC      |
5039         D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC);
5040
5041     desc7->dpcLineCaps.dwTextureBlendCaps &= (
5042         D3DPTBLENDCAPS_DECAL             | D3DPTBLENDCAPS_MODULATE             | D3DPTBLENDCAPS_DECALALPHA           |
5043         D3DPTBLENDCAPS_MODULATEALPHA     | D3DPTBLENDCAPS_DECALMASK            | D3DPTBLENDCAPS_MODULATEMASK         |
5044         D3DPTBLENDCAPS_COPY              | D3DPTBLENDCAPS_ADD);
5045
5046     desc7->dpcLineCaps.dwTextureAddressCaps &= (
5047         D3DPTADDRESSCAPS_WRAP            | D3DPTADDRESSCAPS_MIRROR             | D3DPTADDRESSCAPS_CLAMP              |
5048         D3DPTADDRESSCAPS_BORDER          | D3DPTADDRESSCAPS_INDEPENDENTUV);
5049
5050     if (!(desc7->dpcLineCaps.dwTextureCaps & D3DPTEXTURECAPS_POW2))
5051     {
5052         /* DirectX7 always has the np2 flag set, no matter what the card
5053          * supports. Some old games (Rollcage) check the caps incorrectly.
5054          * If wined3d supports nonpow2 textures it also has np2 conditional
5055          * support. */
5056         desc7->dpcLineCaps.dwTextureCaps |= D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL;
5057     }
5058
5059     /* Fill the missing members, and do some fixup */
5060     desc7->dpcLineCaps.dwSize = sizeof(desc7->dpcLineCaps);
5061     desc7->dpcLineCaps.dwTextureBlendCaps = D3DPTBLENDCAPS_ADD | D3DPTBLENDCAPS_MODULATEMASK |
5062                                             D3DPTBLENDCAPS_COPY | D3DPTBLENDCAPS_DECAL |
5063                                             D3DPTBLENDCAPS_DECALALPHA | D3DPTBLENDCAPS_DECALMASK |
5064                                             D3DPTBLENDCAPS_MODULATE | D3DPTBLENDCAPS_MODULATEALPHA;
5065     desc7->dpcLineCaps.dwStippleWidth = 32;
5066     desc7->dpcLineCaps.dwStippleHeight = 32;
5067     /* Use the same for the TriCaps */
5068     desc7->dpcTriCaps = desc7->dpcLineCaps;
5069
5070     desc7->dwDeviceRenderBitDepth = DDBD_16 | DDBD_24 | DDBD_32;
5071     desc7->dwDeviceZBufferBitDepth = DDBD_16 | DDBD_24;
5072     desc7->dwMinTextureWidth = 1;
5073     desc7->dwMinTextureHeight = 1;
5074
5075     /* Convert DWORDs safely to WORDs */
5076     if (wined3d_caps.MaxTextureBlendStages > 0xffff) desc7->wMaxTextureBlendStages = 0xffff;
5077     else desc7->wMaxTextureBlendStages = (WORD)wined3d_caps.MaxTextureBlendStages;
5078     if (wined3d_caps.MaxSimultaneousTextures > 0xffff) desc7->wMaxSimultaneousTextures = 0xffff;
5079     else desc7->wMaxSimultaneousTextures = (WORD)wined3d_caps.MaxSimultaneousTextures;
5080
5081     if (wined3d_caps.MaxUserClipPlanes > 0xffff) desc7->wMaxUserClipPlanes = 0xffff;
5082     else desc7->wMaxUserClipPlanes = (WORD)wined3d_caps.MaxUserClipPlanes;
5083     if (wined3d_caps.MaxVertexBlendMatrices > 0xffff) desc7->wMaxVertexBlendMatrices = 0xffff;
5084     else desc7->wMaxVertexBlendMatrices = (WORD)wined3d_caps.MaxVertexBlendMatrices;
5085
5086     desc7->deviceGUID = IID_IDirect3DTnLHalDevice;
5087
5088     desc7->dwReserved1 = 0;
5089     desc7->dwReserved2 = 0;
5090     desc7->dwReserved3 = 0;
5091     desc7->dwReserved4 = 0;
5092
5093     /* Fill the old structure */
5094     memset(desc1, 0, sizeof(*desc1));
5095     desc1->dwSize = sizeof(D3DDEVICEDESC);
5096     desc1->dwFlags = D3DDD_COLORMODEL
5097             | D3DDD_DEVCAPS
5098             | D3DDD_TRANSFORMCAPS
5099             | D3DDD_BCLIPPING
5100             | D3DDD_LIGHTINGCAPS
5101             | D3DDD_LINECAPS
5102             | D3DDD_TRICAPS
5103             | D3DDD_DEVICERENDERBITDEPTH
5104             | D3DDD_DEVICEZBUFFERBITDEPTH
5105             | D3DDD_MAXBUFFERSIZE
5106             | D3DDD_MAXVERTEXCOUNT;
5107
5108     desc1->dcmColorModel = D3DCOLOR_RGB;
5109     desc1->dwDevCaps = desc7->dwDevCaps;
5110     desc1->dtcTransformCaps.dwSize = sizeof(D3DTRANSFORMCAPS);
5111     desc1->dtcTransformCaps.dwCaps = D3DTRANSFORMCAPS_CLIP;
5112     desc1->bClipping = TRUE;
5113     desc1->dlcLightingCaps.dwSize = sizeof(D3DLIGHTINGCAPS);
5114     desc1->dlcLightingCaps.dwCaps = D3DLIGHTCAPS_DIRECTIONAL
5115             | D3DLIGHTCAPS_PARALLELPOINT
5116             | D3DLIGHTCAPS_POINT
5117             | D3DLIGHTCAPS_SPOT;
5118
5119     desc1->dlcLightingCaps.dwLightingModel = D3DLIGHTINGMODEL_RGB;
5120     desc1->dlcLightingCaps.dwNumLights = desc7->dwMaxActiveLights;
5121
5122     desc1->dpcLineCaps.dwSize = sizeof(D3DPRIMCAPS);
5123     desc1->dpcLineCaps.dwMiscCaps = desc7->dpcLineCaps.dwMiscCaps;
5124     desc1->dpcLineCaps.dwRasterCaps = desc7->dpcLineCaps.dwRasterCaps;
5125     desc1->dpcLineCaps.dwZCmpCaps = desc7->dpcLineCaps.dwZCmpCaps;
5126     desc1->dpcLineCaps.dwSrcBlendCaps = desc7->dpcLineCaps.dwSrcBlendCaps;
5127     desc1->dpcLineCaps.dwDestBlendCaps = desc7->dpcLineCaps.dwDestBlendCaps;
5128     desc1->dpcLineCaps.dwShadeCaps = desc7->dpcLineCaps.dwShadeCaps;
5129     desc1->dpcLineCaps.dwTextureCaps = desc7->dpcLineCaps.dwTextureCaps;
5130     desc1->dpcLineCaps.dwTextureFilterCaps = desc7->dpcLineCaps.dwTextureFilterCaps;
5131     desc1->dpcLineCaps.dwTextureBlendCaps = desc7->dpcLineCaps.dwTextureBlendCaps;
5132     desc1->dpcLineCaps.dwTextureAddressCaps = desc7->dpcLineCaps.dwTextureAddressCaps;
5133     desc1->dpcLineCaps.dwStippleWidth = desc7->dpcLineCaps.dwStippleWidth;
5134     desc1->dpcLineCaps.dwAlphaCmpCaps = desc7->dpcLineCaps.dwAlphaCmpCaps;
5135
5136     desc1->dpcTriCaps.dwSize = sizeof(D3DPRIMCAPS);
5137     desc1->dpcTriCaps.dwMiscCaps = desc7->dpcTriCaps.dwMiscCaps;
5138     desc1->dpcTriCaps.dwRasterCaps = desc7->dpcTriCaps.dwRasterCaps;
5139     desc1->dpcTriCaps.dwZCmpCaps = desc7->dpcTriCaps.dwZCmpCaps;
5140     desc1->dpcTriCaps.dwSrcBlendCaps = desc7->dpcTriCaps.dwSrcBlendCaps;
5141     desc1->dpcTriCaps.dwDestBlendCaps = desc7->dpcTriCaps.dwDestBlendCaps;
5142     desc1->dpcTriCaps.dwShadeCaps = desc7->dpcTriCaps.dwShadeCaps;
5143     desc1->dpcTriCaps.dwTextureCaps = desc7->dpcTriCaps.dwTextureCaps;
5144     desc1->dpcTriCaps.dwTextureFilterCaps = desc7->dpcTriCaps.dwTextureFilterCaps;
5145     desc1->dpcTriCaps.dwTextureBlendCaps = desc7->dpcTriCaps.dwTextureBlendCaps;
5146     desc1->dpcTriCaps.dwTextureAddressCaps = desc7->dpcTriCaps.dwTextureAddressCaps;
5147     desc1->dpcTriCaps.dwStippleWidth = desc7->dpcTriCaps.dwStippleWidth;
5148     desc1->dpcTriCaps.dwAlphaCmpCaps = desc7->dpcTriCaps.dwAlphaCmpCaps;
5149
5150     desc1->dwDeviceRenderBitDepth = desc7->dwDeviceRenderBitDepth;
5151     desc1->dwDeviceZBufferBitDepth = desc7->dwDeviceZBufferBitDepth;
5152     desc1->dwMaxBufferSize = 0;
5153     desc1->dwMaxVertexCount = 65536;
5154     desc1->dwMinTextureWidth  = desc7->dwMinTextureWidth;
5155     desc1->dwMinTextureHeight = desc7->dwMinTextureHeight;
5156     desc1->dwMaxTextureWidth  = desc7->dwMaxTextureWidth;
5157     desc1->dwMaxTextureHeight = desc7->dwMaxTextureHeight;
5158     desc1->dwMinStippleWidth  = 1;
5159     desc1->dwMinStippleHeight = 1;
5160     desc1->dwMaxStippleWidth  = 32;
5161     desc1->dwMaxStippleHeight = 32;
5162     desc1->dwMaxTextureRepeat = desc7->dwMaxTextureRepeat;
5163     desc1->dwMaxTextureAspectRatio = desc7->dwMaxTextureAspectRatio;
5164     desc1->dwMaxAnisotropy = desc7->dwMaxAnisotropy;
5165     desc1->dvGuardBandLeft = desc7->dvGuardBandLeft;
5166     desc1->dvGuardBandRight = desc7->dvGuardBandRight;
5167     desc1->dvGuardBandTop = desc7->dvGuardBandTop;
5168     desc1->dvGuardBandBottom = desc7->dvGuardBandBottom;
5169     desc1->dvExtentsAdjust = desc7->dvExtentsAdjust;
5170     desc1->dwStencilCaps = desc7->dwStencilCaps;
5171     desc1->dwFVFCaps = desc7->dwFVFCaps;
5172     desc1->dwTextureOpCaps = desc7->dwTextureOpCaps;
5173     desc1->wMaxTextureBlendStages = desc7->wMaxTextureBlendStages;
5174     desc1->wMaxSimultaneousTextures = desc7->wMaxSimultaneousTextures;
5175
5176     return DD_OK;
5177 }
5178
5179 /*****************************************************************************
5180  * IDirectDraw7 VTable
5181  *****************************************************************************/
5182 static const struct IDirectDraw7Vtbl ddraw7_vtbl =
5183 {
5184     /* IUnknown */
5185     ddraw7_QueryInterface,
5186     ddraw7_AddRef,
5187     ddraw7_Release,
5188     /* IDirectDraw */
5189     ddraw7_Compact,
5190     ddraw7_CreateClipper,
5191     ddraw7_CreatePalette,
5192     ddraw7_CreateSurface,
5193     ddraw7_DuplicateSurface,
5194     ddraw7_EnumDisplayModes,
5195     ddraw7_EnumSurfaces,
5196     ddraw7_FlipToGDISurface,
5197     ddraw7_GetCaps,
5198     ddraw7_GetDisplayMode,
5199     ddraw7_GetFourCCCodes,
5200     ddraw7_GetGDISurface,
5201     ddraw7_GetMonitorFrequency,
5202     ddraw7_GetScanLine,
5203     ddraw7_GetVerticalBlankStatus,
5204     ddraw7_Initialize,
5205     ddraw7_RestoreDisplayMode,
5206     ddraw7_SetCooperativeLevel,
5207     ddraw7_SetDisplayMode,
5208     ddraw7_WaitForVerticalBlank,
5209     /* IDirectDraw2 */
5210     ddraw7_GetAvailableVidMem,
5211     /* IDirectDraw3 */
5212     ddraw7_GetSurfaceFromDC,
5213     /* IDirectDraw4 */
5214     ddraw7_RestoreAllSurfaces,
5215     ddraw7_TestCooperativeLevel,
5216     ddraw7_GetDeviceIdentifier,
5217     /* IDirectDraw7 */
5218     ddraw7_StartModeTest,
5219     ddraw7_EvaluateMode
5220 };
5221
5222 static const struct IDirectDraw4Vtbl ddraw4_vtbl =
5223 {
5224     /* IUnknown */
5225     ddraw4_QueryInterface,
5226     ddraw4_AddRef,
5227     ddraw4_Release,
5228     /* IDirectDraw */
5229     ddraw4_Compact,
5230     ddraw4_CreateClipper,
5231     ddraw4_CreatePalette,
5232     ddraw4_CreateSurface,
5233     ddraw4_DuplicateSurface,
5234     ddraw4_EnumDisplayModes,
5235     ddraw4_EnumSurfaces,
5236     ddraw4_FlipToGDISurface,
5237     ddraw4_GetCaps,
5238     ddraw4_GetDisplayMode,
5239     ddraw4_GetFourCCCodes,
5240     ddraw4_GetGDISurface,
5241     ddraw4_GetMonitorFrequency,
5242     ddraw4_GetScanLine,
5243     ddraw4_GetVerticalBlankStatus,
5244     ddraw4_Initialize,
5245     ddraw4_RestoreDisplayMode,
5246     ddraw4_SetCooperativeLevel,
5247     ddraw4_SetDisplayMode,
5248     ddraw4_WaitForVerticalBlank,
5249     /* IDirectDraw2 */
5250     ddraw4_GetAvailableVidMem,
5251     /* IDirectDraw3 */
5252     ddraw4_GetSurfaceFromDC,
5253     /* IDirectDraw4 */
5254     ddraw4_RestoreAllSurfaces,
5255     ddraw4_TestCooperativeLevel,
5256     ddraw4_GetDeviceIdentifier,
5257 };
5258
5259 static const struct IDirectDraw3Vtbl ddraw3_vtbl =
5260 {
5261     /* IUnknown */
5262     ddraw3_QueryInterface,
5263     ddraw3_AddRef,
5264     ddraw3_Release,
5265     /* IDirectDraw */
5266     ddraw3_Compact,
5267     ddraw3_CreateClipper,
5268     ddraw3_CreatePalette,
5269     ddraw3_CreateSurface,
5270     ddraw3_DuplicateSurface,
5271     ddraw3_EnumDisplayModes,
5272     ddraw3_EnumSurfaces,
5273     ddraw3_FlipToGDISurface,
5274     ddraw3_GetCaps,
5275     ddraw3_GetDisplayMode,
5276     ddraw3_GetFourCCCodes,
5277     ddraw3_GetGDISurface,
5278     ddraw3_GetMonitorFrequency,
5279     ddraw3_GetScanLine,
5280     ddraw3_GetVerticalBlankStatus,
5281     ddraw3_Initialize,
5282     ddraw3_RestoreDisplayMode,
5283     ddraw3_SetCooperativeLevel,
5284     ddraw3_SetDisplayMode,
5285     ddraw3_WaitForVerticalBlank,
5286     /* IDirectDraw2 */
5287     ddraw3_GetAvailableVidMem,
5288     /* IDirectDraw3 */
5289     ddraw3_GetSurfaceFromDC,
5290 };
5291
5292 static const struct IDirectDraw2Vtbl ddraw2_vtbl =
5293 {
5294     /* IUnknown */
5295     ddraw2_QueryInterface,
5296     ddraw2_AddRef,
5297     ddraw2_Release,
5298     /* IDirectDraw */
5299     ddraw2_Compact,
5300     ddraw2_CreateClipper,
5301     ddraw2_CreatePalette,
5302     ddraw2_CreateSurface,
5303     ddraw2_DuplicateSurface,
5304     ddraw2_EnumDisplayModes,
5305     ddraw2_EnumSurfaces,
5306     ddraw2_FlipToGDISurface,
5307     ddraw2_GetCaps,
5308     ddraw2_GetDisplayMode,
5309     ddraw2_GetFourCCCodes,
5310     ddraw2_GetGDISurface,
5311     ddraw2_GetMonitorFrequency,
5312     ddraw2_GetScanLine,
5313     ddraw2_GetVerticalBlankStatus,
5314     ddraw2_Initialize,
5315     ddraw2_RestoreDisplayMode,
5316     ddraw2_SetCooperativeLevel,
5317     ddraw2_SetDisplayMode,
5318     ddraw2_WaitForVerticalBlank,
5319     /* IDirectDraw2 */
5320     ddraw2_GetAvailableVidMem,
5321 };
5322
5323 static const struct IDirectDrawVtbl ddraw1_vtbl =
5324 {
5325     /* IUnknown */
5326     ddraw1_QueryInterface,
5327     ddraw1_AddRef,
5328     ddraw1_Release,
5329     /* IDirectDraw */
5330     ddraw1_Compact,
5331     ddraw1_CreateClipper,
5332     ddraw1_CreatePalette,
5333     ddraw1_CreateSurface,
5334     ddraw1_DuplicateSurface,
5335     ddraw1_EnumDisplayModes,
5336     ddraw1_EnumSurfaces,
5337     ddraw1_FlipToGDISurface,
5338     ddraw1_GetCaps,
5339     ddraw1_GetDisplayMode,
5340     ddraw1_GetFourCCCodes,
5341     ddraw1_GetGDISurface,
5342     ddraw1_GetMonitorFrequency,
5343     ddraw1_GetScanLine,
5344     ddraw1_GetVerticalBlankStatus,
5345     ddraw1_Initialize,
5346     ddraw1_RestoreDisplayMode,
5347     ddraw1_SetCooperativeLevel,
5348     ddraw1_SetDisplayMode,
5349     ddraw1_WaitForVerticalBlank,
5350 };
5351
5352 static const struct IDirect3D7Vtbl d3d7_vtbl =
5353 {
5354     /* IUnknown methods */
5355     d3d7_QueryInterface,
5356     d3d7_AddRef,
5357     d3d7_Release,
5358     /* IDirect3D7 methods */
5359     d3d7_EnumDevices,
5360     d3d7_CreateDevice,
5361     d3d7_CreateVertexBuffer,
5362     d3d7_EnumZBufferFormats,
5363     d3d7_EvictManagedTextures
5364 };
5365
5366 static const struct IDirect3D3Vtbl d3d3_vtbl =
5367 {
5368     /* IUnknown methods */
5369     d3d3_QueryInterface,
5370     d3d3_AddRef,
5371     d3d3_Release,
5372     /* IDirect3D3 methods */
5373     d3d3_EnumDevices,
5374     d3d3_CreateLight,
5375     d3d3_CreateMaterial,
5376     d3d3_CreateViewport,
5377     d3d3_FindDevice,
5378     d3d3_CreateDevice,
5379     d3d3_CreateVertexBuffer,
5380     d3d3_EnumZBufferFormats,
5381     d3d3_EvictManagedTextures
5382 };
5383
5384 static const struct IDirect3D2Vtbl d3d2_vtbl =
5385 {
5386     /* IUnknown methods */
5387     d3d2_QueryInterface,
5388     d3d2_AddRef,
5389     d3d2_Release,
5390     /* IDirect3D2 methods */
5391     d3d2_EnumDevices,
5392     d3d2_CreateLight,
5393     d3d2_CreateMaterial,
5394     d3d2_CreateViewport,
5395     d3d2_FindDevice,
5396     d3d2_CreateDevice
5397 };
5398
5399 static const struct IDirect3DVtbl d3d1_vtbl =
5400 {
5401     /* IUnknown methods */
5402     d3d1_QueryInterface,
5403     d3d1_AddRef,
5404     d3d1_Release,
5405     /* IDirect3D methods */
5406     d3d1_Initialize,
5407     d3d1_EnumDevices,
5408     d3d1_CreateLight,
5409     d3d1_CreateMaterial,
5410     d3d1_CreateViewport,
5411     d3d1_FindDevice
5412 };
5413
5414 /*****************************************************************************
5415  * ddraw_find_decl
5416  *
5417  * Finds the WineD3D vertex declaration for a specific fvf, and creates one
5418  * if none was found.
5419  *
5420  * This function is in ddraw.c and the DDraw object space because D3D7
5421  * vertex buffers are created using the IDirect3D interface to the ddraw
5422  * object, so they can be valid across D3D devices(theoretically. The ddraw
5423  * object also owns the wined3d device
5424  *
5425  * Parameters:
5426  *  This: Device
5427  *  fvf: Fvf to find the decl for
5428  *
5429  * Returns:
5430  *  NULL in case of an error, the IWineD3DVertexDeclaration interface for the
5431  *  fvf otherwise.
5432  *
5433  *****************************************************************************/
5434 IWineD3DVertexDeclaration *ddraw_find_decl(IDirectDrawImpl *This, DWORD fvf)
5435 {
5436     HRESULT hr;
5437     IWineD3DVertexDeclaration* pDecl = NULL;
5438     int p, low, high; /* deliberately signed */
5439     struct FvfToDecl *convertedDecls = This->decls;
5440
5441     TRACE("Searching for declaration for fvf %08x... ", fvf);
5442
5443     low = 0;
5444     high = This->numConvertedDecls - 1;
5445     while(low <= high) {
5446         p = (low + high) >> 1;
5447         TRACE("%d ", p);
5448         if(convertedDecls[p].fvf == fvf) {
5449             TRACE("found %p\n", convertedDecls[p].decl);
5450             return convertedDecls[p].decl;
5451         } else if(convertedDecls[p].fvf < fvf) {
5452             low = p + 1;
5453         } else {
5454             high = p - 1;
5455         }
5456     }
5457     TRACE("not found. Creating and inserting at position %d.\n", low);
5458
5459     hr = IWineD3DDevice_CreateVertexDeclarationFromFVF(This->wineD3DDevice,
5460             fvf, This, &ddraw_null_wined3d_parent_ops, &pDecl);
5461     if (hr != S_OK) return NULL;
5462
5463     if(This->declArraySize == This->numConvertedDecls) {
5464         int grow = max(This->declArraySize / 2, 8);
5465         convertedDecls = HeapReAlloc(GetProcessHeap(), 0, convertedDecls,
5466                                      sizeof(convertedDecls[0]) * (This->numConvertedDecls + grow));
5467         if(!convertedDecls) {
5468             /* This will destroy it */
5469             IWineD3DVertexDeclaration_Release(pDecl);
5470             return NULL;
5471         }
5472         This->decls = convertedDecls;
5473         This->declArraySize += grow;
5474     }
5475
5476     memmove(convertedDecls + low + 1, convertedDecls + low, sizeof(convertedDecls[0]) * (This->numConvertedDecls - low));
5477     convertedDecls[low].decl = pDecl;
5478     convertedDecls[low].fvf = fvf;
5479     This->numConvertedDecls++;
5480
5481     TRACE("Returning %p. %d decls in array\n", pDecl, This->numConvertedDecls);
5482     return pDecl;
5483 }
5484
5485 /* IWineD3DDeviceParent IUnknown methods */
5486
5487 static inline struct IDirectDrawImpl *ddraw_from_device_parent(IWineD3DDeviceParent *iface)
5488 {
5489     return (struct IDirectDrawImpl *)((char*)iface - FIELD_OFFSET(struct IDirectDrawImpl, device_parent_vtbl));
5490 }
5491
5492 static HRESULT STDMETHODCALLTYPE device_parent_QueryInterface(IWineD3DDeviceParent *iface, REFIID riid, void **object)
5493 {
5494     struct IDirectDrawImpl *This = ddraw_from_device_parent(iface);
5495     return ddraw7_QueryInterface((IDirectDraw7 *)This, riid, object);
5496 }
5497
5498 static ULONG STDMETHODCALLTYPE device_parent_AddRef(IWineD3DDeviceParent *iface)
5499 {
5500     struct IDirectDrawImpl *This = ddraw_from_device_parent(iface);
5501     return ddraw7_AddRef((IDirectDraw7 *)This);
5502 }
5503
5504 static ULONG STDMETHODCALLTYPE device_parent_Release(IWineD3DDeviceParent *iface)
5505 {
5506     struct IDirectDrawImpl *This = ddraw_from_device_parent(iface);
5507     return ddraw7_Release((IDirectDraw7 *)This);
5508 }
5509
5510 /* IWineD3DDeviceParent methods */
5511
5512 static void STDMETHODCALLTYPE device_parent_WineD3DDeviceCreated(IWineD3DDeviceParent *iface, IWineD3DDevice *device)
5513 {
5514     TRACE("iface %p, device %p\n", iface, device);
5515 }
5516
5517 static HRESULT STDMETHODCALLTYPE device_parent_CreateSurface(IWineD3DDeviceParent *iface,
5518         IUnknown *superior, UINT width, UINT height, enum wined3d_format_id format, DWORD usage,
5519         WINED3DPOOL pool, UINT level, WINED3DCUBEMAP_FACES face, IWineD3DSurface **surface)
5520 {
5521     struct IDirectDrawImpl *This = ddraw_from_device_parent(iface);
5522     IDirectDrawSurfaceImpl *surf = NULL;
5523     UINT i = 0;
5524     DDSCAPS2 searchcaps = This->tex_root->surface_desc.ddsCaps;
5525
5526     TRACE("iface %p, superior %p, width %u, height %u, format %#x, usage %#x,\n"
5527             "\tpool %#x, level %u, face %u, surface %p\n",
5528             iface, superior, width, height, format, usage, pool, level, face, surface);
5529
5530     searchcaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
5531     switch(face)
5532     {
5533         case WINED3DCUBEMAP_FACE_POSITIVE_X:
5534             TRACE("Asked for positive x\n");
5535             if (searchcaps.dwCaps2 & DDSCAPS2_CUBEMAP)
5536             {
5537                 searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEX;
5538             }
5539             surf = This->tex_root; break;
5540         case WINED3DCUBEMAP_FACE_NEGATIVE_X:
5541             TRACE("Asked for negative x\n");
5542             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEX; break;
5543         case WINED3DCUBEMAP_FACE_POSITIVE_Y:
5544             TRACE("Asked for positive y\n");
5545             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEY; break;
5546         case WINED3DCUBEMAP_FACE_NEGATIVE_Y:
5547             TRACE("Asked for negative y\n");
5548             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEY; break;
5549         case WINED3DCUBEMAP_FACE_POSITIVE_Z:
5550             TRACE("Asked for positive z\n");
5551             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEZ; break;
5552         case WINED3DCUBEMAP_FACE_NEGATIVE_Z:
5553             TRACE("Asked for negative z\n");
5554             searchcaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEZ; break;
5555         default: {ERR("Unexpected cube face\n");} /* Stupid compiler */
5556     }
5557
5558     if (!surf)
5559     {
5560         IDirectDrawSurface7 *attached;
5561         IDirectDrawSurface7_GetAttachedSurface((IDirectDrawSurface7 *)This->tex_root, &searchcaps, &attached);
5562         surf = (IDirectDrawSurfaceImpl *)attached;
5563         IDirectDrawSurface7_Release(attached);
5564     }
5565     if (!surf) ERR("root search surface not found\n");
5566
5567     /* Find the wanted mipmap. There are enough mipmaps in the chain */
5568     while (i < level)
5569     {
5570         IDirectDrawSurface7 *attached;
5571         IDirectDrawSurface7_GetAttachedSurface((IDirectDrawSurface7 *)surf, &searchcaps, &attached);
5572         if(!attached) ERR("Surface not found\n");
5573         surf = (IDirectDrawSurfaceImpl *)attached;
5574         IDirectDrawSurface7_Release(attached);
5575         ++i;
5576     }
5577
5578     /* Return the surface */
5579     *surface = surf->WineD3DSurface;
5580     IWineD3DSurface_AddRef(*surface);
5581
5582     TRACE("Returning wineD3DSurface %p, it belongs to surface %p\n", *surface, surf);
5583
5584     return D3D_OK;
5585 }
5586
5587 static HRESULT WINAPI findRenderTarget(IDirectDrawSurface7 *surface, DDSURFACEDESC2 *surface_desc, void *ctx)
5588 {
5589     IDirectDrawSurfaceImpl *s = (IDirectDrawSurfaceImpl *)surface;
5590     IDirectDrawSurfaceImpl **target = ctx;
5591
5592     if (!s->isRenderTarget)
5593     {
5594         *target = s;
5595         IDirectDrawSurface7_Release(surface);
5596         return DDENUMRET_CANCEL;
5597     }
5598
5599     /* Recurse into the surface tree */
5600     IDirectDrawSurface7_EnumAttachedSurfaces(surface, ctx, findRenderTarget);
5601
5602     IDirectDrawSurface7_Release(surface);
5603     if (*target) return DDENUMRET_CANCEL;
5604
5605     return DDENUMRET_OK;
5606 }
5607
5608 static HRESULT STDMETHODCALLTYPE device_parent_CreateRenderTarget(IWineD3DDeviceParent *iface,
5609         IUnknown *superior, UINT width, UINT height, enum wined3d_format_id format,
5610         WINED3DMULTISAMPLE_TYPE multisample_type, DWORD multisample_quality, BOOL lockable,
5611         IWineD3DSurface **surface)
5612 {
5613     struct IDirectDrawImpl *This = ddraw_from_device_parent(iface);
5614     IDirectDrawSurfaceImpl *d3d_surface = This->d3d_target;
5615     IDirectDrawSurfaceImpl *target = NULL;
5616
5617     TRACE("iface %p, superior %p, width %u, height %u, format %#x, multisample_type %#x,\n"
5618             "\tmultisample_quality %u, lockable %u, surface %p\n",
5619             iface, superior, width, height, format, multisample_type, multisample_quality, lockable, surface);
5620
5621     if (d3d_surface->isRenderTarget)
5622     {
5623         IDirectDrawSurface7_EnumAttachedSurfaces((IDirectDrawSurface7 *)d3d_surface, &target, findRenderTarget);
5624     }
5625     else
5626     {
5627         target = d3d_surface;
5628     }
5629
5630     if (!target)
5631     {
5632         target = This->d3d_target;
5633         ERR(" (%p) : No DirectDrawSurface found to create the back buffer. Using the front buffer as back buffer. Uncertain consequences\n", This);
5634     }
5635
5636     /* TODO: Return failure if the dimensions do not match, but this shouldn't happen */
5637
5638     *surface = target->WineD3DSurface;
5639     IWineD3DSurface_AddRef(*surface);
5640     target->isRenderTarget = TRUE;
5641
5642     TRACE("Returning wineD3DSurface %p, it belongs to surface %p\n", *surface, d3d_surface);
5643
5644     return D3D_OK;
5645 }
5646
5647 static HRESULT STDMETHODCALLTYPE device_parent_CreateDepthStencilSurface(IWineD3DDeviceParent *iface,
5648         UINT width, UINT height, enum wined3d_format_id format, WINED3DMULTISAMPLE_TYPE multisample_type,
5649         DWORD multisample_quality, BOOL discard, IWineD3DSurface **surface)
5650 {
5651     struct IDirectDrawImpl *This = ddraw_from_device_parent(iface);
5652     IDirectDrawSurfaceImpl *ddraw_surface;
5653     DDSURFACEDESC2 ddsd;
5654     HRESULT hr;
5655
5656     TRACE("iface %p, width %u, height %u, format %#x, multisample_type %#x,\n"
5657             "\tmultisample_quality %u, discard %u, surface %p\n",
5658             iface, width, height, format, multisample_type, multisample_quality, discard, surface);
5659
5660     *surface = NULL;
5661
5662     /* Create a DirectDraw surface */
5663     memset(&ddsd, 0, sizeof(ddsd));
5664     ddsd.dwSize = sizeof(ddsd);
5665     ddsd.u4.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
5666     ddsd.dwFlags = DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
5667     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
5668     ddsd.dwHeight = height;
5669     ddsd.dwWidth = width;
5670     if (format)
5671     {
5672         PixelFormat_WineD3DtoDD(&ddsd.u4.ddpfPixelFormat, format);
5673     }
5674     else
5675     {
5676         ddsd.dwFlags ^= DDSD_PIXELFORMAT;
5677     }
5678
5679     This->depthstencil = TRUE;
5680     hr = IDirectDraw7_CreateSurface((IDirectDraw7 *)This, &ddsd, (IDirectDrawSurface7 **)&ddraw_surface, NULL);
5681     This->depthstencil = FALSE;
5682     if(FAILED(hr))
5683     {
5684         ERR(" (%p) Creating a DepthStencil Surface failed, result = %x\n", This, hr);
5685         return hr;
5686     }
5687
5688     *surface = ddraw_surface->WineD3DSurface;
5689     IWineD3DSurface_AddRef(*surface);
5690     IDirectDrawSurface7_Release((IDirectDrawSurface7 *)ddraw_surface);
5691
5692     return D3D_OK;
5693 }
5694
5695 static HRESULT STDMETHODCALLTYPE device_parent_CreateVolume(IWineD3DDeviceParent *iface,
5696         IUnknown *superior, UINT width, UINT height, UINT depth, enum wined3d_format_id format,
5697         WINED3DPOOL pool, DWORD usage, IWineD3DVolume **volume)
5698 {
5699     TRACE("iface %p, superior %p, width %u, height %u, depth %u, format %#x, pool %#x, usage %#x, volume %p\n",
5700                 iface, superior, width, height, depth, format, pool, usage, volume);
5701
5702     ERR("Not implemented!\n");
5703
5704     return E_NOTIMPL;
5705 }
5706
5707 static HRESULT STDMETHODCALLTYPE device_parent_CreateSwapChain(IWineD3DDeviceParent *iface,
5708         WINED3DPRESENT_PARAMETERS *present_parameters, IWineD3DSwapChain **swapchain)
5709 {
5710     struct IDirectDrawImpl *This = ddraw_from_device_parent(iface);
5711     IDirectDrawSurfaceImpl *iterator;
5712     IParentImpl *object;
5713     HRESULT hr;
5714
5715     TRACE("iface %p, present_parameters %p, swapchain %p\n", iface, present_parameters, swapchain);
5716
5717     object = HeapAlloc(GetProcessHeap(),  HEAP_ZERO_MEMORY, sizeof(IParentImpl));
5718     if (!object)
5719     {
5720         FIXME("Allocation of memory failed\n");
5721         *swapchain = NULL;
5722         return DDERR_OUTOFVIDEOMEMORY;
5723     }
5724
5725     ddraw_parent_init(object);
5726
5727     hr = IWineD3DDevice_CreateSwapChain(This->wineD3DDevice, present_parameters,
5728             This->ImplType, object, swapchain);
5729     if (FAILED(hr))
5730     {
5731         FIXME("(%p) CreateSwapChain failed, returning %#x\n", iface, hr);
5732         HeapFree(GetProcessHeap(), 0 , object);
5733         *swapchain = NULL;
5734         return hr;
5735     }
5736
5737     object->child = (IUnknown *)*swapchain;
5738     This->d3d_target->wineD3DSwapChain = *swapchain;
5739     iterator = This->d3d_target->complex_array[0];
5740     while (iterator)
5741     {
5742         iterator->wineD3DSwapChain = *swapchain;
5743         iterator = iterator->complex_array[0];
5744     }
5745
5746     return hr;
5747 }
5748
5749 static const IWineD3DDeviceParentVtbl ddraw_wined3d_device_parent_vtbl =
5750 {
5751     /* IUnknown methods */
5752     device_parent_QueryInterface,
5753     device_parent_AddRef,
5754     device_parent_Release,
5755     /* IWineD3DDeviceParent methods */
5756     device_parent_WineD3DDeviceCreated,
5757     device_parent_CreateSurface,
5758     device_parent_CreateRenderTarget,
5759     device_parent_CreateDepthStencilSurface,
5760     device_parent_CreateVolume,
5761     device_parent_CreateSwapChain,
5762 };
5763
5764 HRESULT ddraw_init(IDirectDrawImpl *ddraw, WINED3DDEVTYPE device_type)
5765 {
5766     HRESULT hr;
5767     HDC hDC;
5768
5769     ddraw->lpVtbl = &ddraw7_vtbl;
5770     ddraw->IDirectDraw_vtbl = &ddraw1_vtbl;
5771     ddraw->IDirectDraw2_vtbl = &ddraw2_vtbl;
5772     ddraw->IDirectDraw3_vtbl = &ddraw3_vtbl;
5773     ddraw->IDirectDraw4_vtbl = &ddraw4_vtbl;
5774     ddraw->IDirect3D_vtbl = &d3d1_vtbl;
5775     ddraw->IDirect3D2_vtbl = &d3d2_vtbl;
5776     ddraw->IDirect3D3_vtbl = &d3d3_vtbl;
5777     ddraw->IDirect3D7_vtbl = &d3d7_vtbl;
5778     ddraw->device_parent_vtbl = &ddraw_wined3d_device_parent_vtbl;
5779     ddraw->numIfaces = 1;
5780     ddraw->ref7 = 1;
5781
5782     /* See comments in IDirectDrawImpl_CreateNewSurface for a description of
5783      * this field. */
5784     ddraw->ImplType = DefaultSurfaceType;
5785
5786     /* Get the current screen settings. */
5787     hDC = GetDC(0);
5788     ddraw->orig_bpp = GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES);
5789     ReleaseDC(0, hDC);
5790     ddraw->orig_width = GetSystemMetrics(SM_CXSCREEN);
5791     ddraw->orig_height = GetSystemMetrics(SM_CYSCREEN);
5792
5793     if (!LoadWineD3D())
5794     {
5795         ERR("Failed to load wined3d - broken OpenGL setup?\n");
5796         return DDERR_NODIRECTDRAWSUPPORT;
5797     }
5798
5799     ddraw->wineD3D = pWineDirect3DCreate(7, (IUnknown *)ddraw);
5800     if (!ddraw->wineD3D)
5801     {
5802         WARN("Failed to create a wined3d object.\n");
5803         return E_OUTOFMEMORY;
5804     }
5805
5806     hr = IWineD3D_CreateDevice(ddraw->wineD3D, WINED3DADAPTER_DEFAULT, device_type, NULL, 0,
5807             (IWineD3DDeviceParent *)&ddraw->device_parent_vtbl, &ddraw->wineD3DDevice);
5808     if (FAILED(hr))
5809     {
5810         WARN("Failed to create a wined3d device, hr %#x.\n", hr);
5811         IWineD3D_Release(ddraw->wineD3D);
5812         return hr;
5813     }
5814
5815     /* Get the amount of video memory */
5816     ddraw->total_vidmem = IWineD3DDevice_GetAvailableTextureMem(ddraw->wineD3DDevice);
5817
5818     list_init(&ddraw->surface_list);
5819
5820     return DD_OK;
5821 }