dlls/d3drm/device.c

   1 /*
   2  * Implementation of IDirect3DRMDevice Interface
   3  *
   4  * Copyright 2011, 2012 André Hentschel
   5  *
   6  * This file contains the (internal) driver registration functions,
   7  * driver enumeration APIs and DirectDraw creation functions.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "wine/debug.h"
  25
  26 #define COBJMACROS
  27
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30
  31 #include "d3drm_private.h"
  32 #include "initguid.h"
  33 #include "d3drmwin.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(d3drm);
  36
  37 struct d3drm_device
  38 {
  39     IDirect3DRMDevice2 IDirect3DRMDevice2_iface;
  40     IDirect3DRMDevice3 IDirect3DRMDevice3_iface;
  41     IDirect3DRMWinDevice IDirect3DRMWinDevice_iface;
  42     LONG ref;
  43     BOOL dither;
  44     D3DRMRENDERQUALITY quality;
  45     DWORD rendermode;
  46     DWORD height;
  47     DWORD width;
  48 };
  49
  50 static inline struct d3drm_device *impl_from_IDirect3DRMDevice2(IDirect3DRMDevice2 *iface)
  51 {
  52     return CONTAINING_RECORD(iface, struct d3drm_device, IDirect3DRMDevice2_iface);
  53 }
  54
  55 static inline struct d3drm_device *impl_from_IDirect3DRMDevice3(IDirect3DRMDevice3 *iface)
  56 {
  57     return CONTAINING_RECORD(iface, struct d3drm_device, IDirect3DRMDevice3_iface);
  58 }
  59
  60 static inline struct d3drm_device *impl_from_IDirect3DRMWinDevice(IDirect3DRMWinDevice *iface)
  61 {
  62     return CONTAINING_RECORD(iface, struct d3drm_device, IDirect3DRMWinDevice_iface);
  63 }
  64
  65 static HRESULT WINAPI d3drm_device2_QueryInterface(IDirect3DRMDevice2 *iface, REFIID riid, void **out)
  66 {
  67     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
  68
  69     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  70
  71     if (IsEqualGUID(riid, &IID_IDirect3DRMDevice2)
  72             || IsEqualGUID(riid, &IID_IDirect3DRMDevice)
  73             || IsEqualGUID(riid, &IID_IUnknown))
  74     {
  75         *out = &device->IDirect3DRMDevice2_iface;
  76     }
  77     else if (IsEqualGUID(riid, &IID_IDirect3DRMDevice3))
  78     {
  79         *out = &device->IDirect3DRMDevice3_iface;
  80     }
  81     else if (IsEqualGUID(riid, &IID_IDirect3DRMWinDevice))
  82     {
  83         *out = &device->IDirect3DRMWinDevice_iface;
  84     }
  85     else
  86     {
  87         *out = NULL;
  88         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  89         return E_NOINTERFACE;
  90     }
  91
  92     IUnknown_AddRef((IUnknown *)*out);
  93     return S_OK;
  94 }
  95
  96 static ULONG WINAPI d3drm_device2_AddRef(IDirect3DRMDevice2 *iface)
  97 {
  98     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
  99     ULONG refcount = InterlockedIncrement(&device->ref);
 100
 101     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 102
 103     return refcount;
 104 }
 105
 106 static ULONG WINAPI d3drm_device2_Release(IDirect3DRMDevice2 *iface)
 107 {
 108     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 109     ULONG refcount = InterlockedDecrement(&device->ref);
 110
 111     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 112
 113     if (!refcount)
 114         HeapFree(GetProcessHeap(), 0, device);
 115
 116     return refcount;
 117 }
 118
 119 static HRESULT WINAPI d3drm_device2_Clone(IDirect3DRMDevice2 *iface,
 120         IUnknown *outer, REFIID iid, void **out)
 121 {
 122     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
 123
 124     return E_NOTIMPL;
 125 }
 126
 127 static HRESULT WINAPI d3drm_device2_AddDestroyCallback(IDirect3DRMDevice2 *iface,
 128         D3DRMOBJECTCALLBACK cb, void *ctx)
 129 {
 130     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 131
 132     return E_NOTIMPL;
 133 }
 134
 135 static HRESULT WINAPI d3drm_device2_DeleteDestroyCallback(IDirect3DRMDevice2 *iface,
 136         D3DRMOBJECTCALLBACK cb, void *ctx)
 137 {
 138     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 139
 140     return E_NOTIMPL;
 141 }
 142
 143 static HRESULT WINAPI d3drm_device2_SetAppData(IDirect3DRMDevice2 *iface, DWORD data)
 144 {
 145     FIXME("iface %p, data %#x stub!\n", iface, data);
 146
 147     return E_NOTIMPL;
 148 }
 149
 150 static DWORD WINAPI d3drm_device2_GetAppData(IDirect3DRMDevice2 *iface)
 151 {
 152     FIXME("iface %p stub!\n", iface);
 153
 154     return 0;
 155 }
 156
 157 static HRESULT WINAPI d3drm_device2_SetName(IDirect3DRMDevice2 *iface, const char *name)
 158 {
 159     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
 160
 161     return E_NOTIMPL;
 162 }
 163
 164 static HRESULT WINAPI d3drm_device2_GetName(IDirect3DRMDevice2 *iface, DWORD *size, char *name)
 165 {
 166     FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
 167
 168     return E_NOTIMPL;
 169 }
 170
 171 static HRESULT WINAPI d3drm_device2_GetClassName(IDirect3DRMDevice2 *iface, DWORD *size, char *name)
 172 {
 173     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 174
 175     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 176
 177     return IDirect3DRMDevice3_GetClassName(&device->IDirect3DRMDevice3_iface, size, name);
 178 }
 179
 180 static HRESULT WINAPI d3drm_device2_Init(IDirect3DRMDevice2 *iface, ULONG width, ULONG height)
 181 {
 182     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 183
 184     TRACE("iface %p, width %u, height %u.\n", iface, width, height);
 185
 186     return IDirect3DRMDevice3_Init(&device->IDirect3DRMDevice3_iface, width, height);
 187 }
 188
 189 static HRESULT WINAPI d3drm_device2_InitFromD3D(IDirect3DRMDevice2 *iface,
 190         IDirect3D *d3d, IDirect3DDevice *d3d_device)
 191 {
 192     FIXME("iface %p, d3d %p, d3d_device %p stub!\n", iface, d3d, d3d_device);
 193
 194     return E_NOTIMPL;
 195 }
 196
 197 static HRESULT WINAPI d3drm_device2_InitFromClipper(IDirect3DRMDevice2 *iface,
 198         IDirectDrawClipper *clipper, GUID *guid, int width, int height)
 199 {
 200     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 201
 202     TRACE("iface %p, clipper %p, guid %s, width %d, height %d.\n",
 203             iface, clipper, debugstr_guid(guid), width, height);
 204
 205     return IDirect3DRMDevice3_InitFromClipper(&device->IDirect3DRMDevice3_iface,
 206             clipper, guid, width, height);
 207 }
 208
 209 static HRESULT WINAPI d3drm_device2_Update(IDirect3DRMDevice2 *iface)
 210 {
 211     FIXME("iface %p stub!\n", iface);
 212
 213     return D3DRM_OK;
 214 }
 215
 216 static HRESULT WINAPI d3drm_device2_AddUpdateCallback(IDirect3DRMDevice2 *iface,
 217         D3DRMUPDATECALLBACK cb, void *ctx)
 218 {
 219     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 220
 221     return E_NOTIMPL;
 222 }
 223
 224 static HRESULT WINAPI d3drm_device2_DeleteUpdateCallback(IDirect3DRMDevice2 *iface,
 225         D3DRMUPDATECALLBACK cb, void *ctx)
 226 {
 227     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 228
 229     return E_NOTIMPL;
 230 }
 231
 232 static HRESULT WINAPI d3drm_device2_SetBufferCount(IDirect3DRMDevice2 *iface, DWORD count)
 233 {
 234     FIXME("iface %p, count %u.\n", iface, count);
 235
 236     return E_NOTIMPL;
 237 }
 238
 239 static DWORD WINAPI d3drm_device2_GetBufferCount(IDirect3DRMDevice2 *iface)
 240 {
 241     FIXME("iface %p stub!\n", iface);
 242
 243     return E_NOTIMPL;
 244 }
 245
 246 static HRESULT WINAPI d3drm_device2_SetDither(IDirect3DRMDevice2 *iface, BOOL enable)
 247 {
 248     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 249
 250     TRACE("iface %p, enabled %#x.\n", iface, enable);
 251
 252     return IDirect3DRMDevice3_SetDither(&device->IDirect3DRMDevice3_iface, enable);
 253 }
 254
 255 static HRESULT WINAPI d3drm_device2_SetShades(IDirect3DRMDevice2 *iface, DWORD count)
 256 {
 257     FIXME("iface %p, count %u stub!\n", iface, count);
 258
 259     return E_NOTIMPL;
 260 }
 261
 262 static HRESULT WINAPI d3drm_device2_SetQuality(IDirect3DRMDevice2 *iface, D3DRMRENDERQUALITY quality)
 263 {
 264     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 265
 266     TRACE("iface %p, quality %u.\n", iface, quality);
 267
 268     return IDirect3DRMDevice3_SetQuality(&device->IDirect3DRMDevice3_iface, quality);
 269 }
 270
 271 static HRESULT WINAPI d3drm_device2_SetTextureQuality(IDirect3DRMDevice2 *iface, D3DRMTEXTUREQUALITY quality)
 272 {
 273     FIXME("iface %p, quality %u stub!\n", iface, quality);
 274
 275     return E_NOTIMPL;
 276 }
 277
 278 static HRESULT WINAPI d3drm_device2_GetViewports(IDirect3DRMDevice2 *iface, IDirect3DRMViewportArray **array)
 279 {
 280     FIXME("iface %p, array %p stub!\n", iface, array);
 281
 282     return E_NOTIMPL;
 283 }
 284
 285 static BOOL WINAPI d3drm_device2_GetDither(IDirect3DRMDevice2 *iface)
 286 {
 287     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 288
 289     TRACE("iface %p.\n", iface);
 290
 291     return IDirect3DRMDevice3_GetDither(&device->IDirect3DRMDevice3_iface);
 292 }
 293
 294 static DWORD WINAPI d3drm_device2_GetShades(IDirect3DRMDevice2 *iface)
 295 {
 296     FIXME("iface %p stub!\n", iface);
 297
 298     return E_NOTIMPL;
 299 }
 300
 301 static DWORD WINAPI d3drm_device2_GetHeight(IDirect3DRMDevice2 *iface)
 302 {
 303     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 304
 305     TRACE("iface %p.\n", iface);
 306
 307     return IDirect3DRMDevice3_GetHeight(&device->IDirect3DRMDevice3_iface);
 308 }
 309
 310 static DWORD WINAPI d3drm_device2_GetWidth(IDirect3DRMDevice2 *iface)
 311 {
 312     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 313
 314     TRACE("iface %p.\n", iface);
 315
 316     return IDirect3DRMDevice3_GetWidth(&device->IDirect3DRMDevice3_iface);
 317 }
 318
 319 static DWORD WINAPI d3drm_device2_GetTrianglesDrawn(IDirect3DRMDevice2 *iface)
 320 {
 321     FIXME("iface %p stub!\n", iface);
 322
 323     return E_NOTIMPL;
 324 }
 325
 326 static DWORD WINAPI d3drm_device2_GetWireframeOptions(IDirect3DRMDevice2 *iface)
 327 {
 328     FIXME("iface %p stub!\n", iface);
 329
 330     return E_NOTIMPL;
 331 }
 332
 333 static D3DRMRENDERQUALITY WINAPI d3drm_device2_GetQuality(IDirect3DRMDevice2 *iface)
 334 {
 335     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 336
 337     TRACE("iface %p.\n", iface);
 338
 339     return IDirect3DRMDevice3_GetQuality(&device->IDirect3DRMDevice3_iface);
 340 }
 341
 342 static D3DCOLORMODEL WINAPI d3drm_device2_GetColorModel(IDirect3DRMDevice2 *iface)
 343 {
 344     FIXME("iface %p stub!\n", iface);
 345
 346     return E_NOTIMPL;
 347 }
 348
 349 static D3DRMTEXTUREQUALITY WINAPI d3drm_device2_GetTextureQuality(IDirect3DRMDevice2 *iface)
 350 {
 351     FIXME("iface %p stub!\n", iface);
 352
 353     return E_NOTIMPL;
 354 }
 355
 356 static HRESULT WINAPI d3drm_device2_GetDirect3DDevice(IDirect3DRMDevice2 *iface, IDirect3DDevice **d3d_device)
 357 {
 358     FIXME("iface %p, d3d_device %p stub!\n", iface, d3d_device);
 359
 360     return E_NOTIMPL;
 361 }
 362
 363 static HRESULT WINAPI d3drm_device2_InitFromD3D2(IDirect3DRMDevice2 *iface,
 364         IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device)
 365 {
 366     FIXME("iface %p, d3d %p, d3d_device %p stub!\n", iface, d3d, d3d_device);
 367
 368     return E_NOTIMPL;
 369 }
 370
 371 static HRESULT WINAPI d3drm_device2_InitFromSurface(IDirect3DRMDevice2 *iface,
 372         GUID *guid, IDirectDraw *ddraw, IDirectDrawSurface *backbuffer)
 373 {
 374     FIXME("iface %p, guid %s, ddraw %p, backbuffer %p stub!\n",
 375             iface, debugstr_guid(guid), ddraw, backbuffer);
 376
 377     return E_NOTIMPL;
 378 }
 379
 380 static HRESULT WINAPI d3drm_device2_SetRenderMode(IDirect3DRMDevice2 *iface, DWORD flags)
 381 {
 382     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 383
 384     TRACE("iface %p, flags %#x.\n", iface, flags);
 385
 386     return IDirect3DRMDevice3_SetRenderMode(&device->IDirect3DRMDevice3_iface, flags);
 387 }
 388
 389 static DWORD WINAPI d3drm_device2_GetRenderMode(IDirect3DRMDevice2 *iface)
 390 {
 391     struct d3drm_device *device = impl_from_IDirect3DRMDevice2(iface);
 392
 393     TRACE("iface %p.\n", iface);
 394
 395     return IDirect3DRMDevice3_GetRenderMode(&device->IDirect3DRMDevice3_iface);
 396 }
 397
 398 static HRESULT WINAPI d3drm_device2_GetDirect3DDevice2(IDirect3DRMDevice2 *iface, IDirect3DDevice2 **d3d_device)
 399 {
 400     FIXME("iface %p, d3d_device %p stub!\n", iface, d3d_device);
 401
 402     return E_NOTIMPL;
 403 }
 404
 405 static const struct IDirect3DRMDevice2Vtbl d3drm_device2_vtbl =
 406 {
 407     d3drm_device2_QueryInterface,
 408     d3drm_device2_AddRef,
 409     d3drm_device2_Release,
 410     d3drm_device2_Clone,
 411     d3drm_device2_AddDestroyCallback,
 412     d3drm_device2_DeleteDestroyCallback,
 413     d3drm_device2_SetAppData,
 414     d3drm_device2_GetAppData,
 415     d3drm_device2_SetName,
 416     d3drm_device2_GetName,
 417     d3drm_device2_GetClassName,
 418     d3drm_device2_Init,
 419     d3drm_device2_InitFromD3D,
 420     d3drm_device2_InitFromClipper,
 421     d3drm_device2_Update,
 422     d3drm_device2_AddUpdateCallback,
 423     d3drm_device2_DeleteUpdateCallback,
 424     d3drm_device2_SetBufferCount,
 425     d3drm_device2_GetBufferCount,
 426     d3drm_device2_SetDither,
 427     d3drm_device2_SetShades,
 428     d3drm_device2_SetQuality,
 429     d3drm_device2_SetTextureQuality,
 430     d3drm_device2_GetViewports,
 431     d3drm_device2_GetDither,
 432     d3drm_device2_GetShades,
 433     d3drm_device2_GetHeight,
 434     d3drm_device2_GetWidth,
 435     d3drm_device2_GetTrianglesDrawn,
 436     d3drm_device2_GetWireframeOptions,
 437     d3drm_device2_GetQuality,
 438     d3drm_device2_GetColorModel,
 439     d3drm_device2_GetTextureQuality,
 440     d3drm_device2_GetDirect3DDevice,
 441     d3drm_device2_InitFromD3D2,
 442     d3drm_device2_InitFromSurface,
 443     d3drm_device2_SetRenderMode,
 444     d3drm_device2_GetRenderMode,
 445     d3drm_device2_GetDirect3DDevice2,
 446 };
 447
 448 static HRESULT WINAPI d3drm_device3_QueryInterface(IDirect3DRMDevice3 *iface, REFIID riid, void **out)
 449 {
 450     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 451
 452     return d3drm_device2_QueryInterface(&device->IDirect3DRMDevice2_iface, riid, out);
 453 }
 454
 455 static ULONG WINAPI d3drm_device3_AddRef(IDirect3DRMDevice3 *iface)
 456 {
 457     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 458
 459     return d3drm_device2_AddRef(&device->IDirect3DRMDevice2_iface);
 460 }
 461
 462 static ULONG WINAPI d3drm_device3_Release(IDirect3DRMDevice3 *iface)
 463 {
 464     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 465
 466     return d3drm_device2_Release(&device->IDirect3DRMDevice2_iface);
 467 }
 468
 469 static HRESULT WINAPI d3drm_device3_Clone(IDirect3DRMDevice3 *iface,
 470         IUnknown *outer, REFIID iid, void **out)
 471 {
 472     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
 473
 474     return E_NOTIMPL;
 475 }
 476
 477 static HRESULT WINAPI d3drm_device3_AddDestroyCallback(IDirect3DRMDevice3 *iface,
 478         D3DRMOBJECTCALLBACK cb, void *ctx)
 479 {
 480     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 481
 482     return E_NOTIMPL;
 483 }
 484
 485 static HRESULT WINAPI d3drm_device3_DeleteDestroyCallback(IDirect3DRMDevice3 *iface,
 486         D3DRMOBJECTCALLBACK cb, void *ctx)
 487 {
 488     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 489
 490     return E_NOTIMPL;
 491 }
 492
 493 static HRESULT WINAPI d3drm_device3_SetAppData(IDirect3DRMDevice3 *iface, DWORD data)
 494 {
 495     FIXME("iface %p, data %#x stub!\n", iface, data);
 496
 497     return E_NOTIMPL;
 498 }
 499
 500 static DWORD WINAPI d3drm_device3_GetAppData(IDirect3DRMDevice3 *iface)
 501 {
 502     FIXME("iface %p stub!\n", iface);
 503
 504     return 0;
 505 }
 506
 507 static HRESULT WINAPI d3drm_device3_SetName(IDirect3DRMDevice3 *iface, const char *name)
 508 {
 509     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
 510
 511     return E_NOTIMPL;
 512 }
 513
 514 static HRESULT WINAPI d3drm_device3_GetName(IDirect3DRMDevice3 *iface, DWORD *size, char *name)
 515 {
 516     FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
 517
 518     return E_NOTIMPL;
 519 }
 520
 521 static HRESULT WINAPI d3drm_device3_GetClassName(IDirect3DRMDevice3 *iface, DWORD *size, char *name)
 522 {
 523     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 524
 525     if (!size || *size < strlen("Device") || !name)
 526         return E_INVALIDARG;
 527
 528     strcpy(name, "Device");
 529     *size = sizeof("Device");
 530
 531     return D3DRM_OK;
 532 }
 533
 534 static HRESULT WINAPI d3drm_device3_Init(IDirect3DRMDevice3 *iface, ULONG width, ULONG height)
 535 {
 536     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 537
 538     FIXME("iface %p, width %u, height %u stub!\n", iface, width, height);
 539
 540     device->height = height;
 541     device->width = width;
 542
 543     return D3DRM_OK;
 544 }
 545
 546 static HRESULT WINAPI d3drm_device3_InitFromD3D(IDirect3DRMDevice3 *iface,
 547         IDirect3D *d3d, IDirect3DDevice *d3d_device)
 548 {
 549     FIXME("iface %p, d3d %p, d3d_device %p stub!\n", iface, d3d, d3d_device);
 550
 551     return E_NOTIMPL;
 552 }
 553
 554 static HRESULT WINAPI d3drm_device3_InitFromClipper(IDirect3DRMDevice3 *iface,
 555         IDirectDrawClipper *clipper, GUID *guid, int width, int height)
 556 {
 557     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 558
 559     FIXME("iface %p, clipper %p, guid %s, width %d, height %d stub!\n",
 560             iface, clipper, debugstr_guid(guid), width, height);
 561
 562     device->height = height;
 563     device->width = width;
 564
 565     return D3DRM_OK;
 566 }
 567
 568 static HRESULT WINAPI d3drm_device3_Update(IDirect3DRMDevice3 *iface)
 569 {
 570     FIXME("iface %p stub!\n", iface);
 571
 572     return D3DRM_OK;
 573 }
 574
 575 static HRESULT WINAPI d3drm_device3_AddUpdateCallback(IDirect3DRMDevice3 *iface,
 576         D3DRMUPDATECALLBACK cb, void *ctx)
 577 {
 578     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 579
 580     return E_NOTIMPL;
 581 }
 582
 583 static HRESULT WINAPI d3drm_device3_DeleteUpdateCallback(IDirect3DRMDevice3 *iface,
 584         D3DRMUPDATECALLBACK cb, void *ctx)
 585 {
 586     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 587
 588     return E_NOTIMPL;
 589 }
 590
 591 static HRESULT WINAPI d3drm_device3_SetBufferCount(IDirect3DRMDevice3 *iface, DWORD count)
 592 {
 593     FIXME("iface %p, count %u stub!\n", iface, count);
 594
 595     return E_NOTIMPL;
 596 }
 597
 598 static DWORD WINAPI d3drm_device3_GetBufferCount(IDirect3DRMDevice3 *iface)
 599 {
 600     FIXME("iface %p stub!\n", iface);
 601
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT WINAPI d3drm_device3_SetDither(IDirect3DRMDevice3 *iface, BOOL enable)
 606 {
 607     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 608
 609     TRACE("iface %p, enable %#x.\n", iface, enable);
 610
 611     device->dither = enable;
 612
 613     return D3DRM_OK;
 614 }
 615
 616 static HRESULT WINAPI d3drm_device3_SetShades(IDirect3DRMDevice3 *iface, DWORD count)
 617 {
 618     FIXME("iface %p, count %u stub!\n", iface, count);
 619
 620     return E_NOTIMPL;
 621 }
 622
 623 static HRESULT WINAPI d3drm_device3_SetQuality(IDirect3DRMDevice3 *iface, D3DRMRENDERQUALITY quality)
 624 {
 625     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 626
 627     TRACE("iface %p, quality %u.\n", iface, quality);
 628
 629     device->quality = quality;
 630
 631     return D3DRM_OK;
 632 }
 633
 634 static HRESULT WINAPI d3drm_device3_SetTextureQuality(IDirect3DRMDevice3 *iface, D3DRMTEXTUREQUALITY quality)
 635 {
 636     FIXME("iface %p, quality %u stub!\n", iface, quality);
 637
 638     return E_NOTIMPL;
 639 }
 640
 641 static HRESULT WINAPI d3drm_device3_GetViewports(IDirect3DRMDevice3 *iface, IDirect3DRMViewportArray **array)
 642 {
 643     FIXME("iface %p, array %p stub!\n", iface, array);
 644
 645     return E_NOTIMPL;
 646 }
 647
 648 static BOOL WINAPI d3drm_device3_GetDither(IDirect3DRMDevice3 *iface)
 649 {
 650     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 651
 652     TRACE("iface %p.\n", iface);
 653
 654     return device->dither;
 655 }
 656
 657 static DWORD WINAPI d3drm_device3_GetShades(IDirect3DRMDevice3 *iface)
 658 {
 659     FIXME("iface %p stub!\n", iface);
 660
 661     return E_NOTIMPL;
 662 }
 663
 664 static DWORD WINAPI d3drm_device3_GetHeight(IDirect3DRMDevice3 *iface)
 665 {
 666     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 667
 668     TRACE("iface %p.\n", iface);
 669
 670     return device->height;
 671 }
 672
 673 static DWORD WINAPI d3drm_device3_GetWidth(IDirect3DRMDevice3 *iface)
 674 {
 675     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 676
 677     TRACE("iface %p.\n", iface);
 678
 679     return device->width;
 680 }
 681
 682 static DWORD WINAPI d3drm_device3_GetTrianglesDrawn(IDirect3DRMDevice3 *iface)
 683 {
 684     FIXME("iface %p stub!\n", iface);
 685
 686     return E_NOTIMPL;
 687 }
 688
 689 static DWORD WINAPI d3drm_device3_GetWireframeOptions(IDirect3DRMDevice3 *iface)
 690 {
 691     FIXME("iface %p stub!\n", iface);
 692
 693     return E_NOTIMPL;
 694 }
 695
 696 static D3DRMRENDERQUALITY WINAPI d3drm_device3_GetQuality(IDirect3DRMDevice3 *iface)
 697 {
 698     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 699
 700     TRACE("iface %p.\n", iface);
 701
 702     return device->quality;
 703 }
 704
 705 static D3DCOLORMODEL WINAPI d3drm_device3_GetColorModel(IDirect3DRMDevice3 *iface)
 706 {
 707     FIXME("iface %p stub!\n", iface);
 708
 709     return E_NOTIMPL;
 710 }
 711
 712 static D3DRMTEXTUREQUALITY WINAPI d3drm_device3_GetTextureQuality(IDirect3DRMDevice3 *iface)
 713 {
 714     FIXME("iface %p stub!\n", iface);
 715
 716     return E_NOTIMPL;
 717 }
 718
 719 static HRESULT WINAPI d3drm_device3_GetDirect3DDevice(IDirect3DRMDevice3 *iface, IDirect3DDevice **d3d_device)
 720 {
 721     FIXME("iface %p, d3d_device %p stub!\n", iface, d3d_device);
 722
 723     return E_NOTIMPL;
 724 }
 725
 726 static HRESULT WINAPI d3drm_device3_InitFromD3D2(IDirect3DRMDevice3 *iface,
 727         IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device)
 728 {
 729     FIXME("iface %p, d3d %p, d3d_device %p stub!\n", iface, d3d, d3d_device);
 730
 731     return E_NOTIMPL;
 732 }
 733
 734 static HRESULT WINAPI d3drm_device3_InitFromSurface(IDirect3DRMDevice3 *iface,
 735         GUID *guid, IDirectDraw *ddraw, IDirectDrawSurface *backbuffer)
 736 {
 737     FIXME("iface %p, guid %s, ddraw %p, backbuffer %p stub!\n",
 738             iface, debugstr_guid(guid), ddraw, backbuffer);
 739
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT WINAPI d3drm_device3_SetRenderMode(IDirect3DRMDevice3 *iface, DWORD flags)
 744 {
 745     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 746
 747     TRACE("iface %p, flags %#x.\n", iface, flags);
 748
 749     device->rendermode = flags;
 750
 751     return D3DRM_OK;
 752 }
 753
 754 static DWORD WINAPI d3drm_device3_GetRenderMode(IDirect3DRMDevice3 *iface)
 755 {
 756     struct d3drm_device *device = impl_from_IDirect3DRMDevice3(iface);
 757
 758     TRACE("iface %p.\n", iface);
 759
 760     return device->rendermode;
 761 }
 762
 763 static HRESULT WINAPI d3drm_device3_GetDirect3DDevice2(IDirect3DRMDevice3 *iface, IDirect3DDevice2 **d3d_device)
 764 {
 765     FIXME("iface %p, d3d_device %p stub!\n", iface, d3d_device);
 766
 767     return E_NOTIMPL;
 768 }
 769
 770 static HRESULT WINAPI d3drm_device3_FindPreferredTextureFormat(IDirect3DRMDevice3 *iface,
 771         DWORD bitdepths, DWORD flags, DDPIXELFORMAT *pf)
 772 {
 773     FIXME("iface %p, bitdepths %u, flags %#x, pf %p stub!\n", iface, bitdepths, flags, pf);
 774
 775     return E_NOTIMPL;
 776 }
 777
 778 static HRESULT WINAPI d3drm_device3_RenderStateChange(IDirect3DRMDevice3 *iface,
 779         D3DRENDERSTATETYPE state, DWORD value, DWORD flags)
 780 {
 781     FIXME("iface %p, state %#x, value %#x, flags %#x stub!\n", iface, state, value, flags);
 782
 783     return E_NOTIMPL;
 784 }
 785
 786 static HRESULT WINAPI d3drm_device3_LightStateChange(IDirect3DRMDevice3 *iface,
 787         D3DLIGHTSTATETYPE state, DWORD value, DWORD flags)
 788 {
 789     FIXME("iface %p, state %#x, value %#x, flags %#x stub!\n", iface, state, value, flags);
 790
 791     return E_NOTIMPL;
 792 }
 793
 794 static HRESULT WINAPI d3drm_device3_GetStateChangeOptions(IDirect3DRMDevice3 *iface,
 795         DWORD state_class, DWORD state_idx, DWORD *flags)
 796 {
 797     FIXME("iface %p, state_class %#x, state_idx %#x, flags %p stub!\n",
 798             iface, state_class, state_idx, flags);
 799
 800     return E_NOTIMPL;
 801 }
 802
 803 static HRESULT WINAPI d3drm_device3_SetStateChangeOptions(IDirect3DRMDevice3 *iface,
 804         DWORD state_class, DWORD state_idx, DWORD flags)
 805 {
 806     FIXME("iface %p, state_class %#x, state_idx %#x, flags %#x stub!\n",
 807             iface, state_class, state_idx, flags);
 808
 809     return E_NOTIMPL;
 810 }
 811
 812 static const struct IDirect3DRMDevice3Vtbl d3drm_device3_vtbl =
 813 {
 814     d3drm_device3_QueryInterface,
 815     d3drm_device3_AddRef,
 816     d3drm_device3_Release,
 817     d3drm_device3_Clone,
 818     d3drm_device3_AddDestroyCallback,
 819     d3drm_device3_DeleteDestroyCallback,
 820     d3drm_device3_SetAppData,
 821     d3drm_device3_GetAppData,
 822     d3drm_device3_SetName,
 823     d3drm_device3_GetName,
 824     d3drm_device3_GetClassName,
 825     d3drm_device3_Init,
 826     d3drm_device3_InitFromD3D,
 827     d3drm_device3_InitFromClipper,
 828     d3drm_device3_Update,
 829     d3drm_device3_AddUpdateCallback,
 830     d3drm_device3_DeleteUpdateCallback,
 831     d3drm_device3_SetBufferCount,
 832     d3drm_device3_GetBufferCount,
 833     d3drm_device3_SetDither,
 834     d3drm_device3_SetShades,
 835     d3drm_device3_SetQuality,
 836     d3drm_device3_SetTextureQuality,
 837     d3drm_device3_GetViewports,
 838     d3drm_device3_GetDither,
 839     d3drm_device3_GetShades,
 840     d3drm_device3_GetHeight,
 841     d3drm_device3_GetWidth,
 842     d3drm_device3_GetTrianglesDrawn,
 843     d3drm_device3_GetWireframeOptions,
 844     d3drm_device3_GetQuality,
 845     d3drm_device3_GetColorModel,
 846     d3drm_device3_GetTextureQuality,
 847     d3drm_device3_GetDirect3DDevice,
 848     d3drm_device3_InitFromD3D2,
 849     d3drm_device3_InitFromSurface,
 850     d3drm_device3_SetRenderMode,
 851     d3drm_device3_GetRenderMode,
 852     d3drm_device3_GetDirect3DDevice2,
 853     d3drm_device3_FindPreferredTextureFormat,
 854     d3drm_device3_RenderStateChange,
 855     d3drm_device3_LightStateChange,
 856     d3drm_device3_GetStateChangeOptions,
 857     d3drm_device3_SetStateChangeOptions,
 858 };
 859
 860 static HRESULT WINAPI d3drm_device_win_QueryInterface(IDirect3DRMWinDevice *iface, REFIID riid, void **out)
 861 {
 862     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
 863
 864     return d3drm_device2_QueryInterface(&device->IDirect3DRMDevice2_iface, riid, out);
 865 }
 866
 867 static ULONG WINAPI d3drm_device_win_AddRef(IDirect3DRMWinDevice *iface)
 868 {
 869     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
 870
 871     return d3drm_device2_AddRef(&device->IDirect3DRMDevice2_iface);
 872 }
 873
 874 static ULONG WINAPI d3drm_device_win_Release(IDirect3DRMWinDevice *iface)
 875 {
 876     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
 877
 878     return d3drm_device2_Release(&device->IDirect3DRMDevice2_iface);
 879 }
 880
 881 static HRESULT WINAPI d3drm_device_win_Clone(IDirect3DRMWinDevice *iface,
 882         IUnknown *outer, REFIID iid, void **out)
 883 {
 884     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
 885
 886     return E_NOTIMPL;
 887 }
 888
 889 static HRESULT WINAPI d3drm_device_win_AddDestroyCallback(IDirect3DRMWinDevice *iface,
 890         D3DRMOBJECTCALLBACK cb, void *ctx)
 891 {
 892     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 893
 894     return E_NOTIMPL;
 895 }
 896
 897 static HRESULT WINAPI d3drm_device_win_DeleteDestroyCallback(IDirect3DRMWinDevice *iface,
 898         D3DRMOBJECTCALLBACK cb, void *ctx)
 899 {
 900     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 901
 902     return E_NOTIMPL;
 903 }
 904
 905 static HRESULT WINAPI d3drm_device_win_SetAppData(IDirect3DRMWinDevice *iface, DWORD data)
 906 {
 907     FIXME("iface %p, data %#x stub!\n", iface, data);
 908
 909     return E_NOTIMPL;
 910 }
 911
 912 static DWORD WINAPI d3drm_device_win_GetAppData(IDirect3DRMWinDevice *iface)
 913 {
 914     FIXME("iface %p stub!\n", iface);
 915
 916     return 0;
 917 }
 918
 919 static HRESULT WINAPI d3drm_device_win_SetName(IDirect3DRMWinDevice *iface, const char *name)
 920 {
 921     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
 922
 923     return E_NOTIMPL;
 924 }
 925
 926 static HRESULT WINAPI d3drm_device_win_GetName(IDirect3DRMWinDevice *iface, DWORD *size, char *name)
 927 {
 928     FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
 929
 930     return E_NOTIMPL;
 931 }
 932
 933 static HRESULT WINAPI d3drm_device_win_GetClassName(IDirect3DRMWinDevice *iface, DWORD *size, char *name)
 934 {
 935     struct d3drm_device *device = impl_from_IDirect3DRMWinDevice(iface);
 936
 937     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 938
 939     return IDirect3DRMDevice3_GetClassName(&device->IDirect3DRMDevice3_iface, size, name);
 940 }
 941
 942 static HRESULT WINAPI d3drm_device_win_HandlePaint(IDirect3DRMWinDevice *iface, HDC dc)
 943 {
 944     FIXME("iface %p, dc %p stub!\n", iface, dc);
 945
 946     return D3DRM_OK;
 947 }
 948
 949 static HRESULT WINAPI d3drm_device_win_HandleActivate(IDirect3DRMWinDevice *iface, WORD wparam)
 950 {
 951     FIXME("iface %p, wparam %#x stub!\n", iface, wparam);
 952
 953     return D3DRM_OK;
 954 }
 955
 956 static const struct IDirect3DRMWinDeviceVtbl d3drm_device_win_vtbl =
 957 {
 958     d3drm_device_win_QueryInterface,
 959     d3drm_device_win_AddRef,
 960     d3drm_device_win_Release,
 961     d3drm_device_win_Clone,
 962     d3drm_device_win_AddDestroyCallback,
 963     d3drm_device_win_DeleteDestroyCallback,
 964     d3drm_device_win_SetAppData,
 965     d3drm_device_win_GetAppData,
 966     d3drm_device_win_SetName,
 967     d3drm_device_win_GetName,
 968     d3drm_device_win_GetClassName,
 969     d3drm_device_win_HandlePaint,
 970     d3drm_device_win_HandleActivate,
 971 };
 972
 973 HRESULT Direct3DRMDevice_create(REFIID riid, IUnknown **out)
 974 {
 975     struct d3drm_device *object;
 976
 977     TRACE("riid %s, out %p.\n", debugstr_guid(riid), out);
 978
 979     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 980         return E_OUTOFMEMORY;
 981
 982     object->IDirect3DRMDevice2_iface.lpVtbl = &d3drm_device2_vtbl;
 983     object->IDirect3DRMDevice3_iface.lpVtbl = &d3drm_device3_vtbl;
 984     object->IDirect3DRMWinDevice_iface.lpVtbl = &d3drm_device_win_vtbl;
 985     object->ref = 1;
 986
 987     if (IsEqualGUID(riid, &IID_IDirect3DRMDevice3))
 988         *out = (IUnknown*)&object->IDirect3DRMDevice3_iface;
 989     else
 990         *out = (IUnknown*)&object->IDirect3DRMDevice2_iface;
 991
 992     return S_OK;
 993 }