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