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