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