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