dlls/d3drm/device.c

   1 /*
   2  * Implementation of IDirect3DRMDevice Interface
   3  *
   4  * Copyright 2011, 2012 André Hentschel
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include "d3drm_private.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(d3drm);
  27
  28 static inline struct d3drm_device *impl_from_IDirect3DRMDevice(IDirect3DRMDevice *iface)
  29 {
  30     return CONTAINING_RECORD(iface, struct d3drm_device, IDirect3DRMDevice_iface);
  31 }
  32
  33 static inline struct d3drm_device *impl_from_IDirect3DRMDevice2(IDirect3DRMDevice2 *iface)
  34 {
  35     return CONTAINING_RECORD(iface, struct d3drm_device, IDirect3DRMDevice2_iface);
  36 }
  37
  38 static inline struct d3drm_device *impl_from_IDirect3DRMDevice3(IDirect3DRMDevice3 *iface)
  39 {
  40     return CONTAINING_RECORD(iface, struct d3drm_device, IDirect3DRMDevice3_iface);
  41 }
  42
  43 void d3drm_device_destroy(struct d3drm_device *device)
  44 {
  45     d3drm_object_cleanup((IDirect3DRMObject *)&device->IDirect3DRMDevice_iface, &device->obj);
  46     if (device->device)
  47     {
  48         TRACE("Releasing attached ddraw interfaces.\n");
  49         IDirect3DDevice_Release(device->device);
  50     }
  51     if (device->render_target)
  52         IDirectDrawSurface_Release(device->render_target);
  53     if (device->primary_surface)
  54     {
  55         TRACE("Releasing primary surface and attached clipper.\n");
  56         IDirectDrawSurface_Release(device->primary_surface);
  57         IDirectDrawClipper_Release(device->clipper);
  58     }
  59     if (device->ddraw)
  60     {
  61         IDirectDraw_Release(device->ddraw);
  62         IDirect3DRM_Release(device->d3drm);
  63     }
  64     HeapFree(GetProcessHeap(), 0, device);
  65 }
  66
  67 static inline struct d3drm_device *impl_from_IDirect3DRMWinDevice(IDirect3DRMWinDevice *iface)
  68 {
  69     return CONTAINING_RECORD(iface, struct d3drm_device, IDirect3DRMWinDevice_iface);
  70 }
  71
  72 HRESULT d3drm_device_create_surfaces_from_clipper(struct d3drm_device *object, IDirectDraw *ddraw, IDirectDrawClipper *clipper, int width, int height, IDirectDrawSurface **surface)
  73 {
  74     DDSURFACEDESC surface_desc;
  75     IDirectDrawSurface *primary_surface, *render_target;
  76     HWND window;
  77     HRESULT hr;
  78
  79     hr = IDirectDrawClipper_GetHWnd(clipper, &window);
  80     if (FAILED(hr))
  81         return hr;
  82
  83     hr = IDirectDraw_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
  84     if (FAILED(hr))
  85         return hr;
  86
  87     memset(&surface_desc, 0, sizeof(surface_desc));
  88     surface_desc.dwSize = sizeof(surface_desc);
  89     surface_desc.dwFlags = DDSD_CAPS;
  90     surface_desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
  91     hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &primary_surface, NULL);
  92     if (FAILED(hr))
  93         return hr;
  94     hr = IDirectDrawSurface_SetClipper(primary_surface, clipper);
  95     if (FAILED(hr))
  96     {
  97         IDirectDrawSurface_Release(primary_surface);
  98         return hr;
  99     }
 100
 101     memset(&surface_desc, 0, sizeof(surface_desc));
 102     surface_desc.dwSize = sizeof(surface_desc);
 103     surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
 104     surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
 105     surface_desc.dwWidth = width;
 106     surface_desc.dwHeight = height;
 107
 108     hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &render_target, NULL);
 109     if (FAILED(hr))
 110     {
 111         IDirectDrawSurface_Release(primary_surface);
 112         return hr;
 113     }
 114
 115     object->primary_surface = primary_surface;
 116     object->clipper = clipper;
 117     IDirectDrawClipper_AddRef(clipper);
 118     *surface = render_target;
 119
 120     return D3DRM_OK;
 121 }
 122
 123 HRESULT d3drm_device_init(struct d3drm_device *device, UINT version, IDirectDraw *ddraw, IDirectDrawSurface *surface,
 124             BOOL create_z_surface)
 125 {
 126     DDSCAPS caps = { DDSCAPS_ZBUFFER };
 127     IDirectDrawSurface *ds = NULL;
 128     IDirect3DDevice *device1 = NULL;
 129     IDirect3DDevice2 *device2 = NULL;
 130     IDirect3D2 *d3d2 = NULL;
 131     DDSURFACEDESC desc, surface_desc;
 132     HRESULT hr;
 133
 134     device->ddraw = ddraw;
 135     IDirectDraw_AddRef(ddraw);
 136     IDirect3DRM_AddRef(device->d3drm);
 137     device->render_target = surface;
 138     IDirectDrawSurface_AddRef(surface);
 139
 140     desc.dwSize = sizeof(desc);
 141     hr = IDirectDrawSurface_GetSurfaceDesc(surface, &desc);
 142     if (FAILED(hr))
 143         return hr;
 144
 145     if (!(desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE))
 146         return DDERR_INVALIDCAPS;
 147
 148     hr = IDirectDrawSurface_GetAttachedSurface(surface, &caps, &ds);
 149     if (SUCCEEDED(hr))
 150     {
 151         create_z_surface = FALSE;
 152         IDirectDrawSurface_Release(ds);
 153         ds = NULL;
 154     }
 155
 156     if (create_z_surface)
 157     {
 158         memset(&surface_desc, 0, sizeof(surface_desc));
 159         surface_desc.dwSize = sizeof(surface_desc);
 160         surface_desc.dwFlags = DDSD_CAPS | DDSD_ZBUFFERBITDEPTH | DDSD_WIDTH | DDSD_HEIGHT;
 161         surface_desc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
 162         surface_desc.u2.dwZBufferBitDepth = 16;
 163         surface_desc.dwWidth = desc.dwWidth;
 164         surface_desc.dwHeight = desc.dwHeight;
 165         hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &ds, NULL);
 166         if (FAILED(hr))
 167             return hr;
 168
 169         hr = IDirectDrawSurface_AddAttachedSurface(surface, ds);
 170         IDirectDrawSurface_Release(ds);
 171         if (FAILED(hr))
 172             return hr;
 173     }
 174
 175     if (version == 1)
 176         hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirect3DRGBDevice, (void **)&device1);
 177     else
 178     {
 179         IDirectDraw_QueryInterface(ddraw, &IID_IDirect3D2, (void**)&d3d2);
 180         hr = IDirect3D2_CreateDevice(d3d2, &IID_IDirect3DRGBDevice, surface, &device2);
 181         IDirect3D2_Release(d3d2);
 182     }
 183     if (FAILED(hr))
 184     {
 185         IDirectDrawSurface_DeleteAttachedSurface(surface, 0, ds);
 186         return hr;
 187     }
 188
 189     if (version != 1)
 190     {
 191         hr = IDirect3DDevice2_QueryInterface(device2, &IID_IDirect3DDevice, (void**)&device1);
 192         IDirect3DDevice2_Release(device2);
 193         if (FAILED(hr))
 194         {
 195             IDirectDrawSurface_DeleteAttachedSurface(surface, 0, ds);
 196             return hr;
 197         }
 198     }
 199     device->device = device1;
 200     device->width = desc.dwWidth;
 201     device->height = desc.dwHeight;
 202
 203     return hr;
 204 }
 205
 206 static HRESULT d3drm_device_set_ddraw_device_d3d(struct d3drm_device *device, IDirect3D *d3d, IDirect3DDevice *d3d_device)
 207 {
 208     IDirectDraw *ddraw;
 209     IDirectDrawSurface *surface;
 210     IDirect3DDevice2 *d3d_device2 = NULL;
 211     DDSURFACEDESC desc;
 212     HRESULT hr;
 213
 214     /* AddRef these interfaces beforehand for the intentional leak on reinitialization. */
 215     if (FAILED(hr = IDirect3D_QueryInterface(d3d, &IID_IDirectDraw, (void **)&ddraw)))
 216         return hr;
 217     IDirect3DRM_AddRef(device->d3drm);
 218     IDirect3DDevice_AddRef(d3d_device);
 219
 220     /* Fetch render target and get width/height from there */
 221     if (FAILED(hr = IDirect3DDevice_QueryInterface(d3d_device, &IID_IDirectDrawSurface, (void **)&surface)))
 222     {
 223         if (FAILED(hr = IDirect3DDevice_QueryInterface(d3d_device, &IID_IDirect3DDevice2, (void **)&d3d_device2)))
 224             return hr;
 225         hr = IDirect3DDevice2_GetRenderTarget(d3d_device2, &surface);
 226         IDirect3DDevice2_Release(d3d_device2);
 227         if (FAILED(hr))
 228             return hr;
 229     }
 230
 231     if (device->ddraw)
 232     {
 233         if (d3d_device2)
 234             IDirectDrawSurface_Release(surface);
 235         return D3DRMERR_BADOBJECT;
 236     }
 237
 238     desc.dwSize = sizeof(desc);
 239     hr = IDirectDrawSurface_GetSurfaceDesc(surface, &desc);
 240     if (FAILED(hr))
 241     {
 242         IDirectDrawSurface_Release(surface);
 243         return hr;
 244     }
 245
 246     device->ddraw = ddraw;
 247     device->width = desc.dwWidth;
 248     device->height = desc.dwHeight;
 249     device->device = d3d_device;
 250     device->render_target = surface;
 251
 252     return hr;
 253 }
 254
 255 static HRESULT WINAPI d3drm_device3_QueryInterface(IDirect3DRMDevice3 *iface, REFIID riid, void **out)
 256 {
 257     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 258
 259     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 260
 261     if (IsEqualGUID(riid, &IID_IDirect3DRMDevice)
 262             || IsEqualGUID(riid, &IID_IDirect3DRMObject)
 263             || IsEqualGUID(riid, &IID_IUnknown))
 264     {
 265         *out = &device->IDirect3DRMDevice_iface;
 266     }
 267     else if (IsEqualGUID(riid, &IID_IDirect3DRMDevice2))
 268     {
 269         *out = &device->IDirect3DRMDevice2_iface;
 270     }
 271     else if (IsEqualGUID(riid, &IID_IDirect3DRMDevice3))
 272     {
 273         *out = &device->IDirect3DRMDevice3_iface;
 274     }
 275     else if (IsEqualGUID(riid, &IID_IDirect3DRMWinDevice))
 276     {
 277         *out = &device->IDirect3DRMWinDevice_iface;
 278     }
 279     else
 280     {
 281         *out = NULL;
 282         WARN("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(riid));
 283         return CLASS_E_CLASSNOTAVAILABLE;
 284     }
 285
 286     IUnknown_AddRef((IUnknown *)*out);
 287     return S_OK;
 288 }
 289
 290 static HRESULT WINAPI d3drm_device2_QueryInterface(IDirect3DRMDevice2 *iface, REFIID riid, void **out)
 291 {
 292     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 293
 294     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 295
 296     return d3drm_device3_QueryInterface(&device->IDirect3DRMDevice3_iface, riid, out);
 297 }
 298
 299 static HRESULT WINAPI d3drm_device1_QueryInterface(IDirect3DRMDevice *iface, REFIID riid, void **out)
 300 {
 301     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 302
 303     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 304
 305     return d3drm_device3_QueryInterface(&device->IDirect3DRMDevice3_iface, riid, out);
 306 }
 307
 308 static ULONG WINAPI d3drm_device3_AddRef(IDirect3DRMDevice3 *iface)
 309 {
 310     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 311     ULONG refcount = InterlockedIncrement(&device->obj.ref);
 312
 313     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 314
 315     return refcount;
 316 }
 317
 318 static ULONG WINAPI d3drm_device2_AddRef(IDirect3DRMDevice2 *iface)
 319 {
 320     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 321
 322     TRACE("iface %p.\n", iface);
 323
 324     return d3drm_device3_AddRef(&device->IDirect3DRMDevice3_iface);
 325 }
 326
 327 static ULONG WINAPI d3drm_device1_AddRef(IDirect3DRMDevice *iface)
 328 {
 329     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 330
 331     TRACE("iface %p.\n", iface);
 332
 333     return d3drm_device3_AddRef(&device->IDirect3DRMDevice3_iface);
 334 }
 335
 336 static ULONG WINAPI d3drm_device3_Release(IDirect3DRMDevice3 *iface)
 337 {
 338     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 339     ULONG refcount = InterlockedDecrement(&device->obj.ref);
 340
 341     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 342
 343     if (!refcount)
 344         d3drm_device_destroy(device);
 345
 346     return refcount;
 347 }
 348
 349 static ULONG WINAPI d3drm_device2_Release(IDirect3DRMDevice2 *iface)
 350 {
 351     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 352
 353     TRACE("iface %p.\n", iface);
 354
 355     return d3drm_device3_Release(&device->IDirect3DRMDevice3_iface);
 356 }
 357
 358 static ULONG WINAPI d3drm_device1_Release(IDirect3DRMDevice *iface)
 359 {
 360     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 361
 362     TRACE("iface %p.\n", iface);
 363
 364     return d3drm_device3_Release(&device->IDirect3DRMDevice3_iface);
 365 }
 366
 367 static HRESULT WINAPI d3drm_device3_Clone(IDirect3DRMDevice3 *iface,
 368         IUnknown *outer, REFIID iid, void **out)
 369 {
 370     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
 371
 372     return E_NOTIMPL;
 373 }
 374
 375 static HRESULT WINAPI d3drm_device2_Clone(IDirect3DRMDevice2 *iface,
 376         IUnknown *outer, REFIID iid, void **out)
 377 {
 378     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 379
 380     TRACE("iface %p, outer %p, iid %s, out %p\n", iface, outer, debugstr_guid(iid), out);
 381
 382     return d3drm_device3_Clone(&device->IDirect3DRMDevice3_iface, outer, iid, out);
 383 }
 384
 385 static HRESULT WINAPI d3drm_device1_Clone(IDirect3DRMDevice *iface,
 386         IUnknown *outer, REFIID iid, void **out)
 387 {
 388     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 389
 390     TRACE("iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid(iid), out);
 391
 392     return d3drm_device3_Clone(&device->IDirect3DRMDevice3_iface, outer, iid, out);
 393 }
 394
 395 static HRESULT WINAPI d3drm_device3_AddDestroyCallback(IDirect3DRMDevice3 *iface,
 396         D3DRMOBJECTCALLBACK cb, void *ctx)
 397 {
 398     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 399
 400     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 401
 402     return d3drm_object_add_destroy_callback(&device->obj, cb, ctx);
 403 }
 404
 405 static HRESULT WINAPI d3drm_device2_AddDestroyCallback(IDirect3DRMDevice2 *iface,
 406         D3DRMOBJECTCALLBACK cb, void *ctx)
 407 {
 408     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 409
 410     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 411
 412     return d3drm_device3_AddDestroyCallback(&device->IDirect3DRMDevice3_iface, cb, ctx);
 413 }
 414
 415 static HRESULT WINAPI d3drm_device1_AddDestroyCallback(IDirect3DRMDevice *iface,
 416         D3DRMOBJECTCALLBACK cb, void *ctx)
 417 {
 418     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 419
 420     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 421
 422     return d3drm_device3_AddDestroyCallback(&device->IDirect3DRMDevice3_iface, cb, ctx);
 423 }
 424
 425 static HRESULT WINAPI d3drm_device3_DeleteDestroyCallback(IDirect3DRMDevice3 *iface,
 426         D3DRMOBJECTCALLBACK cb, void *ctx)
 427 {
 428     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 429
 430     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 431
 432     return d3drm_object_delete_destroy_callback(&device->obj, cb, ctx);
 433 }
 434
 435 static HRESULT WINAPI d3drm_device2_DeleteDestroyCallback(IDirect3DRMDevice2 *iface,
 436         D3DRMOBJECTCALLBACK cb, void *ctx)
 437 {
 438     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 439
 440     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 441
 442     return d3drm_device3_DeleteDestroyCallback(&device->IDirect3DRMDevice3_iface, cb, ctx);
 443 }
 444
 445 static HRESULT WINAPI d3drm_device1_DeleteDestroyCallback(IDirect3DRMDevice *iface,
 446         D3DRMOBJECTCALLBACK cb, void *ctx)
 447 {
 448     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 449
 450     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 451
 452     return d3drm_device3_DeleteDestroyCallback(&device->IDirect3DRMDevice3_iface, cb, ctx);
 453 }
 454
 455 static HRESULT WINAPI d3drm_device3_SetAppData(IDirect3DRMDevice3 *iface, DWORD data)
 456 {
 457     FIXME("iface %p, data %#x stub!\n", iface, data);
 458
 459     return E_NOTIMPL;
 460 }
 461
 462 static HRESULT WINAPI d3drm_device2_SetAppData(IDirect3DRMDevice2 *iface, DWORD data)
 463 {
 464     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 465
 466     TRACE("iface %p, data %#x.\n", iface, data);
 467
 468     return d3drm_device3_SetAppData(&device->IDirect3DRMDevice3_iface, data);
 469 }
 470
 471 static HRESULT WINAPI d3drm_device1_SetAppData(IDirect3DRMDevice *iface, DWORD data)
 472 {
 473     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 474
 475     TRACE("iface %p, data %#x.\n", iface, data);
 476
 477     return d3drm_device3_SetAppData(&device->IDirect3DRMDevice3_iface, data);
 478 }
 479
 480 static DWORD WINAPI d3drm_device3_GetAppData(IDirect3DRMDevice3 *iface)
 481 {
 482     FIXME("iface %p stub!\n", iface);
 483
 484     return 0;
 485 }
 486
 487 static DWORD WINAPI d3drm_device2_GetAppData(IDirect3DRMDevice2 *iface)
 488 {
 489     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 490
 491     TRACE("iface %p.\n", iface);
 492
 493     return d3drm_device3_GetAppData(&device->IDirect3DRMDevice3_iface);
 494 }
 495
 496 static DWORD WINAPI d3drm_device1_GetAppData(IDirect3DRMDevice *iface)
 497 {
 498     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 499
 500     TRACE("iface %p.\n", iface);
 501
 502     return d3drm_device3_GetAppData(&device->IDirect3DRMDevice3_iface);
 503 }
 504
 505 static HRESULT WINAPI d3drm_device3_SetName(IDirect3DRMDevice3 *iface, const char *name)
 506 {
 507     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
 508
 509     return E_NOTIMPL;
 510 }
 511
 512 static HRESULT WINAPI d3drm_device2_SetName(IDirect3DRMDevice2 *iface, const char *name)
 513 {
 514     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 515
 516     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
 517
 518     return d3drm_device3_SetName(&device->IDirect3DRMDevice3_iface, name);
 519 }
 520
 521 static HRESULT WINAPI d3drm_device1_SetName(IDirect3DRMDevice *iface, const char *name)
 522 {
 523     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 524
 525     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
 526
 527     return d3drm_device3_SetName(&device->IDirect3DRMDevice3_iface, name);
 528 }
 529
 530 static HRESULT WINAPI d3drm_device3_GetName(IDirect3DRMDevice3 *iface, DWORD *size, char *name)
 531 {
 532     FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
 533
 534     return E_NOTIMPL;
 535 }
 536
 537 static HRESULT WINAPI d3drm_device2_GetName(IDirect3DRMDevice2 *iface, DWORD *size, char *name)
 538 {
 539     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 540
 541     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 542
 543     return d3drm_device3_GetName(&device->IDirect3DRMDevice3_iface, size, name);
 544 }
 545
 546 static HRESULT WINAPI d3drm_device1_GetName(IDirect3DRMDevice *iface, DWORD *size, char *name)
 547 {
 548     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 549
 550     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 551
 552     return d3drm_device3_GetName(&device->IDirect3DRMDevice3_iface, size, name);
 553 }
 554
 555 static HRESULT WINAPI d3drm_device3_GetClassName(IDirect3DRMDevice3 *iface, DWORD *size, char *name)
 556 {
 557     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 558
 559     if (!size || *size < strlen("Device") || !name)
 560         return E_INVALIDARG;
 561
 562     strcpy(name, "Device");
 563     *size = sizeof("Device");
 564
 565     return D3DRM_OK;
 566 }
 567
 568 static HRESULT WINAPI d3drm_device2_GetClassName(IDirect3DRMDevice2 *iface, DWORD *size, char *name)
 569 {
 570     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 571
 572     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 573
 574     return d3drm_device3_GetClassName(&device->IDirect3DRMDevice3_iface, size, name);
 575 }
 576
 577 static HRESULT WINAPI d3drm_device1_GetClassName(IDirect3DRMDevice *iface, DWORD *size, char *name)
 578 {
 579     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 580
 581     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 582
 583     return d3drm_device3_GetClassName(&device->IDirect3DRMDevice3_iface, size, name);
 584 }
 585
 586 static HRESULT WINAPI d3drm_device3_Init(IDirect3DRMDevice3 *iface, ULONG width, ULONG height)
 587 {
 588     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 589
 590     FIXME("iface %p, width %u, height %u stub!\n", iface, width, height);
 591
 592     device->height = height;
 593     device->width = width;
 594
 595     return D3DRM_OK;
 596 }
 597
 598 static HRESULT WINAPI d3drm_device2_Init(IDirect3DRMDevice2 *iface, ULONG width, ULONG height)
 599 {
 600     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 601
 602     TRACE("iface %p, width %u, height %u.\n", iface, width, height);
 603
 604     return d3drm_device3_Init(&device->IDirect3DRMDevice3_iface, width, height);
 605 }
 606
 607 static HRESULT WINAPI d3drm_device1_Init(IDirect3DRMDevice *iface, ULONG width, ULONG height)
 608 {
 609     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 610
 611     TRACE("iface %p, width %u, height %u.\n", iface, width, height);
 612
 613     return d3drm_device3_Init(&device->IDirect3DRMDevice3_iface, width, height);
 614 }
 615
 616 static HRESULT WINAPI d3drm_device3_InitFromD3D(IDirect3DRMDevice3 *iface,
 617         IDirect3D *d3d, IDirect3DDevice *d3d_device)
 618 {
 619     FIXME("iface %p, d3d %p, d3d_device %p stub!\n", iface, d3d, d3d_device);
 620
 621     if (!d3d || !d3d_device)
 622         return D3DRMERR_BADVALUE;
 623
 624     return E_NOINTERFACE;
 625 }
 626
 627 static HRESULT WINAPI d3drm_device2_InitFromD3D(IDirect3DRMDevice2 *iface,
 628         IDirect3D *d3d, IDirect3DDevice *d3d_device)
 629 {
 630     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 631
 632     TRACE("iface %p, d3d %p, d3d_device %p.\n", iface, d3d, d3d_device);
 633
 634     return d3drm_device3_InitFromD3D(&device->IDirect3DRMDevice3_iface, d3d, d3d_device);
 635 }
 636
 637 static HRESULT WINAPI d3drm_device1_InitFromD3D(IDirect3DRMDevice *iface,
 638         IDirect3D *d3d, IDirect3DDevice *d3d_device)
 639 {
 640     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 641
 642     TRACE("iface %p, d3d %p, d3d_device %p.\n", iface, d3d, d3d_device);
 643
 644     if (!d3d || !d3d_device)
 645         return D3DRMERR_BADVALUE;
 646
 647     return d3drm_device_set_ddraw_device_d3d(device, d3d, d3d_device);
 648 }
 649
 650 static HRESULT WINAPI d3drm_device3_InitFromClipper(IDirect3DRMDevice3 *iface,
 651         IDirectDrawClipper *clipper, GUID *guid, int width, int height)
 652 {
 653     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 654
 655     FIXME("iface %p, clipper %p, guid %s, width %d, height %d stub!\n",
 656             iface, clipper, debugstr_guid(guid), width, height);
 657
 658     device->height = height;
 659     device->width = width;
 660
 661     return D3DRM_OK;
 662 }
 663
 664 static HRESULT WINAPI d3drm_device2_InitFromClipper(IDirect3DRMDevice2 *iface,
 665         IDirectDrawClipper *clipper, GUID *guid, int width, int height)
 666 {
 667     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 668
 669     TRACE("iface %p, clipper %p, guid %s, width %d, height %d.\n",
 670             iface, clipper, debugstr_guid(guid), width, height);
 671
 672     return d3drm_device3_InitFromClipper(&device->IDirect3DRMDevice3_iface,
 673             clipper, guid, width, height);
 674 }
 675
 676 static HRESULT WINAPI d3drm_device1_InitFromClipper(IDirect3DRMDevice *iface,
 677         IDirectDrawClipper *clipper, GUID *guid, int width, int height)
 678 {
 679     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 680
 681     TRACE("iface %p, clipper %p, guid %s, width %d, height %d.\n",
 682         iface, clipper, debugstr_guid(guid), width, height);
 683
 684     return d3drm_device3_InitFromClipper(&device->IDirect3DRMDevice3_iface,
 685         clipper, guid, width, height);
 686 }
 687
 688 static HRESULT WINAPI d3drm_device3_Update(IDirect3DRMDevice3 *iface)
 689 {
 690     FIXME("iface %p stub!\n", iface);
 691
 692     return D3DRM_OK;
 693 }
 694
 695 static HRESULT WINAPI d3drm_device2_Update(IDirect3DRMDevice2 *iface)
 696 {
 697     FIXME("iface %p stub!\n", iface);
 698
 699     return D3DRM_OK;
 700 }
 701
 702 static HRESULT WINAPI d3drm_device1_Update(IDirect3DRMDevice *iface)
 703 {
 704     FIXME("iface %p stub!\n", iface);
 705
 706     return D3DRM_OK;
 707 }
 708
 709 static HRESULT WINAPI d3drm_device3_AddUpdateCallback(IDirect3DRMDevice3 *iface,
 710         D3DRMUPDATECALLBACK cb, void *ctx)
 711 {
 712     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 713
 714     return E_NOTIMPL;
 715 }
 716
 717 static HRESULT WINAPI d3drm_device2_AddUpdateCallback(IDirect3DRMDevice2 *iface,
 718         D3DRMUPDATECALLBACK cb, void *ctx)
 719 {
 720     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 721
 722     return E_NOTIMPL;
 723 }
 724
 725 static HRESULT WINAPI d3drm_device1_AddUpdateCallback(IDirect3DRMDevice *iface,
 726         D3DRMUPDATECALLBACK cb, void *ctx)
 727 {
 728     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 729
 730     return E_NOTIMPL;
 731 }
 732
 733 static HRESULT WINAPI d3drm_device3_DeleteUpdateCallback(IDirect3DRMDevice3 *iface,
 734         D3DRMUPDATECALLBACK cb, void *ctx)
 735 {
 736     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 737
 738     return E_NOTIMPL;
 739 }
 740
 741 static HRESULT WINAPI d3drm_device2_DeleteUpdateCallback(IDirect3DRMDevice2 *iface,
 742         D3DRMUPDATECALLBACK cb, void *ctx)
 743 {
 744     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 745
 746     return E_NOTIMPL;
 747 }
 748
 749 static HRESULT WINAPI d3drm_device1_DeleteUpdateCallback(IDirect3DRMDevice *iface,
 750         D3DRMUPDATECALLBACK cb, void *ctx)
 751 {
 752     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 753
 754     return E_NOTIMPL;
 755 }
 756
 757 static HRESULT WINAPI d3drm_device3_SetBufferCount(IDirect3DRMDevice3 *iface, DWORD count)
 758 {
 759     FIXME("iface %p, count %u stub!\n", iface, count);
 760
 761     return E_NOTIMPL;
 762 }
 763
 764 static HRESULT WINAPI d3drm_device2_SetBufferCount(IDirect3DRMDevice2 *iface, DWORD count)
 765 {
 766     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 767
 768     TRACE("iface %p, count %u.\n", iface, count);
 769
 770     return d3drm_device3_SetBufferCount(&device->IDirect3DRMDevice3_iface, count);
 771 }
 772
 773 static HRESULT WINAPI d3drm_device1_SetBufferCount(IDirect3DRMDevice *iface, DWORD count)
 774 {
 775     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 776
 777     TRACE("iface %p, count %u.\n", iface, count);
 778
 779     return d3drm_device3_SetBufferCount(&device->IDirect3DRMDevice3_iface, count);
 780 }
 781
 782 static DWORD WINAPI d3drm_device3_GetBufferCount(IDirect3DRMDevice3 *iface)
 783 {
 784     FIXME("iface %p stub!\n", iface);
 785
 786     return E_NOTIMPL;
 787 }
 788
 789 static DWORD WINAPI d3drm_device2_GetBufferCount(IDirect3DRMDevice2 *iface)
 790 {
 791     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 792
 793     TRACE("iface %p.\n", iface);
 794
 795     return d3drm_device3_GetBufferCount(&device->IDirect3DRMDevice3_iface);
 796 }
 797
 798 static DWORD WINAPI d3drm_device1_GetBufferCount(IDirect3DRMDevice *iface)
 799 {
 800     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 801
 802     TRACE("iface %p.\n", iface);
 803
 804     return d3drm_device3_GetBufferCount(&device->IDirect3DRMDevice3_iface);
 805 }
 806
 807 static HRESULT WINAPI d3drm_device3_SetDither(IDirect3DRMDevice3 *iface, BOOL enable)
 808 {
 809     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 810
 811     TRACE("iface %p, enable %#x.\n", iface, enable);
 812
 813     device->dither = enable;
 814
 815     return D3DRM_OK;
 816 }
 817
 818 static HRESULT WINAPI d3drm_device2_SetDither(IDirect3DRMDevice2 *iface, BOOL enable)
 819 {
 820     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 821
 822     TRACE("iface %p, enabled %#x.\n", iface, enable);
 823
 824     return d3drm_device3_SetDither(&device->IDirect3DRMDevice3_iface, enable);
 825 }
 826
 827 static HRESULT WINAPI d3drm_device1_SetDither(IDirect3DRMDevice *iface, BOOL enable)
 828 {
 829     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 830
 831     TRACE("iface %p, enabled %#x.\n", iface, enable);
 832
 833     return d3drm_device3_SetDither(&device->IDirect3DRMDevice3_iface, enable);
 834 }
 835
 836 static HRESULT WINAPI d3drm_device3_SetShades(IDirect3DRMDevice3 *iface, DWORD count)
 837 {
 838     FIXME("iface %p, count %u stub!\n", iface, count);
 839
 840     return E_NOTIMPL;
 841 }
 842
 843 static HRESULT WINAPI d3drm_device2_SetShades(IDirect3DRMDevice2 *iface, DWORD count)
 844 {
 845     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 846
 847     TRACE("iface %p, count %u.\n", iface, count);
 848
 849     return d3drm_device3_SetShades(&device->IDirect3DRMDevice3_iface, count);
 850 }
 851
 852 static HRESULT WINAPI d3drm_device1_SetShades(IDirect3DRMDevice *iface, DWORD count)
 853 {
 854     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 855
 856     TRACE("iface %p, count %u.\n", iface, count);
 857
 858     return d3drm_device3_SetShades(&device->IDirect3DRMDevice3_iface, count);
 859 }
 860
 861 static HRESULT WINAPI d3drm_device3_SetQuality(IDirect3DRMDevice3 *iface, D3DRMRENDERQUALITY quality)
 862 {
 863     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 864
 865     TRACE("iface %p, quality %u.\n", iface, quality);
 866
 867     device->quality = quality;
 868
 869     return D3DRM_OK;
 870 }
 871
 872 static HRESULT WINAPI d3drm_device2_SetQuality(IDirect3DRMDevice2 *iface, D3DRMRENDERQUALITY quality)
 873 {
 874     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 875
 876     TRACE("iface %p, quality %u.\n", iface, quality);
 877
 878     return d3drm_device3_SetQuality(&device->IDirect3DRMDevice3_iface, quality);
 879 }
 880
 881 static HRESULT WINAPI d3drm_device1_SetQuality(IDirect3DRMDevice *iface, D3DRMRENDERQUALITY quality)
 882 {
 883     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 884
 885     TRACE("iface %p, quality %u.\n", iface, quality);
 886
 887     return d3drm_device3_SetQuality(&device->IDirect3DRMDevice3_iface, quality);
 888 }
 889
 890 static HRESULT WINAPI d3drm_device3_SetTextureQuality(IDirect3DRMDevice3 *iface, D3DRMTEXTUREQUALITY quality)
 891 {
 892     FIXME("iface %p, quality %u stub!\n", iface, quality);
 893
 894     return E_NOTIMPL;
 895 }
 896
 897 static HRESULT WINAPI d3drm_device2_SetTextureQuality(IDirect3DRMDevice2 *iface, D3DRMTEXTUREQUALITY quality)
 898 {
 899     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 900
 901     TRACE("iface %p, quality %u.\n", iface, quality);
 902
 903     return d3drm_device3_SetTextureQuality(&device->IDirect3DRMDevice3_iface, quality);
 904 }
 905
 906 static HRESULT WINAPI d3drm_device1_SetTextureQuality(IDirect3DRMDevice *iface, D3DRMTEXTUREQUALITY quality)
 907 {
 908     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 909
 910     TRACE("iface %p, quality %u.\n", iface, quality);
 911
 912     return d3drm_device3_SetTextureQuality(&device->IDirect3DRMDevice3_iface, quality);
 913 }
 914
 915 static HRESULT WINAPI d3drm_device3_GetViewports(IDirect3DRMDevice3 *iface, IDirect3DRMViewportArray **array)
 916 {
 917     FIXME("iface %p, array %p stub!\n", iface, array);
 918
 919     return E_NOTIMPL;
 920 }
 921
 922 static HRESULT WINAPI d3drm_device2_GetViewports(IDirect3DRMDevice2 *iface, IDirect3DRMViewportArray **array)
 923 {
 924     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 925
 926     TRACE("iface %p, array %p.\n", iface, array);
 927
 928     return d3drm_device3_GetViewports(&device->IDirect3DRMDevice3_iface, array);
 929 }
 930
 931 static HRESULT WINAPI d3drm_device1_GetViewports(IDirect3DRMDevice *iface, IDirect3DRMViewportArray **array)
 932 {
 933     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 934
 935     TRACE("iface %p, array %p.\n", iface, array);
 936
 937     return d3drm_device3_GetViewports(&device->IDirect3DRMDevice3_iface, array);
 938 }
 939
 940 static BOOL WINAPI d3drm_device3_GetDither(IDirect3DRMDevice3 *iface)
 941 {
 942     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 943
 944     TRACE("iface %p.\n", iface);
 945
 946     return device->dither;
 947 }
 948
 949 static BOOL WINAPI d3drm_device2_GetDither(IDirect3DRMDevice2 *iface)
 950 {
 951     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 952
 953     TRACE("iface %p.\n", iface);
 954
 955     return d3drm_device3_GetDither(&device->IDirect3DRMDevice3_iface);
 956 }
 957
 958 static BOOL WINAPI d3drm_device1_GetDither(IDirect3DRMDevice *iface)
 959 {
 960     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 961
 962     TRACE("iface %p.\n", iface);
 963
 964     return d3drm_device3_GetDither(&device->IDirect3DRMDevice3_iface);
 965 }
 966
 967 static DWORD WINAPI d3drm_device3_GetShades(IDirect3DRMDevice3 *iface)
 968 {
 969     FIXME("iface %p stub!\n", iface);
 970
 971     return E_NOTIMPL;
 972 }
 973
 974 static DWORD WINAPI d3drm_device2_GetShades(IDirect3DRMDevice2 *iface)
 975 {
 976     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 977
 978     TRACE("iface %p.\n", iface);
 979
 980     return d3drm_device3_GetShades(&device->IDirect3DRMDevice3_iface);
 981 }
 982
 983 static DWORD WINAPI d3drm_device1_GetShades(IDirect3DRMDevice *iface)
 984 {
 985     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
 986
 987     TRACE("iface %p.\n", iface);
 988
 989     return d3drm_device3_GetShades(&device->IDirect3DRMDevice3_iface);
 990 }
 991
 992 static DWORD WINAPI d3drm_device3_GetHeight(IDirect3DRMDevice3 *iface)
 993 {
 994     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 995
 996     TRACE("iface %p.\n", iface);
 997
 998     return device->height;
 999 }
1000
1001 static DWORD WINAPI d3drm_device2_GetHeight(IDirect3DRMDevice2 *iface)
1002 {
1003     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1004
1005     TRACE("iface %p.\n", iface);
1006
1007     return d3drm_device3_GetHeight(&device->IDirect3DRMDevice3_iface);
1008 }
1009
1010 static DWORD WINAPI d3drm_device1_GetHeight(IDirect3DRMDevice *iface)
1011 {
1012     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
1013
1014     TRACE("iface %p.\n", iface);
1015
1016     return d3drm_device3_GetHeight(&device->IDirect3DRMDevice3_iface);
1017 }
1018
1019 static DWORD WINAPI d3drm_device3_GetWidth(IDirect3DRMDevice3 *iface)
1020 {
1021     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
1022
1023     TRACE("iface %p.\n", iface);
1024
1025     return device->width;
1026 }
1027
1028 static DWORD WINAPI d3drm_device2_GetWidth(IDirect3DRMDevice2 *iface)
1029 {
1030     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1031
1032     TRACE("iface %p.\n", iface);
1033
1034     return d3drm_device3_GetWidth(&device->IDirect3DRMDevice3_iface);
1035 }
1036
1037 static DWORD WINAPI d3drm_device1_GetWidth(IDirect3DRMDevice *iface)
1038 {
1039     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
1040
1041     TRACE("iface %p.\n", iface);
1042
1043     return d3drm_device3_GetWidth(&device->IDirect3DRMDevice3_iface);
1044 }
1045
1046 static DWORD WINAPI d3drm_device3_GetTrianglesDrawn(IDirect3DRMDevice3 *iface)
1047 {
1048     FIXME("iface %p stub!\n", iface);
1049
1050     return E_NOTIMPL;
1051 }
1052
1053 static DWORD WINAPI d3drm_device2_GetTrianglesDrawn(IDirect3DRMDevice2 *iface)
1054 {
1055     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1056
1057     TRACE("iface %p.\n", iface);
1058
1059     return d3drm_device3_GetTrianglesDrawn(&device->IDirect3DRMDevice3_iface);
1060 }
1061
1062 static DWORD WINAPI d3drm_device1_GetTrianglesDrawn(IDirect3DRMDevice *iface)
1063 {
1064     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
1065
1066     TRACE("iface %p.\n", iface);
1067
1068     return d3drm_device3_GetTrianglesDrawn(&device->IDirect3DRMDevice3_iface);
1069 }
1070
1071 static DWORD WINAPI d3drm_device3_GetWireframeOptions(IDirect3DRMDevice3 *iface)
1072 {
1073     FIXME("iface %p stub!\n", iface);
1074
1075     return E_NOTIMPL;
1076 }
1077
1078 static DWORD WINAPI d3drm_device2_GetWireframeOptions(IDirect3DRMDevice2 *iface)
1079 {
1080     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1081
1082     TRACE("iface %p.\n", iface);
1083
1084     return d3drm_device3_GetWireframeOptions(&device->IDirect3DRMDevice3_iface);
1085 }
1086
1087 static DWORD WINAPI d3drm_device1_GetWireframeOptions(IDirect3DRMDevice *iface)
1088 {
1089     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
1090
1091     TRACE("iface %p.\n", iface);
1092
1093     return d3drm_device3_GetWireframeOptions(&device->IDirect3DRMDevice3_iface);
1094 }
1095
1096 static D3DRMRENDERQUALITY WINAPI d3drm_device3_GetQuality(IDirect3DRMDevice3 *iface)
1097 {
1098     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
1099
1100     TRACE("iface %p.\n", iface);
1101
1102     return device->quality;
1103 }
1104
1105 static D3DRMRENDERQUALITY WINAPI d3drm_device2_GetQuality(IDirect3DRMDevice2 *iface)
1106 {
1107     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1108
1109     TRACE("iface %p.\n", iface);
1110
1111     return d3drm_device3_GetQuality(&device->IDirect3DRMDevice3_iface);
1112 }
1113
1114 static D3DRMRENDERQUALITY WINAPI d3drm_device1_GetQuality(IDirect3DRMDevice *iface)
1115 {
1116     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
1117
1118     TRACE("iface %p.\n", iface);
1119
1120     return d3drm_device3_GetQuality(&device->IDirect3DRMDevice3_iface);
1121 }
1122
1123 static D3DCOLORMODEL WINAPI d3drm_device3_GetColorModel(IDirect3DRMDevice3 *iface)
1124 {
1125     FIXME("iface %p stub!\n", iface);
1126
1127     return E_NOTIMPL;
1128 }
1129
1130 static D3DCOLORMODEL WINAPI d3drm_device2_GetColorModel(IDirect3DRMDevice2 *iface)
1131 {
1132     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1133
1134     TRACE("iface %p.\n", iface);
1135
1136     return d3drm_device3_GetColorModel(&device->IDirect3DRMDevice3_iface);
1137 }
1138
1139 static D3DCOLORMODEL WINAPI d3drm_device1_GetColorModel(IDirect3DRMDevice *iface)
1140 {
1141     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
1142
1143     TRACE("iface %p.\n", iface);
1144
1145     return d3drm_device3_GetColorModel(&device->IDirect3DRMDevice3_iface);
1146 }
1147
1148 static D3DRMTEXTUREQUALITY WINAPI d3drm_device3_GetTextureQuality(IDirect3DRMDevice3 *iface)
1149 {
1150     FIXME("iface %p stub!\n", iface);
1151
1152     return E_NOTIMPL;
1153 }
1154
1155 static D3DRMTEXTUREQUALITY WINAPI d3drm_device2_GetTextureQuality(IDirect3DRMDevice2 *iface)
1156 {
1157     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1158
1159     TRACE("iface %p.\n", iface);
1160
1161     return d3drm_device3_GetTextureQuality(&device->IDirect3DRMDevice3_iface);
1162 }
1163
1164 static D3DRMTEXTUREQUALITY WINAPI d3drm_device1_GetTextureQuality(IDirect3DRMDevice *iface)
1165 {
1166     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
1167
1168     TRACE("iface %p.\n", iface);
1169
1170     return d3drm_device3_GetTextureQuality(&device->IDirect3DRMDevice3_iface);
1171 }
1172
1173 static HRESULT WINAPI d3drm_device3_GetDirect3DDevice(IDirect3DRMDevice3 *iface, IDirect3DDevice **d3d_device)
1174 {
1175     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
1176     TRACE("iface %p, d3d_device %p!\n", iface, d3d_device);
1177
1178     *d3d_device = device->device;
1179     IDirect3DDevice_AddRef(*d3d_device);
1180
1181     return D3DRM_OK;
1182 }
1183
1184 static HRESULT WINAPI d3drm_device2_GetDirect3DDevice(IDirect3DRMDevice2 *iface, IDirect3DDevice **d3d_device)
1185 {
1186     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1187
1188     TRACE("iface %p, d3d_device %p.\n", iface, d3d_device);
1189
1190     return d3drm_device3_GetDirect3DDevice(&device->IDirect3DRMDevice3_iface, d3d_device);
1191 }
1192
1193 static HRESULT WINAPI d3drm_device1_GetDirect3DDevice(IDirect3DRMDevice *iface, IDirect3DDevice **d3d_device)
1194 {
1195     struct d3drm_device *device = impl_from_IDirect3DRMDevice(iface);
1196
1197     TRACE("iface %p, d3d_device %p.\n", iface, d3d_device);
1198
1199     return d3drm_device3_GetDirect3DDevice(&device->IDirect3DRMDevice3_iface, d3d_device);
1200 }
1201
1202 static HRESULT WINAPI d3drm_device3_InitFromD3D2(IDirect3DRMDevice3 *iface,
1203         IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device)
1204 {
1205     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
1206     IDirect3D *d3d1;
1207     IDirect3DDevice *d3d_device1;
1208     HRESULT hr;
1209
1210     TRACE("iface %p, d3d %p, d3d_device %p.\n", iface, d3d, d3d_device);
1211
1212     if (!d3d || !d3d_device)
1213         return D3DRMERR_BADVALUE;
1214
1215     if (FAILED(hr = IDirect3D2_QueryInterface(d3d, &IID_IDirect3D, (void **)&d3d1)))
1216         return hr;
1217     if (FAILED(hr = IDirect3DDevice2_QueryInterface(d3d_device, &IID_IDirect3DDevice, (void **)&d3d_device1)))
1218     {
1219         IDirect3D_Release(d3d1);
1220         return hr;
1221     }
1222
1223     hr = d3drm_device_set_ddraw_device_d3d(device, d3d1, d3d_device1);
1224     IDirect3D_Release(d3d1);
1225     IDirect3DDevice_Release(d3d_device1);
1226
1227     return hr;
1228 }
1229
1230 static HRESULT WINAPI d3drm_device2_InitFromD3D2(IDirect3DRMDevice2 *iface,
1231         IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device)
1232 {
1233     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1234
1235     TRACE("iface %p, d3d %p, d3d_device %p.\n", iface, d3d, d3d_device);
1236
1237     return d3drm_device3_InitFromD3D2(&device->IDirect3DRMDevice3_iface, d3d, d3d_device);
1238 }
1239
1240 static HRESULT WINAPI d3drm_device3_InitFromSurface(IDirect3DRMDevice3 *iface,
1241         GUID *guid, IDirectDraw *ddraw, IDirectDrawSurface *backbuffer)
1242 {
1243     FIXME("iface %p, guid %s, ddraw %p, backbuffer %p stub!\n",
1244             iface, debugstr_guid(guid), ddraw, backbuffer);
1245
1246     return E_NOTIMPL;
1247 }
1248
1249 static HRESULT WINAPI d3drm_device2_InitFromSurface(IDirect3DRMDevice2 *iface,
1250         GUID *guid, IDirectDraw *ddraw, IDirectDrawSurface *backbuffer)
1251 {
1252     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1253
1254     TRACE("iface %p, guid %s, ddraw %p, backbuffer %p.\n",
1255             iface, debugstr_guid(guid), ddraw, backbuffer);
1256
1257     return d3drm_device3_InitFromSurface(&device->IDirect3DRMDevice3_iface, guid, ddraw, backbuffer);
1258 }
1259
1260 static HRESULT WINAPI d3drm_device3_SetRenderMode(IDirect3DRMDevice3 *iface, DWORD flags)
1261 {
1262     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
1263
1264     TRACE("iface %p, flags %#x.\n", iface, flags);
1265
1266     device->rendermode = flags;
1267
1268     return D3DRM_OK;
1269 }
1270
1271 static HRESULT WINAPI d3drm_device2_SetRenderMode(IDirect3DRMDevice2 *iface, DWORD flags)
1272 {
1273     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1274
1275     TRACE("iface %p, flags %#x.\n", iface, flags);
1276
1277     return d3drm_device3_SetRenderMode(&device->IDirect3DRMDevice3_iface, flags);
1278 }
1279
1280 static DWORD WINAPI d3drm_device3_GetRenderMode(IDirect3DRMDevice3 *iface)
1281 {
1282     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
1283
1284     TRACE("iface %p.\n", iface);
1285
1286     return device->rendermode;
1287 }
1288
1289 static DWORD WINAPI d3drm_device2_GetRenderMode(IDirect3DRMDevice2 *iface)
1290 {
1291     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1292
1293     TRACE("iface %p.\n", iface);
1294
1295     return d3drm_device3_GetRenderMode(&device->IDirect3DRMDevice3_iface);
1296 }
1297
1298 static HRESULT WINAPI d3drm_device3_GetDirect3DDevice2(IDirect3DRMDevice3 *iface, IDirect3DDevice2 **d3d_device)
1299 {
1300     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
1301
1302     TRACE("iface %p, d3d_device %p.\n", iface, d3d_device);
1303
1304     if (FAILED(IDirect3DDevice_QueryInterface(device->device, &IID_IDirect3DDevice2, (void**)d3d_device)))
1305         return D3DRMERR_BADOBJECT;
1306
1307     return D3DRM_OK;
1308 }
1309
1310 static HRESULT WINAPI d3drm_device2_GetDirect3DDevice2(IDirect3DRMDevice2 *iface, IDirect3DDevice2 **d3d_device)
1311 {
1312     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
1313
1314     TRACE("iface %p, d3d_device %p.\n", iface, d3d_device);
1315
1316     IDirect3DDevice_QueryInterface(device->device, &IID_IDirect3DDevice2, (void**)d3d_device);
1317
1318     /* d3drm returns D3DRM_OK even if the call fails. */
1319     return D3DRM_OK;
1320 }
1321
1322 static HRESULT WINAPI d3drm_device3_FindPreferredTextureFormat(IDirect3DRMDevice3 *iface,
1323         DWORD bitdepths, DWORD flags, DDPIXELFORMAT *pf)
1324 {
1325     FIXME("iface %p, bitdepths %u, flags %#x, pf %p stub!\n", iface, bitdepths, flags, pf);
1326
1327     return E_NOTIMPL;
1328 }
1329
1330 static HRESULT WINAPI d3drm_device3_RenderStateChange(IDirect3DRMDevice3 *iface,
1331         D3DRENDERSTATETYPE state, DWORD value, DWORD flags)
1332 {
1333     FIXME("iface %p, state %#x, value %#x, flags %#x stub!\n", iface, state, value, flags);
1334
1335     return E_NOTIMPL;
1336 }
1337
1338 static HRESULT WINAPI d3drm_device3_LightStateChange(IDirect3DRMDevice3 *iface,
1339         D3DLIGHTSTATETYPE state, DWORD value, DWORD flags)
1340 {
1341     FIXME("iface %p, state %#x, value %#x, flags %#x stub!\n", iface, state, value, flags);
1342
1343     return E_NOTIMPL;
1344 }
1345
1346 static HRESULT WINAPI d3drm_device3_GetStateChangeOptions(IDirect3DRMDevice3 *iface,
1347         DWORD state_class, DWORD state_idx, DWORD *flags)
1348 {
1349     FIXME("iface %p, state_class %#x, state_idx %#x, flags %p stub!\n",
1350             iface, state_class, state_idx, flags);
1351
1352     return E_NOTIMPL;
1353 }
1354
1355 static HRESULT WINAPI d3drm_device3_SetStateChangeOptions(IDirect3DRMDevice3 *iface,
1356         DWORD state_class, DWORD state_idx, DWORD flags)
1357 {
1358     FIXME("iface %p, state_class %#x, state_idx %#x, flags %#x stub!\n",
1359             iface, state_class, state_idx, flags);
1360
1361     return E_NOTIMPL;
1362 }
1363
1364 static const struct IDirect3DRMDevice3Vtbl d3drm_device3_vtbl =
1365 {
1366     d3drm_device3_QueryInterface,
1367     d3drm_device3_AddRef,
1368     d3drm_device3_Release,
1369     d3drm_device3_Clone,
1370     d3drm_device3_AddDestroyCallback,
1371     d3drm_device3_DeleteDestroyCallback,
1372     d3drm_device3_SetAppData,
1373     d3drm_device3_GetAppData,
1374     d3drm_device3_SetName,
1375     d3drm_device3_GetName,
1376     d3drm_device3_GetClassName,
1377     d3drm_device3_Init,
1378     d3drm_device3_InitFromD3D,
1379     d3drm_device3_InitFromClipper,
1380     d3drm_device3_Update,
1381     d3drm_device3_AddUpdateCallback,
1382     d3drm_device3_DeleteUpdateCallback,
1383     d3drm_device3_SetBufferCount,
1384     d3drm_device3_GetBufferCount,
1385     d3drm_device3_SetDither,
1386     d3drm_device3_SetShades,
1387     d3drm_device3_SetQuality,
1388     d3drm_device3_SetTextureQuality,
1389     d3drm_device3_GetViewports,
1390     d3drm_device3_GetDither,
1391     d3drm_device3_GetShades,
1392     d3drm_device3_GetHeight,
1393     d3drm_device3_GetWidth,
1394     d3drm_device3_GetTrianglesDrawn,
1395     d3drm_device3_GetWireframeOptions,
1396     d3drm_device3_GetQuality,
1397     d3drm_device3_GetColorModel,
1398     d3drm_device3_GetTextureQuality,
1399     d3drm_device3_GetDirect3DDevice,
1400     d3drm_device3_InitFromD3D2,
1401     d3drm_device3_InitFromSurface,
1402     d3drm_device3_SetRenderMode,
1403     d3drm_device3_GetRenderMode,
1404     d3drm_device3_GetDirect3DDevice2,
1405     d3drm_device3_FindPreferredTextureFormat,
1406     d3drm_device3_RenderStateChange,
1407     d3drm_device3_LightStateChange,
1408     d3drm_device3_GetStateChangeOptions,
1409     d3drm_device3_SetStateChangeOptions,
1410 };
1411
1412 static const struct IDirect3DRMDevice2Vtbl d3drm_device2_vtbl =
1413 {
1414     d3drm_device2_QueryInterface,
1415     d3drm_device2_AddRef,
1416     d3drm_device2_Release,
1417     d3drm_device2_Clone,
1418     d3drm_device2_AddDestroyCallback,
1419     d3drm_device2_DeleteDestroyCallback,
1420     d3drm_device2_SetAppData,
1421     d3drm_device2_GetAppData,
1422     d3drm_device2_SetName,
1423     d3drm_device2_GetName,
1424     d3drm_device2_GetClassName,
1425     d3drm_device2_Init,
1426     d3drm_device2_InitFromD3D,
1427     d3drm_device2_InitFromClipper,
1428     d3drm_device2_Update,
1429     d3drm_device2_AddUpdateCallback,
1430     d3drm_device2_DeleteUpdateCallback,
1431     d3drm_device2_SetBufferCount,
1432     d3drm_device2_GetBufferCount,
1433     d3drm_device2_SetDither,
1434     d3drm_device2_SetShades,
1435     d3drm_device2_SetQuality,
1436     d3drm_device2_SetTextureQuality,
1437     d3drm_device2_GetViewports,
1438     d3drm_device2_GetDither,
1439     d3drm_device2_GetShades,
1440     d3drm_device2_GetHeight,
1441     d3drm_device2_GetWidth,
1442     d3drm_device2_GetTrianglesDrawn,
1443     d3drm_device2_GetWireframeOptions,
1444     d3drm_device2_GetQuality,
1445     d3drm_device2_GetColorModel,
1446     d3drm_device2_GetTextureQuality,
1447     d3drm_device2_GetDirect3DDevice,
1448     d3drm_device2_InitFromD3D2,
1449     d3drm_device2_InitFromSurface,
1450     d3drm_device2_SetRenderMode,
1451     d3drm_device2_GetRenderMode,
1452     d3drm_device2_GetDirect3DDevice2,
1453 };
1454
1455 static const struct IDirect3DRMDeviceVtbl d3drm_device1_vtbl =
1456 {
1457     d3drm_device1_QueryInterface,
1458     d3drm_device1_AddRef,
1459     d3drm_device1_Release,
1460     d3drm_device1_Clone,
1461     d3drm_device1_AddDestroyCallback,
1462     d3drm_device1_DeleteDestroyCallback,
1463     d3drm_device1_SetAppData,
1464     d3drm_device1_GetAppData,
1465     d3drm_device1_SetName,
1466     d3drm_device1_GetName,
1467     d3drm_device1_GetClassName,
1468     d3drm_device1_Init,
1469     d3drm_device1_InitFromD3D,
1470     d3drm_device1_InitFromClipper,
1471     d3drm_device1_Update,
1472     d3drm_device1_AddUpdateCallback,
1473     d3drm_device1_DeleteUpdateCallback,
1474     d3drm_device1_SetBufferCount,
1475     d3drm_device1_GetBufferCount,
1476     d3drm_device1_SetDither,
1477     d3drm_device1_SetShades,
1478     d3drm_device1_SetQuality,
1479     d3drm_device1_SetTextureQuality,
1480     d3drm_device1_GetViewports,
1481     d3drm_device1_GetDither,
1482     d3drm_device1_GetShades,
1483     d3drm_device1_GetHeight,
1484     d3drm_device1_GetWidth,
1485     d3drm_device1_GetTrianglesDrawn,
1486     d3drm_device1_GetWireframeOptions,
1487     d3drm_device1_GetQuality,
1488     d3drm_device1_GetColorModel,
1489     d3drm_device1_GetTextureQuality,
1490     d3drm_device1_GetDirect3DDevice,
1491 };
1492
1493 static HRESULT WINAPI d3drm_device_win_QueryInterface(IDirect3DRMWinDevice *iface, REFIID riid, void **out)
1494 {
1495     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
1496
1497     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
1498
1499     return d3drm_device3_QueryInterface(&device->IDirect3DRMDevice3_iface, riid, out);
1500 }
1501
1502 static ULONG WINAPI d3drm_device_win_AddRef(IDirect3DRMWinDevice *iface)
1503 {
1504     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
1505
1506     TRACE("iface %p.\n", iface);
1507
1508     return d3drm_device3_AddRef(&device->IDirect3DRMDevice3_iface);
1509 }
1510
1511 static ULONG WINAPI d3drm_device_win_Release(IDirect3DRMWinDevice *iface)
1512 {
1513     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
1514
1515     TRACE("iface %p.\n", iface);
1516
1517     return d3drm_device3_Release(&device->IDirect3DRMDevice3_iface);
1518 }
1519
1520 static HRESULT WINAPI d3drm_device_win_Clone(IDirect3DRMWinDevice *iface,
1521         IUnknown *outer, REFIID iid, void **out)
1522 {
1523     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
1524
1525     TRACE("iface %p, outer %p, iid %s, out %p\n", iface, outer, debugstr_guid(iid), out);
1526
1527     return d3drm_device3_Clone(&device->IDirect3DRMDevice3_iface, outer, iid, out);
1528 }
1529
1530 static HRESULT WINAPI d3drm_device_win_AddDestroyCallback(IDirect3DRMWinDevice *iface,
1531         D3DRMOBJECTCALLBACK cb, void *ctx)
1532 {
1533     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1534
1535     return E_NOTIMPL;
1536 }
1537
1538 static HRESULT WINAPI d3drm_device_win_DeleteDestroyCallback(IDirect3DRMWinDevice *iface,
1539         D3DRMOBJECTCALLBACK cb, void *ctx)
1540 {
1541     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1542
1543     return E_NOTIMPL;
1544 }
1545
1546 static HRESULT WINAPI d3drm_device_win_SetAppData(IDirect3DRMWinDevice *iface, DWORD data)
1547 {
1548     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
1549
1550     TRACE("iface %p, data %#x.\n", iface, data);
1551
1552     return d3drm_device3_SetAppData(&device->IDirect3DRMDevice3_iface, data);
1553 }
1554
1555 static DWORD WINAPI d3drm_device_win_GetAppData(IDirect3DRMWinDevice *iface)
1556 {
1557     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
1558
1559     TRACE("iface %p.\n", iface);
1560
1561     return d3drm_device3_GetAppData(&device->IDirect3DRMDevice3_iface);
1562 }
1563
1564 static HRESULT WINAPI d3drm_device_win_SetName(IDirect3DRMWinDevice *iface, const char *name)
1565 {
1566     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
1567
1568     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
1569
1570     return d3drm_device3_SetName(&device->IDirect3DRMDevice3_iface, name);
1571 }
1572
1573 static HRESULT WINAPI d3drm_device_win_GetName(IDirect3DRMWinDevice *iface, DWORD *size, char *name)
1574 {
1575     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
1576
1577     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
1578
1579     return d3drm_device3_GetName(&device->IDirect3DRMDevice3_iface, size, name);
1580 }
1581
1582 static HRESULT WINAPI d3drm_device_win_GetClassName(IDirect3DRMWinDevice *iface, DWORD *size, char *name)
1583 {
1584     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
1585
1586     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
1587
1588     return d3drm_device3_GetClassName(&device->IDirect3DRMDevice3_iface, size, name);
1589 }
1590
1591 static HRESULT WINAPI d3drm_device_win_HandlePaint(IDirect3DRMWinDevice *iface, HDC dc)
1592 {
1593     FIXME("iface %p, dc %p stub!\n", iface, dc);
1594
1595     return D3DRM_OK;
1596 }
1597
1598 static HRESULT WINAPI d3drm_device_win_HandleActivate(IDirect3DRMWinDevice *iface, WORD wparam)
1599 {
1600     FIXME("iface %p, wparam %#x stub!\n", iface, wparam);
1601
1602     return D3DRM_OK;
1603 }
1604
1605 static const struct IDirect3DRMWinDeviceVtbl d3drm_device_win_vtbl =
1606 {
1607     d3drm_device_win_QueryInterface,
1608     d3drm_device_win_AddRef,
1609     d3drm_device_win_Release,
1610     d3drm_device_win_Clone,
1611     d3drm_device_win_AddDestroyCallback,
1612     d3drm_device_win_DeleteDestroyCallback,
1613     d3drm_device_win_SetAppData,
1614     d3drm_device_win_GetAppData,
1615     d3drm_device_win_SetName,
1616     d3drm_device_win_GetName,
1617     d3drm_device_win_GetClassName,
1618     d3drm_device_win_HandlePaint,
1619     d3drm_device_win_HandleActivate,
1620 };
1621
1622 struct d3drm_device *unsafe_impl_from_IDirect3DRMDevice3(IDirect3DRMDevice3 *iface)
1623 {
1624     if (!iface)
1625         return NULL;
1626     assert(iface->lpVtbl == &d3drm_device3_vtbl);
1627
1628     return impl_from_IDirect3DRMDevice3(iface);
1629 }
1630
1631 HRESULT d3drm_device_create(struct d3drm_device **device, IDirect3DRM *d3drm)
1632 {
1633     struct d3drm_device *object;
1634
1635     TRACE("device %p, d3drm %p.\n", device, d3drm);
1636
1637     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1638         return E_OUTOFMEMORY;
1639
1640     object->IDirect3DRMDevice_iface.lpVtbl = &d3drm_device1_vtbl;
1641     object->IDirect3DRMDevice2_iface.lpVtbl = &d3drm_device2_vtbl;
1642     object->IDirect3DRMDevice3_iface.lpVtbl = &d3drm_device3_vtbl;
1643     object->IDirect3DRMWinDevice_iface.lpVtbl = &d3drm_device_win_vtbl;
1644     object->d3drm = d3drm;
1645     d3drm_object_init(&object->obj);
1646
1647     *device = object;
1648
1649     return D3DRM_OK;
1650 }