dlls/d3drm/d3drm.c

   1 /*
   2  * Implementation of IDirect3DRM Interface
   3  *
   4  * Copyright 2010, 2012 Christian Costa
   5  * Copyright 2011 André Hentschel
   6  * Copyright 2016 Aaryaman Vasishta
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "wine/debug.h"
  24
  25 #define COBJMACROS
  26
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "dxfile.h"
  30 #include "rmxfguid.h"
  31
  32 #include "d3drm_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(d3drm);
  35
  36 static const char* get_IID_string(const GUID* guid)
  37 {
  38     if (IsEqualGUID(guid, &IID_IDirect3DRMFrame))
  39         return "IID_IDirect3DRMFrame";
  40     else if (IsEqualGUID(guid, &IID_IDirect3DRMFrame2))
  41         return "IID_IDirect3DRMFrame2";
  42     else if (IsEqualGUID(guid, &IID_IDirect3DRMFrame3))
  43         return "IID_IDirect3DRMFrame3";
  44     else if (IsEqualGUID(guid, &IID_IDirect3DRMMeshBuilder))
  45         return "IID_IDirect3DRMMeshBuilder";
  46     else if (IsEqualGUID(guid, &IID_IDirect3DRMMeshBuilder2))
  47         return "IID_IDirect3DRMMeshBuilder2";
  48     else if (IsEqualGUID(guid, &IID_IDirect3DRMMeshBuilder3))
  49         return "IID_IDirect3DRMMeshBuilder3";
  50
  51     return "?";
  52 }
  53
  54 static HRESULT d3drm_create_texture_object(void **object, IDirect3DRM *d3drm)
  55 {
  56     struct d3drm_texture *texture;
  57     HRESULT hr;
  58
  59     if (FAILED(hr = d3drm_texture_create(&texture, d3drm)))
  60         return hr;
  61
  62     *object = &texture->IDirect3DRMTexture_iface;
  63
  64     return hr;
  65 }
  66
  67 static HRESULT d3drm_create_device_object(void **object, IDirect3DRM *d3drm)
  68 {
  69     struct d3drm_device *device;
  70     HRESULT hr;
  71
  72     if (FAILED(hr = d3drm_device_create(&device, d3drm)))
  73         return hr;
  74
  75     *object = &device->IDirect3DRMDevice_iface;
  76
  77     return hr;
  78 }
  79
  80 struct d3drm
  81 {
  82     IDirect3DRM IDirect3DRM_iface;
  83     IDirect3DRM2 IDirect3DRM2_iface;
  84     IDirect3DRM3 IDirect3DRM3_iface;
  85     LONG ref1, ref2, ref3, iface_count;
  86 };
  87
  88 static inline struct d3drm *impl_from_IDirect3DRM(IDirect3DRM *iface)
  89 {
  90     return CONTAINING_RECORD(iface, struct d3drm, IDirect3DRM_iface);
  91 }
  92
  93 static inline struct d3drm *impl_from_IDirect3DRM2(IDirect3DRM2 *iface)
  94 {
  95     return CONTAINING_RECORD(iface, struct d3drm, IDirect3DRM2_iface);
  96 }
  97
  98 static inline struct d3drm *impl_from_IDirect3DRM3(IDirect3DRM3 *iface)
  99 {
 100     return CONTAINING_RECORD(iface, struct d3drm, IDirect3DRM3_iface);
 101 }
 102
 103 static void d3drm_destroy(struct d3drm *d3drm)
 104 {
 105     HeapFree(GetProcessHeap(), 0, d3drm);
 106     TRACE("d3drm object %p is being destroyed.\n", d3drm);
 107 }
 108
 109 static HRESULT WINAPI d3drm1_QueryInterface(IDirect3DRM *iface, REFIID riid, void **out)
 110 {
 111     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 112
 113     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 114
 115     if (IsEqualGUID(riid, &IID_IDirect3DRM)
 116             || IsEqualGUID(riid, &IID_IUnknown))
 117     {
 118         *out = &d3drm->IDirect3DRM_iface;
 119     }
 120     else if (IsEqualGUID(riid, &IID_IDirect3DRM2))
 121     {
 122         *out = &d3drm->IDirect3DRM2_iface;
 123     }
 124     else if (IsEqualGUID(riid, &IID_IDirect3DRM3))
 125     {
 126         *out = &d3drm->IDirect3DRM3_iface;
 127     }
 128     else
 129     {
 130         *out = NULL;
 131         WARN("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(riid));
 132         return CLASS_E_CLASSNOTAVAILABLE;
 133     }
 134
 135     IUnknown_AddRef((IUnknown *)*out);
 136     return S_OK;
 137 }
 138
 139 static ULONG WINAPI d3drm1_AddRef(IDirect3DRM *iface)
 140 {
 141     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 142     ULONG refcount = InterlockedIncrement(&d3drm->ref1);
 143
 144     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 145
 146     if (refcount == 1)
 147         InterlockedIncrement(&d3drm->iface_count);
 148
 149     return refcount;
 150 }
 151
 152 static ULONG WINAPI d3drm1_Release(IDirect3DRM *iface)
 153 {
 154     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 155     ULONG refcount = InterlockedDecrement(&d3drm->ref1);
 156
 157     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 158
 159     if (!refcount && !InterlockedDecrement(&d3drm->iface_count))
 160         d3drm_destroy(d3drm);
 161
 162     return refcount;
 163 }
 164
 165 static HRESULT WINAPI d3drm1_CreateObject(IDirect3DRM *iface,
 166         REFCLSID clsid, IUnknown *outer, REFIID iid, void **out)
 167 {
 168     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 169
 170     TRACE("iface %p, clsid %s, outer %p, iid %s, out %p.\n",
 171             iface, debugstr_guid(clsid), outer, debugstr_guid(iid), out);
 172
 173     return IDirect3DRM3_CreateObject(&d3drm->IDirect3DRM3_iface, clsid, outer, iid, out);
 174 }
 175
 176 static HRESULT WINAPI d3drm1_CreateFrame(IDirect3DRM *iface,
 177         IDirect3DRMFrame *parent_frame, IDirect3DRMFrame **frame)
 178 {
 179     struct d3drm_frame *object;
 180     HRESULT hr;
 181
 182     TRACE("iface %p, parent_frame %p, frame %p.\n", iface, parent_frame, frame);
 183
 184     if (FAILED(hr = d3drm_frame_create(&object, (IUnknown *)parent_frame, iface)))
 185         return hr;
 186
 187     *frame = &object->IDirect3DRMFrame_iface;
 188
 189     return D3DRM_OK;
 190 }
 191
 192 static HRESULT WINAPI d3drm1_CreateMesh(IDirect3DRM *iface, IDirect3DRMMesh **mesh)
 193 {
 194     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 195
 196     TRACE("iface %p, mesh %p.\n", iface, mesh);
 197
 198     return IDirect3DRM3_CreateMesh(&d3drm->IDirect3DRM3_iface, mesh);
 199 }
 200
 201 static HRESULT WINAPI d3drm1_CreateMeshBuilder(IDirect3DRM *iface, IDirect3DRMMeshBuilder **mesh_builder)
 202 {
 203     TRACE("iface %p, mesh_builder %p.\n", iface, mesh_builder);
 204
 205     return Direct3DRMMeshBuilder_create(&IID_IDirect3DRMMeshBuilder, (IUnknown **)mesh_builder);
 206 }
 207
 208 static HRESULT WINAPI d3drm1_CreateFace(IDirect3DRM *iface, IDirect3DRMFace **face)
 209 {
 210     TRACE("iface %p, face %p.\n", iface, face);
 211
 212     return Direct3DRMFace_create(&IID_IDirect3DRMFace, (IUnknown **)face);
 213 }
 214
 215 static HRESULT WINAPI d3drm1_CreateAnimation(IDirect3DRM *iface, IDirect3DRMAnimation **animation)
 216 {
 217     FIXME("iface %p, animation %p stub!\n", iface, animation);
 218
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI d3drm1_CreateAnimationSet(IDirect3DRM *iface, IDirect3DRMAnimationSet **set)
 223 {
 224     FIXME("iface %p, set %p stub!\n", iface, set);
 225
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT WINAPI d3drm1_CreateTexture(IDirect3DRM *iface,
 230         D3DRMIMAGE *image, IDirect3DRMTexture **texture)
 231 {
 232     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 233     IDirect3DRMTexture3 *texture3;
 234     HRESULT hr;
 235
 236     TRACE("iface %p, image %p, texture %p.\n", iface, image, texture);
 237
 238     if (!texture)
 239         return D3DRMERR_BADVALUE;
 240
 241     if (FAILED(hr = IDirect3DRM3_CreateTexture(&d3drm->IDirect3DRM3_iface, image, &texture3)))
 242     {
 243         *texture = NULL;
 244         return hr;
 245     }
 246
 247     hr = IDirect3DRMTexture3_QueryInterface(texture3, &IID_IDirect3DRMTexture, (void **)texture);
 248     IDirect3DRMTexture3_Release(texture3);
 249
 250     return hr;
 251 }
 252
 253 static HRESULT WINAPI d3drm1_CreateLight(IDirect3DRM *iface,
 254         D3DRMLIGHTTYPE type, D3DCOLOR color, IDirect3DRMLight **light)
 255 {
 256     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 257
 258     TRACE("iface %p, type %#x, color 0x%08x, light %p.\n", iface, type, color, light);
 259
 260     return IDirect3DRM3_CreateLight(&d3drm->IDirect3DRM3_iface, type, color, light);
 261 }
 262
 263 static HRESULT WINAPI d3drm1_CreateLightRGB(IDirect3DRM *iface, D3DRMLIGHTTYPE type,
 264         D3DVALUE red, D3DVALUE green, D3DVALUE blue, IDirect3DRMLight **light)
 265 {
 266     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 267
 268     TRACE("iface %p, type %#x, red %.8e, green %.8e, blue %.8e, light %p.\n",
 269             iface, type, red, green, blue, light);
 270
 271     return IDirect3DRM3_CreateLightRGB(&d3drm->IDirect3DRM3_iface, type, red, green, blue, light);
 272 }
 273
 274 static HRESULT WINAPI d3drm1_CreateMaterial(IDirect3DRM *iface,
 275         D3DVALUE power, IDirect3DRMMaterial **material)
 276 {
 277     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 278
 279     TRACE("iface %p, power %.8e, material %p.\n", iface, power, material);
 280
 281     return IDirect3DRM3_CreateMaterial(&d3drm->IDirect3DRM3_iface, power, (IDirect3DRMMaterial2 **)material);
 282 }
 283
 284 static HRESULT WINAPI d3drm1_CreateDevice(IDirect3DRM *iface,
 285         DWORD width, DWORD height, IDirect3DRMDevice **device)
 286 {
 287     struct d3drm_device *object;
 288     HRESULT hr;
 289
 290     FIXME("iface %p, width %u, height %u, device %p partial stub!\n", iface, width, height, device);
 291
 292     if (FAILED(hr = d3drm_device_create(&object, iface)))
 293         return hr;
 294
 295     *device = &object->IDirect3DRMDevice_iface;
 296
 297     return D3DRM_OK;
 298 }
 299
 300 static HRESULT WINAPI d3drm1_CreateDeviceFromSurface(IDirect3DRM *iface, GUID *guid,
 301         IDirectDraw *ddraw, IDirectDrawSurface *backbuffer, IDirect3DRMDevice **device)
 302 {
 303     struct d3drm_device *object;
 304     HRESULT hr;
 305
 306     TRACE("iface %p, guid %s, ddraw %p, backbuffer %p, device %p.\n",
 307             iface, debugstr_guid(guid), ddraw, backbuffer, device);
 308
 309     if (!device)
 310         return D3DRMERR_BADVALUE;
 311     *device = NULL;
 312
 313     if (!backbuffer || !ddraw)
 314         return D3DRMERR_BADDEVICE;
 315
 316     if (FAILED(hr = d3drm_device_create(&object, iface)))
 317         return hr;
 318
 319     if (SUCCEEDED(hr = d3drm_device_init(object, 1, ddraw, backbuffer, TRUE)))
 320         *device = &object->IDirect3DRMDevice_iface;
 321     else
 322         d3drm_device_destroy(object);
 323
 324     return hr;
 325 }
 326
 327 static HRESULT WINAPI d3drm1_CreateDeviceFromD3D(IDirect3DRM *iface,
 328         IDirect3D *d3d, IDirect3DDevice *d3d_device, IDirect3DRMDevice **device)
 329 {
 330     struct d3drm_device *object;
 331     HRESULT hr;
 332     TRACE("iface %p, d3d %p, d3d_device %p, device %p.\n",
 333             iface, d3d, d3d_device, device);
 334
 335     if (!device)
 336         return D3DRMERR_BADVALUE;
 337     *device = NULL;
 338
 339     if (FAILED(hr = d3drm_device_create(&object, iface)))
 340         return hr;
 341
 342     if (FAILED(hr = IDirect3DRMDevice_InitFromD3D(&object->IDirect3DRMDevice_iface, d3d, d3d_device)))
 343     {
 344         d3drm_device_destroy(object);
 345         return hr;
 346     }
 347     *device = &object->IDirect3DRMDevice_iface;
 348
 349     return D3DRM_OK;
 350 }
 351
 352 static HRESULT WINAPI d3drm1_CreateDeviceFromClipper(IDirect3DRM *iface,
 353         IDirectDrawClipper *clipper, GUID *guid, int width, int height,
 354         IDirect3DRMDevice **device)
 355 {
 356     struct d3drm_device *object;
 357     IDirectDraw *ddraw;
 358     IDirectDrawSurface *render_target;
 359     HRESULT hr;
 360
 361     TRACE("iface %p, clipper %p, guid %s, width %d, height %d, device %p.\n",
 362             iface, clipper, debugstr_guid(guid), width, height, device);
 363
 364     if (!device)
 365         return D3DRMERR_BADVALUE;
 366     *device = NULL;
 367
 368     if (!clipper || !width || !height)
 369         return D3DRMERR_BADVALUE;
 370
 371     hr = DirectDrawCreate(NULL, &ddraw, NULL);
 372     if (FAILED(hr))
 373         return hr;
 374
 375     if (FAILED(hr = d3drm_device_create(&object, iface)))
 376     {
 377         IDirectDraw_Release(ddraw);
 378         return hr;
 379     }
 380
 381     hr = d3drm_device_create_surfaces_from_clipper(object, ddraw, clipper, width, height, &render_target);
 382     if (FAILED(hr))
 383     {
 384         IDirectDraw_Release(ddraw);
 385         d3drm_device_destroy(object);
 386         return hr;
 387     }
 388
 389     hr = d3drm_device_init(object, 1, ddraw, render_target, TRUE);
 390     IDirectDraw_Release(ddraw);
 391     IDirectDrawSurface_Release(render_target);
 392     if (FAILED(hr))
 393         d3drm_device_destroy(object);
 394     else
 395         *device = &object->IDirect3DRMDevice_iface;
 396
 397     return hr;
 398 }
 399
 400 static HRESULT WINAPI d3drm1_CreateTextureFromSurface(IDirect3DRM *iface,
 401         IDirectDrawSurface *surface, IDirect3DRMTexture **texture)
 402 {
 403     FIXME("iface %p, surface %p, texture %p stub!\n", iface, surface, texture);
 404
 405     return E_NOTIMPL;
 406 }
 407
 408 static HRESULT WINAPI d3drm1_CreateShadow(IDirect3DRM *iface, IDirect3DRMVisual *visual,
 409         IDirect3DRMLight *light, D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz,
 410         IDirect3DRMVisual **shadow)
 411 {
 412     FIXME("iface %p, visual %p, light %p, px %.8e, py %.8e, pz %.8e, nx %.8e, ny %.8e, nz %.8e, shadow %p stub!\n",
 413             iface, visual, light, px, py, pz, nx, ny, nz, shadow);
 414
 415     return E_NOTIMPL;
 416 }
 417
 418 static HRESULT WINAPI d3drm1_CreateViewport(IDirect3DRM *iface, IDirect3DRMDevice *device,
 419         IDirect3DRMFrame *camera, DWORD x, DWORD y, DWORD width, DWORD height, IDirect3DRMViewport **viewport)
 420 {
 421     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 422
 423     FIXME("iface %p, device %p, camera %p, x %u, y %u, width %u, height %u, viewport %p partial stub!\n",
 424             iface, device, camera, x, y, width, height, viewport);
 425
 426     return IDirect3DRM2_CreateViewport(&d3drm->IDirect3DRM2_iface, device, camera, x, y, width, height, viewport);
 427 }
 428
 429 static HRESULT WINAPI d3drm1_CreateWrap(IDirect3DRM *iface, D3DRMWRAPTYPE type, IDirect3DRMFrame *frame,
 430         D3DVALUE ox, D3DVALUE oy, D3DVALUE oz, D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
 431         D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov, D3DVALUE su, D3DVALUE sv,
 432         IDirect3DRMWrap **wrap)
 433 {
 434     FIXME("iface %p, type %#x, frame %p, ox %.8e, oy %.8e, oz %.8e, dx %.8e, dy %.8e, dz %.8e, "
 435             "ux %.8e, uy %.8e, uz %.8e, ou %.8e, ov %.8e, su %.8e, sv %.8e, wrap %p stub!\n",
 436             iface, type, frame, ox, oy, oz, dx, dy, dz, ux, uy, uz, ou, ov, su, sv, wrap);
 437
 438     return E_NOTIMPL;
 439 }
 440
 441 static HRESULT WINAPI d3drm1_CreateUserVisual(IDirect3DRM *iface,
 442         D3DRMUSERVISUALCALLBACK cb, void *ctx, IDirect3DRMUserVisual **visual)
 443 {
 444     FIXME("iface %p, cb %p, ctx %p visual %p stub!\n", iface, cb, ctx, visual);
 445
 446     return E_NOTIMPL;
 447 }
 448
 449 static HRESULT WINAPI d3drm1_LoadTexture(IDirect3DRM *iface,
 450         const char *filename, IDirect3DRMTexture **texture)
 451 {
 452     struct d3drm_texture *object;
 453     HRESULT hr;
 454
 455     FIXME("iface %p, filename %s, texture %p stub!\n", iface, debugstr_a(filename), texture);
 456
 457     if (FAILED(hr = d3drm_texture_create(&object, iface)))
 458         return hr;
 459
 460     *texture = &object->IDirect3DRMTexture_iface;
 461
 462     return D3DRM_OK;
 463 }
 464
 465 static HRESULT WINAPI d3drm1_LoadTextureFromResource(IDirect3DRM *iface,
 466         HRSRC resource, IDirect3DRMTexture **texture)
 467 {
 468     struct d3drm_texture *object;
 469     HRESULT hr;
 470
 471     FIXME("iface %p, resource %p, texture %p stub!\n", iface, resource, texture);
 472
 473     if (FAILED(hr = d3drm_texture_create(&object, iface)))
 474         return hr;
 475
 476     *texture = &object->IDirect3DRMTexture_iface;
 477
 478     return D3DRM_OK;
 479 }
 480
 481 static HRESULT WINAPI d3drm1_SetSearchPath(IDirect3DRM *iface, const char *path)
 482 {
 483     FIXME("iface %p, path %s stub!\n", iface, debugstr_a(path));
 484
 485     return E_NOTIMPL;
 486 }
 487
 488 static HRESULT WINAPI d3drm1_AddSearchPath(IDirect3DRM *iface, const char *path)
 489 {
 490     FIXME("iface %p, path %s stub!\n", iface, debugstr_a(path));
 491
 492     return E_NOTIMPL;
 493 }
 494
 495 static HRESULT WINAPI d3drm1_GetSearchPath(IDirect3DRM *iface, DWORD *size, char *path)
 496 {
 497     FIXME("iface %p, size %p, path %p stub!\n", iface, size, path);
 498
 499     return E_NOTIMPL;
 500 }
 501
 502 static HRESULT WINAPI d3drm1_SetDefaultTextureColors(IDirect3DRM *iface, DWORD color_count)
 503 {
 504     FIXME("iface %p, color_count %u stub!\n", iface, color_count);
 505
 506     return E_NOTIMPL;
 507 }
 508
 509 static HRESULT WINAPI d3drm1_SetDefaultTextureShades(IDirect3DRM *iface, DWORD shade_count)
 510 {
 511     FIXME("iface %p, shade_count %u stub!\n", iface, shade_count);
 512
 513     return E_NOTIMPL;
 514 }
 515
 516 static HRESULT WINAPI d3drm1_GetDevices(IDirect3DRM *iface, IDirect3DRMDeviceArray **array)
 517 {
 518     FIXME("iface %p, array %p stub!\n", iface, array);
 519
 520     return E_NOTIMPL;
 521 }
 522
 523 static HRESULT WINAPI d3drm1_GetNamedObject(IDirect3DRM *iface,
 524         const char *name, IDirect3DRMObject **object)
 525 {
 526     FIXME("iface %p, name %s, object %p stub!\n", iface, debugstr_a(name), object);
 527
 528     return E_NOTIMPL;
 529 }
 530
 531 static HRESULT WINAPI d3drm1_EnumerateObjects(IDirect3DRM *iface, D3DRMOBJECTCALLBACK cb, void *ctx)
 532 {
 533     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 534
 535     return E_NOTIMPL;
 536 }
 537
 538 static HRESULT WINAPI d3drm1_Load(IDirect3DRM *iface, void *source, void *object_id, IID **iids,
 539         DWORD iid_count, D3DRMLOADOPTIONS flags, D3DRMLOADCALLBACK load_cb, void *load_ctx,
 540         D3DRMLOADTEXTURECALLBACK load_tex_cb, void *load_tex_ctx, IDirect3DRMFrame *parent_frame)
 541 {
 542     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 543     IDirect3DRMFrame3 *parent_frame3 = NULL;
 544     HRESULT hr = D3DRM_OK;
 545
 546     TRACE("iface %p, source %p, object_id %p, iids %p, iid_count %u, flags %#x, "
 547             "load_cb %p, load_ctx %p, load_tex_cb %p, load_tex_ctx %p, parent_frame %p.\n",
 548             iface, source, object_id, iids, iid_count, flags,
 549             load_cb, load_ctx, load_tex_cb, load_tex_ctx, parent_frame);
 550
 551     if (parent_frame)
 552         hr = IDirect3DRMFrame_QueryInterface(parent_frame, &IID_IDirect3DRMFrame3, (void **)&parent_frame3);
 553     if (SUCCEEDED(hr))
 554         hr = IDirect3DRM3_Load(&d3drm->IDirect3DRM3_iface, source, object_id, iids, iid_count,
 555                 flags, load_cb, load_ctx, load_tex_cb, load_tex_ctx, parent_frame3);
 556     if (parent_frame3)
 557         IDirect3DRMFrame3_Release(parent_frame3);
 558
 559     return hr;
 560 }
 561
 562 static HRESULT WINAPI d3drm1_Tick(IDirect3DRM *iface, D3DVALUE tick)
 563 {
 564     FIXME("iface %p, tick %.8e stub!\n", iface, tick);
 565
 566     return E_NOTIMPL;
 567 }
 568
 569 static const struct IDirect3DRMVtbl d3drm1_vtbl =
 570 {
 571     d3drm1_QueryInterface,
 572     d3drm1_AddRef,
 573     d3drm1_Release,
 574     d3drm1_CreateObject,
 575     d3drm1_CreateFrame,
 576     d3drm1_CreateMesh,
 577     d3drm1_CreateMeshBuilder,
 578     d3drm1_CreateFace,
 579     d3drm1_CreateAnimation,
 580     d3drm1_CreateAnimationSet,
 581     d3drm1_CreateTexture,
 582     d3drm1_CreateLight,
 583     d3drm1_CreateLightRGB,
 584     d3drm1_CreateMaterial,
 585     d3drm1_CreateDevice,
 586     d3drm1_CreateDeviceFromSurface,
 587     d3drm1_CreateDeviceFromD3D,
 588     d3drm1_CreateDeviceFromClipper,
 589     d3drm1_CreateTextureFromSurface,
 590     d3drm1_CreateShadow,
 591     d3drm1_CreateViewport,
 592     d3drm1_CreateWrap,
 593     d3drm1_CreateUserVisual,
 594     d3drm1_LoadTexture,
 595     d3drm1_LoadTextureFromResource,
 596     d3drm1_SetSearchPath,
 597     d3drm1_AddSearchPath,
 598     d3drm1_GetSearchPath,
 599     d3drm1_SetDefaultTextureColors,
 600     d3drm1_SetDefaultTextureShades,
 601     d3drm1_GetDevices,
 602     d3drm1_GetNamedObject,
 603     d3drm1_EnumerateObjects,
 604     d3drm1_Load,
 605     d3drm1_Tick,
 606 };
 607
 608 static HRESULT WINAPI d3drm2_QueryInterface(IDirect3DRM2 *iface, REFIID riid, void **out)
 609 {
 610     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 611
 612     return d3drm1_QueryInterface(&d3drm->IDirect3DRM_iface, riid, out);
 613 }
 614
 615 static ULONG WINAPI d3drm2_AddRef(IDirect3DRM2 *iface)
 616 {
 617     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 618     ULONG refcount = InterlockedIncrement(&d3drm->ref2);
 619
 620     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 621
 622     if (refcount == 1)
 623         InterlockedIncrement(&d3drm->iface_count);
 624
 625     return refcount;
 626 }
 627
 628 static ULONG WINAPI d3drm2_Release(IDirect3DRM2 *iface)
 629 {
 630     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 631     ULONG refcount = InterlockedDecrement(&d3drm->ref2);
 632
 633     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 634
 635     if (!refcount && !InterlockedDecrement(&d3drm->iface_count))
 636         d3drm_destroy(d3drm);
 637
 638     return refcount;
 639 }
 640
 641 static HRESULT WINAPI d3drm2_CreateObject(IDirect3DRM2 *iface,
 642         REFCLSID clsid, IUnknown *outer, REFIID iid, void **out)
 643 {
 644     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 645
 646     TRACE("iface %p, clsid %s, outer %p, iid %s, out %p.\n",
 647             iface, debugstr_guid(clsid), outer, debugstr_guid(iid), out);
 648
 649     return IDirect3DRM3_CreateObject(&d3drm->IDirect3DRM3_iface, clsid, outer, iid, out);
 650 }
 651
 652 static HRESULT WINAPI d3drm2_CreateFrame(IDirect3DRM2 *iface,
 653         IDirect3DRMFrame *parent_frame, IDirect3DRMFrame2 **frame)
 654 {
 655     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 656     struct d3drm_frame *object;
 657     HRESULT hr;
 658
 659     TRACE("iface %p, parent_frame %p, frame %p.\n", iface, parent_frame, frame);
 660
 661     if (FAILED(hr = d3drm_frame_create(&object, (IUnknown *)parent_frame, &d3drm->IDirect3DRM_iface)))
 662         return hr;
 663
 664     *frame = &object->IDirect3DRMFrame2_iface;
 665
 666     return D3DRM_OK;
 667 }
 668
 669 static HRESULT WINAPI d3drm2_CreateMesh(IDirect3DRM2 *iface, IDirect3DRMMesh **mesh)
 670 {
 671     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 672
 673     TRACE("iface %p, mesh %p.\n", iface, mesh);
 674
 675     return IDirect3DRM3_CreateMesh(&d3drm->IDirect3DRM3_iface, mesh);
 676 }
 677
 678 static HRESULT WINAPI d3drm2_CreateMeshBuilder(IDirect3DRM2 *iface, IDirect3DRMMeshBuilder2 **mesh_builder)
 679 {
 680     TRACE("iface %p, mesh_builder %p.\n", iface, mesh_builder);
 681
 682     return Direct3DRMMeshBuilder_create(&IID_IDirect3DRMMeshBuilder2, (IUnknown **)mesh_builder);
 683 }
 684
 685 static HRESULT WINAPI d3drm2_CreateFace(IDirect3DRM2 *iface, IDirect3DRMFace **face)
 686 {
 687     TRACE("iface %p, face %p.\n", iface, face);
 688
 689     return Direct3DRMFace_create(&IID_IDirect3DRMFace, (IUnknown **)face);
 690 }
 691
 692 static HRESULT WINAPI d3drm2_CreateAnimation(IDirect3DRM2 *iface, IDirect3DRMAnimation **animation)
 693 {
 694     FIXME("iface %p, animation %p stub!\n", iface, animation);
 695
 696     return E_NOTIMPL;
 697 }
 698
 699 static HRESULT WINAPI d3drm2_CreateAnimationSet(IDirect3DRM2 *iface, IDirect3DRMAnimationSet **set)
 700 {
 701     FIXME("iface %p, set %p stub!\n", iface, set);
 702
 703     return E_NOTIMPL;
 704 }
 705
 706 static HRESULT WINAPI d3drm2_CreateTexture(IDirect3DRM2 *iface,
 707         D3DRMIMAGE *image, IDirect3DRMTexture2 **texture)
 708 {
 709     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 710     IDirect3DRMTexture3 *texture3;
 711     HRESULT hr;
 712
 713     TRACE("iface %p, image %p, texture %p.\n", iface, image, texture);
 714
 715     if (!texture)
 716         return D3DRMERR_BADVALUE;
 717
 718     if (FAILED(hr = IDirect3DRM3_CreateTexture(&d3drm->IDirect3DRM3_iface, image, &texture3)))
 719     {
 720         *texture = NULL;
 721         return hr;
 722     }
 723
 724     hr = IDirect3DRMTexture3_QueryInterface(texture3, &IID_IDirect3DRMTexture2, (void **)texture);
 725     IDirect3DRMTexture3_Release(texture3);
 726
 727     return hr;
 728 }
 729
 730 static HRESULT WINAPI d3drm2_CreateLight(IDirect3DRM2 *iface,
 731         D3DRMLIGHTTYPE type, D3DCOLOR color, IDirect3DRMLight **light)
 732 {
 733     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 734
 735     TRACE("iface %p, type %#x, color 0x%08x, light %p.\n", iface, type, color, light);
 736
 737     return IDirect3DRM3_CreateLight(&d3drm->IDirect3DRM3_iface, type, color, light);
 738 }
 739
 740 static HRESULT WINAPI d3drm2_CreateLightRGB(IDirect3DRM2 *iface, D3DRMLIGHTTYPE type,
 741         D3DVALUE red, D3DVALUE green, D3DVALUE blue, IDirect3DRMLight **light)
 742 {
 743     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 744
 745     TRACE("iface %p, type %#x, red %.8e, green %.8e, blue %.8e, light %p.\n",
 746             iface, type, red, green, blue, light);
 747
 748     return IDirect3DRM3_CreateLightRGB(&d3drm->IDirect3DRM3_iface, type, red, green, blue, light);
 749 }
 750
 751 static HRESULT WINAPI d3drm2_CreateMaterial(IDirect3DRM2 *iface,
 752         D3DVALUE power, IDirect3DRMMaterial **material)
 753 {
 754     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 755
 756     TRACE("iface %p, power %.8e, material %p.\n", iface, power, material);
 757
 758     return IDirect3DRM3_CreateMaterial(&d3drm->IDirect3DRM3_iface, power, (IDirect3DRMMaterial2 **)material);
 759 }
 760
 761 static HRESULT WINAPI d3drm2_CreateDevice(IDirect3DRM2 *iface,
 762         DWORD width, DWORD height, IDirect3DRMDevice2 **device)
 763 {
 764     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 765     struct d3drm_device *object;
 766     HRESULT hr;
 767
 768     FIXME("iface %p, width %u, height %u, device %p partial stub!\n", iface, width, height, device);
 769
 770     if (FAILED(hr = d3drm_device_create(&object, &d3drm->IDirect3DRM_iface)))
 771         return hr;
 772
 773     *device = &object->IDirect3DRMDevice2_iface;
 774
 775     return D3DRM_OK;
 776 }
 777
 778 static HRESULT WINAPI d3drm2_CreateDeviceFromSurface(IDirect3DRM2 *iface, GUID *guid,
 779         IDirectDraw *ddraw, IDirectDrawSurface *backbuffer, IDirect3DRMDevice2 **device)
 780 {
 781     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 782     IDirect3DRMDevice3 *device3;
 783     HRESULT hr;
 784     TRACE("iface %p, guid %s, ddraw %p, backbuffer %p, device %p.\n",
 785             iface, debugstr_guid(guid), ddraw, backbuffer, device);
 786
 787     if (!device)
 788         return D3DRMERR_BADVALUE;
 789     *device = NULL;
 790     hr = IDirect3DRM3_CreateDeviceFromSurface(&d3drm->IDirect3DRM3_iface, guid, ddraw, backbuffer, 0, &device3);
 791     if (FAILED(hr))
 792         return hr;
 793
 794     hr = IDirect3DRMDevice3_QueryInterface(device3, &IID_IDirect3DRMDevice2, (void**)device);
 795     IDirect3DRMDevice3_Release(device3);
 796
 797     return hr;
 798 }
 799
 800 static HRESULT WINAPI d3drm2_CreateDeviceFromD3D(IDirect3DRM2 *iface,
 801     IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device, IDirect3DRMDevice2 **device)
 802 {
 803     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 804     IDirect3DRMDevice3 *device3;
 805     HRESULT hr;
 806
 807     TRACE("iface %p, d3d %p, d3d_device %p, device %p.\n",
 808             iface, d3d, d3d_device, device);
 809
 810     if (!device)
 811         return D3DRMERR_BADVALUE;
 812     *device = NULL;
 813
 814     hr = IDirect3DRM3_CreateDeviceFromD3D(&d3drm->IDirect3DRM3_iface, d3d, d3d_device, &device3);
 815     if (FAILED(hr))
 816         return hr;
 817
 818     hr = IDirect3DRMDevice3_QueryInterface(device3, &IID_IDirect3DRMDevice2, (void **)device);
 819     IDirect3DRMDevice3_Release(device3);
 820
 821     return hr;
 822 }
 823
 824 static HRESULT WINAPI d3drm2_CreateDeviceFromClipper(IDirect3DRM2 *iface,
 825         IDirectDrawClipper *clipper, GUID *guid, int width, int height,
 826         IDirect3DRMDevice2 **device)
 827 {
 828     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 829     IDirect3DRMDevice3 *device3;
 830     HRESULT hr;
 831
 832     TRACE("iface %p, clipper %p, guid %s, width %d, height %d, device %p.\n",
 833             iface, clipper, debugstr_guid(guid), width, height, device);
 834
 835     if (!device)
 836         return D3DRMERR_BADVALUE;
 837     *device = NULL;
 838     hr = IDirect3DRM3_CreateDeviceFromClipper(&d3drm->IDirect3DRM3_iface, clipper, guid, width, height, &device3);
 839     if (FAILED(hr))
 840         return hr;
 841
 842     hr = IDirect3DRMDevice3_QueryInterface(device3, &IID_IDirect3DRMDevice2, (void**)device);
 843     IDirect3DRMDevice3_Release(device3);
 844
 845     return hr;
 846 }
 847
 848 static HRESULT WINAPI d3drm2_CreateTextureFromSurface(IDirect3DRM2 *iface,
 849         IDirectDrawSurface *surface, IDirect3DRMTexture2 **texture)
 850 {
 851     FIXME("iface %p, surface %p, texture %p stub!\n", iface, surface, texture);
 852
 853     return E_NOTIMPL;
 854 }
 855
 856 static HRESULT WINAPI d3drm2_CreateShadow(IDirect3DRM2 *iface, IDirect3DRMVisual *visual,
 857         IDirect3DRMLight *light, D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz,
 858         IDirect3DRMVisual **shadow)
 859 {
 860     FIXME("iface %p, visual %p, light %p, px %.8e, py %.8e, pz %.8e, nx %.8e, ny %.8e, nz %.8e, shadow %p stub!\n",
 861             iface, visual, light, px, py, pz, nx, ny, nz, shadow);
 862
 863     return E_NOTIMPL;
 864 }
 865
 866 static HRESULT WINAPI d3drm2_CreateViewport(IDirect3DRM2 *iface, IDirect3DRMDevice *device,
 867         IDirect3DRMFrame *camera, DWORD x, DWORD y, DWORD width, DWORD height, IDirect3DRMViewport **viewport)
 868 {
 869     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 870     struct d3drm_viewport *object;
 871     HRESULT hr;
 872
 873     FIXME("iface %p, device %p, camera %p, x %u, y %u, width %u, height %u, viewport %p partial stub!\n",
 874             iface, device, camera, x, y, width, height, viewport);
 875
 876     if (FAILED(hr = d3drm_viewport_create(&object, &d3drm->IDirect3DRM_iface)))
 877         return hr;
 878
 879     *viewport = &object->IDirect3DRMViewport_iface;
 880
 881     return D3DRM_OK;
 882 }
 883
 884 static HRESULT WINAPI d3drm2_CreateWrap(IDirect3DRM2 *iface, D3DRMWRAPTYPE type, IDirect3DRMFrame *frame,
 885         D3DVALUE ox, D3DVALUE oy, D3DVALUE oz, D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
 886         D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov, D3DVALUE su, D3DVALUE sv,
 887         IDirect3DRMWrap **wrap)
 888 {
 889     FIXME("iface %p, type %#x, frame %p, ox %.8e, oy %.8e, oz %.8e, dx %.8e, dy %.8e, dz %.8e, "
 890             "ux %.8e, uy %.8e, uz %.8e, ou %.8e, ov %.8e, su %.8e, sv %.8e, wrap %p stub!\n",
 891             iface, type, frame, ox, oy, oz, dx, dy, dz, ux, uy, uz, ou, ov, su, sv, wrap);
 892
 893     return E_NOTIMPL;
 894 }
 895
 896 static HRESULT WINAPI d3drm2_CreateUserVisual(IDirect3DRM2 *iface,
 897         D3DRMUSERVISUALCALLBACK cb, void *ctx, IDirect3DRMUserVisual **visual)
 898 {
 899     FIXME("iface %p, cb %p, ctx %p, visual %p stub!\n", iface, cb, ctx, visual);
 900
 901     return E_NOTIMPL;
 902 }
 903
 904 static HRESULT WINAPI d3drm2_LoadTexture(IDirect3DRM2 *iface,
 905         const char *filename, IDirect3DRMTexture2 **texture)
 906 {
 907     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 908     struct d3drm_texture *object;
 909     HRESULT hr;
 910
 911     FIXME("iface %p, filename %s, texture %p stub!\n", iface, debugstr_a(filename), texture);
 912
 913     if (FAILED(hr = d3drm_texture_create(&object, &d3drm->IDirect3DRM_iface)))
 914         return hr;
 915
 916     *texture = &object->IDirect3DRMTexture2_iface;
 917
 918     return hr;
 919 }
 920
 921 static HRESULT WINAPI d3drm2_LoadTextureFromResource(IDirect3DRM2 *iface, HMODULE module,
 922         const char *resource_name, const char *resource_type, IDirect3DRMTexture2 **texture)
 923 {
 924     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 925     struct d3drm_texture *object;
 926     HRESULT hr;
 927
 928     FIXME("iface %p, resource_name %s, resource_type %s, texture %p stub!\n",
 929             iface, debugstr_a(resource_name), debugstr_a(resource_type), texture);
 930
 931     if (FAILED(hr = d3drm_texture_create(&object, &d3drm->IDirect3DRM_iface)))
 932         return hr;
 933
 934     *texture = &object->IDirect3DRMTexture2_iface;
 935
 936     return D3DRM_OK;
 937 }
 938
 939 static HRESULT WINAPI d3drm2_SetSearchPath(IDirect3DRM2 *iface, const char *path)
 940 {
 941     FIXME("iface %p, path %s stub!\n", iface, debugstr_a(path));
 942
 943     return E_NOTIMPL;
 944 }
 945
 946 static HRESULT WINAPI d3drm2_AddSearchPath(IDirect3DRM2 *iface, const char *path)
 947 {
 948     FIXME("iface %p, path %s stub!\n", iface, debugstr_a(path));
 949
 950     return E_NOTIMPL;
 951 }
 952
 953 static HRESULT WINAPI d3drm2_GetSearchPath(IDirect3DRM2 *iface, DWORD *size, char *path)
 954 {
 955     FIXME("iface %p, size %p, path %p stub!\n", iface, size, path);
 956
 957     return E_NOTIMPL;
 958 }
 959
 960 static HRESULT WINAPI d3drm2_SetDefaultTextureColors(IDirect3DRM2 *iface, DWORD color_count)
 961 {
 962     FIXME("iface %p, color_count %u stub!\n", iface, color_count);
 963
 964     return E_NOTIMPL;
 965 }
 966
 967 static HRESULT WINAPI d3drm2_SetDefaultTextureShades(IDirect3DRM2 *iface, DWORD shade_count)
 968 {
 969     FIXME("iface %p, shade_count %u stub!\n", iface, shade_count);
 970
 971     return E_NOTIMPL;
 972 }
 973
 974 static HRESULT WINAPI d3drm2_GetDevices(IDirect3DRM2 *iface, IDirect3DRMDeviceArray **array)
 975 {
 976     FIXME("iface %p, array %p stub!\n", iface, array);
 977
 978     return E_NOTIMPL;
 979 }
 980
 981 static HRESULT WINAPI d3drm2_GetNamedObject(IDirect3DRM2 *iface,
 982         const char *name, IDirect3DRMObject **object)
 983 {
 984     FIXME("iface %p, name %s, object %p stub!\n", iface, debugstr_a(name), object);
 985
 986     return E_NOTIMPL;
 987 }
 988
 989 static HRESULT WINAPI d3drm2_EnumerateObjects(IDirect3DRM2 *iface, D3DRMOBJECTCALLBACK cb, void *ctx)
 990 {
 991     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 992
 993     return E_NOTIMPL;
 994 }
 995
 996 static HRESULT WINAPI d3drm2_Load(IDirect3DRM2 *iface, void *source, void *object_id, IID **iids,
 997         DWORD iid_count, D3DRMLOADOPTIONS flags, D3DRMLOADCALLBACK load_cb, void *load_ctx,
 998         D3DRMLOADTEXTURECALLBACK load_tex_cb, void *load_tex_ctx, IDirect3DRMFrame *parent_frame)
 999 {
1000     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
1001     IDirect3DRMFrame3 *parent_frame3 = NULL;
1002     HRESULT hr = D3DRM_OK;
1003
1004     TRACE("iface %p, source %p, object_id %p, iids %p, iid_count %u, flags %#x, "
1005             "load_cb %p, load_ctx %p, load_tex_cb %p, load_tex_ctx %p, parent_frame %p.\n",
1006             iface, source, object_id, iids, iid_count, flags,
1007             load_cb, load_ctx, load_tex_cb, load_tex_ctx, parent_frame);
1008
1009     if (parent_frame)
1010         hr = IDirect3DRMFrame_QueryInterface(parent_frame, &IID_IDirect3DRMFrame3, (void **)&parent_frame3);
1011     if (SUCCEEDED(hr))
1012         hr = IDirect3DRM3_Load(&d3drm->IDirect3DRM3_iface, source, object_id, iids, iid_count,
1013                 flags, load_cb, load_ctx, load_tex_cb, load_tex_ctx, parent_frame3);
1014     if (parent_frame3)
1015         IDirect3DRMFrame3_Release(parent_frame3);
1016
1017     return hr;
1018 }
1019
1020 static HRESULT WINAPI d3drm2_Tick(IDirect3DRM2 *iface, D3DVALUE tick)
1021 {
1022     FIXME("iface %p, tick %.8e stub!\n", iface, tick);
1023
1024     return E_NOTIMPL;
1025 }
1026
1027 static HRESULT WINAPI d3drm2_CreateProgressiveMesh(IDirect3DRM2 *iface, IDirect3DRMProgressiveMesh **mesh)
1028 {
1029     FIXME("iface %p, mesh %p stub!\n", iface, mesh);
1030
1031     return E_NOTIMPL;
1032 }
1033
1034 static const struct IDirect3DRM2Vtbl d3drm2_vtbl =
1035 {
1036     d3drm2_QueryInterface,
1037     d3drm2_AddRef,
1038     d3drm2_Release,
1039     d3drm2_CreateObject,
1040     d3drm2_CreateFrame,
1041     d3drm2_CreateMesh,
1042     d3drm2_CreateMeshBuilder,
1043     d3drm2_CreateFace,
1044     d3drm2_CreateAnimation,
1045     d3drm2_CreateAnimationSet,
1046     d3drm2_CreateTexture,
1047     d3drm2_CreateLight,
1048     d3drm2_CreateLightRGB,
1049     d3drm2_CreateMaterial,
1050     d3drm2_CreateDevice,
1051     d3drm2_CreateDeviceFromSurface,
1052     d3drm2_CreateDeviceFromD3D,
1053     d3drm2_CreateDeviceFromClipper,
1054     d3drm2_CreateTextureFromSurface,
1055     d3drm2_CreateShadow,
1056     d3drm2_CreateViewport,
1057     d3drm2_CreateWrap,
1058     d3drm2_CreateUserVisual,
1059     d3drm2_LoadTexture,
1060     d3drm2_LoadTextureFromResource,
1061     d3drm2_SetSearchPath,
1062     d3drm2_AddSearchPath,
1063     d3drm2_GetSearchPath,
1064     d3drm2_SetDefaultTextureColors,
1065     d3drm2_SetDefaultTextureShades,
1066     d3drm2_GetDevices,
1067     d3drm2_GetNamedObject,
1068     d3drm2_EnumerateObjects,
1069     d3drm2_Load,
1070     d3drm2_Tick,
1071     d3drm2_CreateProgressiveMesh,
1072 };
1073
1074 static HRESULT WINAPI d3drm3_QueryInterface(IDirect3DRM3 *iface, REFIID riid, void **out)
1075 {
1076     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1077
1078     return d3drm1_QueryInterface(&d3drm->IDirect3DRM_iface, riid, out);
1079 }
1080
1081 static ULONG WINAPI d3drm3_AddRef(IDirect3DRM3 *iface)
1082 {
1083     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1084     ULONG refcount = InterlockedIncrement(&d3drm->ref3);
1085
1086     TRACE("%p increasing refcount to %u.\n", iface, refcount);
1087
1088     if (refcount == 1)
1089         InterlockedIncrement(&d3drm->iface_count);
1090
1091     return refcount;
1092 }
1093
1094 static ULONG WINAPI d3drm3_Release(IDirect3DRM3 *iface)
1095 {
1096     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1097     ULONG refcount = InterlockedDecrement(&d3drm->ref3);
1098
1099     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
1100
1101     if (!refcount && !InterlockedDecrement(&d3drm->iface_count))
1102         d3drm_destroy(d3drm);
1103
1104     return refcount;
1105 }
1106
1107 static HRESULT WINAPI d3drm3_CreateObject(IDirect3DRM3 *iface,
1108         REFCLSID clsid, IUnknown *outer, REFIID iid, void **out)
1109 {
1110     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1111     IUnknown *object;
1112     unsigned int i;
1113     HRESULT hr;
1114
1115     static const struct
1116     {
1117         const CLSID *clsid;
1118         HRESULT (*create_object)(void **object, IDirect3DRM *d3drm);
1119     }
1120     object_table[] =
1121     {
1122         {&CLSID_CDirect3DRMTexture, d3drm_create_texture_object},
1123         {&CLSID_CDirect3DRMDevice, d3drm_create_device_object},
1124     };
1125
1126     TRACE("iface %p, clsid %s, outer %p, iid %s, out %p.\n",
1127             iface, debugstr_guid(clsid), outer, debugstr_guid(iid), out);
1128
1129     if (!out)
1130         return D3DRMERR_BADVALUE;
1131
1132     if (!clsid || !iid)
1133     {
1134         *out = NULL;
1135         return D3DRMERR_BADVALUE;
1136     }
1137
1138     if (outer)
1139     {
1140         FIXME("COM aggregation for outer IUnknown (%p) not implemented. Returning E_NOTIMPL.\n", outer);
1141         *out = NULL;
1142         return E_NOTIMPL;
1143     }
1144
1145     for (i = 0; i < ARRAY_SIZE(object_table); ++i)
1146     {
1147         if (IsEqualGUID(clsid, object_table[i].clsid))
1148         {
1149             if (FAILED(hr = object_table[i].create_object((void **)&object, &d3drm->IDirect3DRM_iface)))
1150             {
1151                 *out = NULL;
1152                 return hr;
1153             }
1154             break;
1155         }
1156     }
1157     if (i == ARRAY_SIZE(object_table))
1158     {
1159         FIXME("%s not implemented. Returning CLASSFACTORY_E_FIRST.\n", debugstr_guid(clsid));
1160         *out = NULL;
1161         return CLASSFACTORY_E_FIRST;
1162     }
1163
1164     if (FAILED(hr = IUnknown_QueryInterface(object, iid, out)))
1165         *out = NULL;
1166     IUnknown_Release(object);
1167
1168     return hr;
1169 }
1170
1171 static HRESULT WINAPI d3drm3_CreateFrame(IDirect3DRM3 *iface,
1172         IDirect3DRMFrame3 *parent, IDirect3DRMFrame3 **frame)
1173 {
1174     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1175     struct d3drm_frame *object;
1176     HRESULT hr;
1177
1178     TRACE("iface %p, parent %p, frame %p.\n", iface, parent, frame);
1179
1180     if (FAILED(hr = d3drm_frame_create(&object, (IUnknown *)parent, &d3drm->IDirect3DRM_iface)))
1181         return hr;
1182
1183     *frame = &object->IDirect3DRMFrame3_iface;
1184
1185     return D3DRM_OK;
1186 }
1187
1188 static HRESULT WINAPI d3drm3_CreateMesh(IDirect3DRM3 *iface, IDirect3DRMMesh **mesh)
1189 {
1190     TRACE("iface %p, mesh %p.\n", iface, mesh);
1191
1192     return Direct3DRMMesh_create(mesh);
1193 }
1194
1195 static HRESULT WINAPI d3drm3_CreateMeshBuilder(IDirect3DRM3 *iface, IDirect3DRMMeshBuilder3 **mesh_builder)
1196 {
1197     TRACE("iface %p, mesh_builder %p.\n", iface, mesh_builder);
1198
1199     return Direct3DRMMeshBuilder_create(&IID_IDirect3DRMMeshBuilder3, (IUnknown **)mesh_builder);
1200 }
1201
1202 static HRESULT WINAPI d3drm3_CreateFace(IDirect3DRM3 *iface, IDirect3DRMFace2 **face)
1203 {
1204     TRACE("iface %p, face %p.\n", iface, face);
1205
1206     return Direct3DRMFace_create(&IID_IDirect3DRMFace2, (IUnknown **)face);
1207 }
1208
1209 static HRESULT WINAPI d3drm3_CreateAnimation(IDirect3DRM3 *iface, IDirect3DRMAnimation2 **animation)
1210 {
1211     FIXME("iface %p, animation %p stub!\n", iface, animation);
1212
1213     return E_NOTIMPL;
1214 }
1215
1216 static HRESULT WINAPI d3drm3_CreateAnimationSet(IDirect3DRM3 *iface, IDirect3DRMAnimationSet2 **set)
1217 {
1218     FIXME("iface %p, set %p stub!\n", iface, set);
1219
1220     return E_NOTIMPL;
1221 }
1222
1223 static HRESULT WINAPI d3drm3_CreateTexture(IDirect3DRM3 *iface,
1224         D3DRMIMAGE *image, IDirect3DRMTexture3 **texture)
1225 {
1226     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1227     struct d3drm_texture *object;
1228     HRESULT hr;
1229
1230     TRACE("iface %p, image %p, texture %p.\n", iface, image, texture);
1231
1232     if (!texture)
1233         return D3DRMERR_BADVALUE;
1234
1235     if (FAILED(hr = d3drm_texture_create(&object, &d3drm->IDirect3DRM_iface)))
1236         return hr;
1237
1238     *texture = &object->IDirect3DRMTexture3_iface;
1239
1240     if (FAILED(IDirect3DRMTexture3_InitFromImage(*texture, image)))
1241     {
1242         IDirect3DRMTexture3_Release(*texture);
1243         *texture = NULL;
1244         return D3DRMERR_BADVALUE;
1245     }
1246
1247     return D3DRM_OK;
1248 }
1249
1250 static HRESULT WINAPI d3drm3_CreateLight(IDirect3DRM3 *iface,
1251         D3DRMLIGHTTYPE type, D3DCOLOR color, IDirect3DRMLight **light)
1252 {
1253     HRESULT hr;
1254
1255     FIXME("iface %p, type %#x, color 0x%08x, light %p partial stub!\n", iface, type, color, light);
1256
1257     if (SUCCEEDED(hr = Direct3DRMLight_create((IUnknown **)light)))
1258     {
1259         IDirect3DRMLight_SetType(*light, type);
1260         IDirect3DRMLight_SetColor(*light, color);
1261     }
1262
1263     return hr;
1264 }
1265
1266 static HRESULT WINAPI d3drm3_CreateLightRGB(IDirect3DRM3 *iface, D3DRMLIGHTTYPE type,
1267         D3DVALUE red, D3DVALUE green, D3DVALUE blue, IDirect3DRMLight **light)
1268 {
1269     HRESULT hr;
1270
1271     FIXME("iface %p, type %#x, red %.8e, green %.8e, blue %.8e, light %p partial stub!\n",
1272             iface, type, red, green, blue, light);
1273
1274     if (SUCCEEDED(hr = Direct3DRMLight_create((IUnknown **)light)))
1275     {
1276         IDirect3DRMLight_SetType(*light, type);
1277         IDirect3DRMLight_SetColorRGB(*light, red, green, blue);
1278     }
1279
1280     return hr;
1281 }
1282
1283 static HRESULT WINAPI d3drm3_CreateMaterial(IDirect3DRM3 *iface,
1284         D3DVALUE power, IDirect3DRMMaterial2 **material)
1285 {
1286     HRESULT hr;
1287
1288     TRACE("iface %p, power %.8e, material %p.\n", iface, power, material);
1289
1290     if (SUCCEEDED(hr = Direct3DRMMaterial_create(material)))
1291         IDirect3DRMMaterial2_SetPower(*material, power);
1292
1293     return hr;
1294 }
1295
1296 static HRESULT WINAPI d3drm3_CreateDevice(IDirect3DRM3 *iface,
1297         DWORD width, DWORD height, IDirect3DRMDevice3 **device)
1298 {
1299     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1300     struct d3drm_device *object;
1301     HRESULT hr;
1302
1303     FIXME("iface %p, width %u, height %u, device %p partial stub!\n", iface, width, height, device);
1304
1305     if (FAILED(hr = d3drm_device_create(&object, &d3drm->IDirect3DRM_iface)))
1306         return hr;
1307
1308     *device = &object->IDirect3DRMDevice3_iface;
1309
1310     return D3DRM_OK;
1311 }
1312
1313 static HRESULT WINAPI d3drm3_CreateDeviceFromSurface(IDirect3DRM3 *iface, GUID *guid,
1314         IDirectDraw *ddraw, IDirectDrawSurface *backbuffer, DWORD flags, IDirect3DRMDevice3 **device)
1315 {
1316     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1317     struct d3drm_device *object;
1318     BOOL use_z_surface;
1319     HRESULT hr;
1320
1321     TRACE("iface %p, guid %s, ddraw %p, backbuffer %p, flags %#x, device %p.\n",
1322             iface, debugstr_guid(guid), ddraw, backbuffer, flags, device);
1323
1324     if (!device)
1325         return D3DRMERR_BADVALUE;
1326     *device = NULL;
1327
1328     if (!backbuffer || !ddraw)
1329         return D3DRMERR_BADDEVICE;
1330
1331     if (FAILED(hr = d3drm_device_create(&object, &d3drm->IDirect3DRM_iface)))
1332         return hr;
1333
1334     use_z_surface = !(flags & D3DRMDEVICE_NOZBUFFER);
1335
1336     if (SUCCEEDED(hr = d3drm_device_init(object, 3, ddraw, backbuffer, use_z_surface)))
1337         *device = &object->IDirect3DRMDevice3_iface;
1338     else
1339         d3drm_device_destroy(object);
1340
1341     return hr;
1342 }
1343
1344 static HRESULT WINAPI d3drm3_CreateDeviceFromD3D(IDirect3DRM3 *iface,
1345         IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device, IDirect3DRMDevice3 **device)
1346 {
1347     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1348     struct d3drm_device *object;
1349     HRESULT hr;
1350
1351     TRACE("iface %p, d3d %p, d3d_device %p, device %p.\n",
1352             iface, d3d, d3d_device, device);
1353
1354     if (!device)
1355         return D3DRMERR_BADVALUE;
1356     *device = NULL;
1357
1358     if (FAILED(hr = d3drm_device_create(&object, &d3drm->IDirect3DRM_iface)))
1359         return hr;
1360
1361     if (FAILED(hr = IDirect3DRMDevice3_InitFromD3D2(&object->IDirect3DRMDevice3_iface, d3d, d3d_device)))
1362     {
1363         d3drm_device_destroy(object);
1364         return hr;
1365     }
1366     *device = &object->IDirect3DRMDevice3_iface;
1367
1368     return D3DRM_OK;
1369 }
1370
1371 static HRESULT WINAPI d3drm3_CreateDeviceFromClipper(IDirect3DRM3 *iface,
1372         IDirectDrawClipper *clipper, GUID *guid, int width, int height,
1373         IDirect3DRMDevice3 **device)
1374 {
1375     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1376     struct d3drm_device *object;
1377     IDirectDraw *ddraw;
1378     IDirectDrawSurface *render_target;
1379     HRESULT hr;
1380
1381     TRACE("iface %p, clipper %p, guid %s, width %d, height %d, device %p.\n",
1382             iface, clipper, debugstr_guid(guid), width, height, device);
1383
1384     if (!device)
1385         return D3DRMERR_BADVALUE;
1386     *device = NULL;
1387
1388     if (!clipper || !width || !height)
1389         return D3DRMERR_BADVALUE;
1390
1391     hr = DirectDrawCreate(NULL, &ddraw, NULL);
1392     if (FAILED(hr))
1393         return hr;
1394
1395     if (FAILED(hr = d3drm_device_create(&object, &d3drm->IDirect3DRM_iface)))
1396     {
1397         IDirectDraw_Release(ddraw);
1398         return hr;
1399     }
1400
1401     hr = d3drm_device_create_surfaces_from_clipper(object, ddraw, clipper, width, height, &render_target);
1402     if (FAILED(hr))
1403     {
1404         IDirectDraw_Release(ddraw);
1405         d3drm_device_destroy(object);
1406         return hr;
1407     }
1408
1409     hr = d3drm_device_init(object, 3, ddraw, render_target, TRUE);
1410     IDirectDraw_Release(ddraw);
1411     IDirectDrawSurface_Release(render_target);
1412     if (FAILED(hr))
1413         d3drm_device_destroy(object);
1414     else
1415         *device = &object->IDirect3DRMDevice3_iface;
1416
1417     return hr;
1418 }
1419
1420 static HRESULT WINAPI d3drm3_CreateShadow(IDirect3DRM3 *iface, IUnknown *object, IDirect3DRMLight *light,
1421         D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz, IDirect3DRMShadow2 **shadow)
1422 {
1423     FIXME("iface %p, object %p, light %p, px %.8e, py %.8e, pz %.8e, nx %.8e, ny %.8e, nz %.8e, shadow %p stub!\n",
1424             iface, object, light, px, py, pz, nx, ny, nz, shadow);
1425
1426     return E_NOTIMPL;
1427 }
1428
1429 static HRESULT WINAPI d3drm3_CreateTextureFromSurface(IDirect3DRM3 *iface,
1430         IDirectDrawSurface *surface, IDirect3DRMTexture3 **texture)
1431 {
1432     FIXME("iface %p, surface %p, texture %p stub!\n", iface, surface, texture);
1433
1434     return E_NOTIMPL;
1435 }
1436
1437 static HRESULT WINAPI d3drm3_CreateViewport(IDirect3DRM3 *iface, IDirect3DRMDevice3 *device,
1438         IDirect3DRMFrame3 *camera, DWORD x, DWORD y, DWORD width, DWORD height, IDirect3DRMViewport2 **viewport)
1439 {
1440     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1441     struct d3drm_viewport *object;
1442     HRESULT hr;
1443
1444     FIXME("iface %p, device %p, camera %p, x %u, y %u, width %u, height %u, viewport %p partial stub!\n",
1445             iface, device, camera, x, y, width, height, viewport);
1446
1447     if (FAILED(hr = d3drm_viewport_create(&object, &d3drm->IDirect3DRM_iface)))
1448         return hr;
1449
1450     *viewport = &object->IDirect3DRMViewport2_iface;
1451
1452     return D3DRM_OK;
1453 }
1454
1455 static HRESULT WINAPI d3drm3_CreateWrap(IDirect3DRM3 *iface, D3DRMWRAPTYPE type, IDirect3DRMFrame3 *frame,
1456         D3DVALUE ox, D3DVALUE oy, D3DVALUE oz, D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
1457         D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov, D3DVALUE su, D3DVALUE sv,
1458         IDirect3DRMWrap **wrap)
1459 {
1460     FIXME("iface %p, type %#x, frame %p, ox %.8e, oy %.8e, oz %.8e, dx %.8e, dy %.8e, dz %.8e, "
1461             "ux %.8e, uy %.8e, uz %.8e, ou %.8e, ov %.8e, su %.8e, sv %.8e, wrap %p stub!\n",
1462             iface, type, frame, ox, oy, oz, dx, dy, dz, ux, uy, uz, ou, ov, su, sv, wrap);
1463
1464     return E_NOTIMPL;
1465 }
1466
1467 static HRESULT WINAPI d3drm3_CreateUserVisual(IDirect3DRM3 *iface,
1468         D3DRMUSERVISUALCALLBACK cb, void *ctx, IDirect3DRMUserVisual **visual)
1469 {
1470     FIXME("iface %p, cb %p, ctx %p, visual %p stub!\n", iface, cb, ctx, visual);
1471
1472     return E_NOTIMPL;
1473 }
1474
1475 static HRESULT WINAPI d3drm3_LoadTexture(IDirect3DRM3 *iface,
1476         const char *filename, IDirect3DRMTexture3 **texture)
1477 {
1478     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1479     struct d3drm_texture *object;
1480     HRESULT hr;
1481
1482     FIXME("iface %p, filename %s, texture %p stub!\n", iface, debugstr_a(filename), texture);
1483
1484     if (FAILED(hr = d3drm_texture_create(&object, &d3drm->IDirect3DRM_iface)))
1485         return hr;
1486
1487     *texture = &object->IDirect3DRMTexture3_iface;
1488
1489     return D3DRM_OK;
1490 }
1491
1492 static HRESULT WINAPI d3drm3_LoadTextureFromResource(IDirect3DRM3 *iface, HMODULE module,
1493         const char *resource_name, const char *resource_type, IDirect3DRMTexture3 **texture)
1494 {
1495     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
1496     struct d3drm_texture *object;
1497     HRESULT hr;
1498
1499     FIXME("iface %p, module %p, resource_name %s, resource_type %s, texture %p stub!\n",
1500             iface, module, debugstr_a(resource_name), debugstr_a(resource_type), texture);
1501
1502     if (FAILED(hr = d3drm_texture_create(&object, &d3drm->IDirect3DRM_iface)))
1503         return hr;
1504
1505     *texture = &object->IDirect3DRMTexture3_iface;
1506
1507     return D3DRM_OK;
1508 }
1509
1510 static HRESULT WINAPI d3drm3_SetSearchPath(IDirect3DRM3 *iface, const char *path)
1511 {
1512     FIXME("iface %p, path %s stub!\n", iface, debugstr_a(path));
1513
1514     return E_NOTIMPL;
1515 }
1516
1517 static HRESULT WINAPI d3drm3_AddSearchPath(IDirect3DRM3 *iface, const char *path)
1518 {
1519     FIXME("iface %p, path %s stub!\n", iface, debugstr_a(path));
1520
1521     return E_NOTIMPL;
1522 }
1523
1524 static HRESULT WINAPI d3drm3_GetSearchPath(IDirect3DRM3 *iface, DWORD *size, char *path)
1525 {
1526     FIXME("iface %p, size %p, path %p stub!\n", iface, size, path);
1527
1528     return E_NOTIMPL;
1529 }
1530
1531 static HRESULT WINAPI d3drm3_SetDefaultTextureColors(IDirect3DRM3 *iface, DWORD color_count)
1532 {
1533     FIXME("iface %p, color_count %u stub!\n", iface, color_count);
1534
1535     return E_NOTIMPL;
1536 }
1537
1538 static HRESULT WINAPI d3drm3_SetDefaultTextureShades(IDirect3DRM3 *iface, DWORD shade_count)
1539 {
1540     FIXME("iface %p, shade_count %u stub!\n", iface, shade_count);
1541
1542     return E_NOTIMPL;
1543 }
1544
1545 static HRESULT WINAPI d3drm3_GetDevices(IDirect3DRM3 *iface, IDirect3DRMDeviceArray **array)
1546 {
1547     FIXME("iface %p, array %p stub!\n", iface, array);
1548
1549     return E_NOTIMPL;
1550 }
1551
1552 static HRESULT WINAPI d3drm3_GetNamedObject(IDirect3DRM3 *iface,
1553         const char *name, IDirect3DRMObject **object)
1554 {
1555     FIXME("iface %p, name %s, object %p stub!\n", iface, debugstr_a(name), object);
1556
1557     return E_NOTIMPL;
1558 }
1559
1560 static HRESULT WINAPI d3drm3_EnumerateObjects(IDirect3DRM3 *iface, D3DRMOBJECTCALLBACK cb, void *ctx)
1561 {
1562     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1563
1564     return E_NOTIMPL;
1565 }
1566
1567 static HRESULT load_data(IDirect3DRM3 *iface, IDirectXFileData *data_object, IID **GUIDs, DWORD nb_GUIDs, D3DRMLOADCALLBACK LoadProc,
1568                          void *ArgLP, D3DRMLOADTEXTURECALLBACK LoadTextureProc, void *ArgLTP, IDirect3DRMFrame3 *parent_frame)
1569 {
1570     HRESULT ret = D3DRMERR_BADOBJECT;
1571     HRESULT hr;
1572     const GUID* guid;
1573     DWORD i;
1574     BOOL requested = FALSE;
1575
1576     hr = IDirectXFileData_GetType(data_object, &guid);
1577     if (hr != DXFILE_OK)
1578         goto end;
1579
1580     TRACE("Found object type whose GUID = %s\n", debugstr_guid(guid));
1581
1582     /* Load object only if it is top level and requested or if it is part of another object */
1583
1584     if (IsEqualGUID(guid, &TID_D3DRMMesh))
1585     {
1586         TRACE("Found TID_D3DRMMesh\n");
1587
1588         for (i = 0; i < nb_GUIDs; i++)
1589             if (IsEqualGUID(GUIDs[i], &IID_IDirect3DRMMeshBuilder) ||
1590                 IsEqualGUID(GUIDs[i], &IID_IDirect3DRMMeshBuilder2) ||
1591                 IsEqualGUID(GUIDs[i], &IID_IDirect3DRMMeshBuilder3))
1592             {
1593                 requested = TRUE;
1594                 break;
1595             }
1596
1597         if (requested || parent_frame)
1598         {
1599             IDirect3DRMMeshBuilder3 *meshbuilder;
1600
1601             TRACE("Load mesh data\n");
1602
1603             hr = IDirect3DRM3_CreateMeshBuilder(iface, &meshbuilder);
1604             if (SUCCEEDED(hr))
1605             {
1606                 hr = load_mesh_data(meshbuilder, data_object, LoadTextureProc, ArgLTP);
1607                 if (SUCCEEDED(hr))
1608                 {
1609                     /* Only top level objects are notified */
1610                     if (!parent_frame)
1611                     {
1612                         IDirect3DRMObject *object;
1613
1614                         hr = IDirect3DRMMeshBuilder3_QueryInterface(meshbuilder, GUIDs[i], (void**)&object);
1615                         if (SUCCEEDED(hr))
1616                         {
1617                             LoadProc(object, GUIDs[i], ArgLP);
1618                             IDirect3DRMObject_Release(object);
1619                         }
1620                     }
1621                     else
1622                     {
1623                         IDirect3DRMFrame3_AddVisual(parent_frame, (IUnknown*)meshbuilder);
1624                     }
1625                 }
1626                 IDirect3DRMMeshBuilder3_Release(meshbuilder);
1627             }
1628
1629             if (FAILED(hr))
1630                 ERR("Cannot process mesh\n");
1631         }
1632     }
1633     else if (IsEqualGUID(guid, &TID_D3DRMFrame))
1634     {
1635         TRACE("Found TID_D3DRMFrame\n");
1636
1637         for (i = 0; i < nb_GUIDs; i++)
1638             if (IsEqualGUID(GUIDs[i], &IID_IDirect3DRMFrame) ||
1639                 IsEqualGUID(GUIDs[i], &IID_IDirect3DRMFrame2) ||
1640                 IsEqualGUID(GUIDs[i], &IID_IDirect3DRMFrame3))
1641             {
1642                 requested = TRUE;
1643                 break;
1644             }
1645
1646         if (requested || parent_frame)
1647         {
1648             IDirect3DRMFrame3 *frame;
1649
1650             TRACE("Load frame data\n");
1651
1652             hr = IDirect3DRM3_CreateFrame(iface, parent_frame, &frame);
1653             if (SUCCEEDED(hr))
1654             {
1655                 IDirectXFileObject *child;
1656
1657                 while (SUCCEEDED(hr = IDirectXFileData_GetNextObject(data_object, &child)))
1658                 {
1659                     IDirectXFileData *data;
1660                     IDirectXFileDataReference *reference;
1661                     IDirectXFileBinary *binary;
1662
1663                     if (SUCCEEDED(IDirectXFileObject_QueryInterface(child,
1664                             &IID_IDirectXFileBinary, (void **)&binary)))
1665                     {
1666                         FIXME("Binary Object not supported yet\n");
1667                         IDirectXFileBinary_Release(binary);
1668                     }
1669                     else if (SUCCEEDED(IDirectXFileObject_QueryInterface(child,
1670                             &IID_IDirectXFileData, (void **)&data)))
1671                     {
1672                         TRACE("Found Data Object\n");
1673                         hr = load_data(iface, data, GUIDs, nb_GUIDs, LoadProc, ArgLP, LoadTextureProc, ArgLTP, frame);
1674                         IDirectXFileData_Release(data);
1675                     }
1676                     else if (SUCCEEDED(IDirectXFileObject_QueryInterface(child,
1677                             &IID_IDirectXFileDataReference, (void **)&reference)))
1678                     {
1679                         TRACE("Found Data Object Reference\n");
1680                         IDirectXFileDataReference_Resolve(reference, &data);
1681                         hr = load_data(iface, data, GUIDs, nb_GUIDs, LoadProc, ArgLP, LoadTextureProc, ArgLTP, frame);
1682                         IDirectXFileData_Release(data);
1683                         IDirectXFileDataReference_Release(reference);
1684                     }
1685                     IDirectXFileObject_Release(child);
1686                 }
1687
1688                 if (hr != DXFILEERR_NOMOREOBJECTS)
1689                 {
1690                     IDirect3DRMFrame3_Release(frame);
1691                     goto end;
1692                 }
1693                 hr = S_OK;
1694
1695                 /* Only top level objects are notified */
1696                 if (!parent_frame)
1697                 {
1698                     IDirect3DRMObject *object;
1699
1700                     hr = IDirect3DRMFrame3_QueryInterface(frame, GUIDs[i], (void**)&object);
1701                     if (SUCCEEDED(hr))
1702                     {
1703                         LoadProc(object, GUIDs[i], ArgLP);
1704                         IDirect3DRMObject_Release(object);
1705                     }
1706                 }
1707                 IDirect3DRMFrame3_Release(frame);
1708             }
1709
1710             if (FAILED(hr))
1711                 ERR("Cannot process frame\n");
1712         }
1713     }
1714     else if (IsEqualGUID(guid, &TID_D3DRMMaterial))
1715     {
1716         TRACE("Found TID_D3DRMMaterial\n");
1717
1718         /* Cannot be requested so nothing to do */
1719     }
1720     else if (IsEqualGUID(guid, &TID_D3DRMFrameTransformMatrix))
1721     {
1722         TRACE("Found TID_D3DRMFrameTransformMatrix\n");
1723
1724         /* Cannot be requested */
1725         if (parent_frame)
1726         {
1727             D3DRMMATRIX4D *matrix;
1728             DWORD size;
1729
1730             TRACE("Load Frame Transform Matrix data\n");
1731
1732             hr = IDirectXFileData_GetData(data_object, NULL, &size, (void**)&matrix);
1733             if ((hr != DXFILE_OK) || (size != sizeof(matrix)))
1734                 goto end;
1735
1736             hr = IDirect3DRMFrame3_AddTransform(parent_frame, D3DRMCOMBINE_REPLACE, *matrix);
1737             if (FAILED(hr))
1738                 goto end;
1739         }
1740     }
1741     else
1742     {
1743         FIXME("Found unknown TID %s\n", debugstr_guid(guid));
1744     }
1745
1746     ret = D3DRM_OK;
1747
1748 end:
1749
1750     return ret;
1751 }
1752
1753 static HRESULT WINAPI d3drm3_Load(IDirect3DRM3 *iface, void *source, void *object_id, IID **iids,
1754         DWORD iid_count, D3DRMLOADOPTIONS flags, D3DRMLOADCALLBACK load_cb, void *load_ctx,
1755         D3DRMLOADTEXTURECALLBACK load_tex_cb, void *load_tex_ctx, IDirect3DRMFrame3 *parent_frame)
1756 {
1757     DXFILELOADOPTIONS load_options;
1758     IDirectXFile *file = NULL;
1759     IDirectXFileEnumObject *enum_object = NULL;
1760     IDirectXFileData *data = NULL;
1761     HRESULT hr;
1762     const GUID* pGuid;
1763     DWORD size;
1764     struct d3drm_file_header *header;
1765     HRESULT ret = D3DRMERR_BADOBJECT;
1766     DWORD i;
1767
1768     TRACE("iface %p, source %p, object_id %p, iids %p, iid_count %u, flags %#x, "
1769             "load_cb %p, load_ctx %p, load_tex_cb %p, load_tex_ctx %p, parent_frame %p.\n",
1770             iface, source, object_id, iids, iid_count, flags,
1771             load_cb, load_ctx, load_tex_cb, load_tex_ctx, parent_frame);
1772
1773     TRACE("Looking for GUIDs:\n");
1774     for (i = 0; i < iid_count; ++i)
1775         TRACE("- %s (%s)\n", debugstr_guid(iids[i]), get_IID_string(iids[i]));
1776
1777     if (flags == D3DRMLOAD_FROMMEMORY)
1778     {
1779         load_options = DXFILELOAD_FROMMEMORY;
1780     }
1781     else if (flags == D3DRMLOAD_FROMFILE)
1782     {
1783         load_options = DXFILELOAD_FROMFILE;
1784         TRACE("Loading from file %s\n", debugstr_a(source));
1785     }
1786     else
1787     {
1788         FIXME("Load options %#x not supported yet.\n", flags);
1789         return E_NOTIMPL;
1790     }
1791
1792     hr = DirectXFileCreate(&file);
1793     if (hr != DXFILE_OK)
1794         goto end;
1795
1796     hr = IDirectXFile_RegisterTemplates(file, templates, strlen(templates));
1797     if (hr != DXFILE_OK)
1798         goto end;
1799
1800     hr = IDirectXFile_CreateEnumObject(file, source, load_options, &enum_object);
1801     if (hr != DXFILE_OK)
1802         goto end;
1803
1804     hr = IDirectXFileEnumObject_GetNextDataObject(enum_object, &data);
1805     if (hr != DXFILE_OK)
1806         goto end;
1807
1808     hr = IDirectXFileData_GetType(data, &pGuid);
1809     if (hr != DXFILE_OK)
1810         goto end;
1811
1812     TRACE("Found object type whose GUID = %s\n", debugstr_guid(pGuid));
1813
1814     if (!IsEqualGUID(pGuid, &TID_DXFILEHeader))
1815     {
1816         ret = D3DRMERR_BADFILE;
1817         goto end;
1818     }
1819
1820     hr = IDirectXFileData_GetData(data, NULL, &size, (void **)&header);
1821     if ((hr != DXFILE_OK) || (size != sizeof(*header)))
1822         goto end;
1823
1824     TRACE("Version is %u.%u, flags %#x.\n", header->major, header->minor, header->flags);
1825
1826     /* Version must be 1.0.x */
1827     if ((header->major != 1) || (header->minor != 0))
1828     {
1829         ret = D3DRMERR_BADFILE;
1830         goto end;
1831     }
1832
1833     IDirectXFileData_Release(data);
1834     data = NULL;
1835
1836     while (1)
1837     {
1838         hr = IDirectXFileEnumObject_GetNextDataObject(enum_object, &data);
1839         if (hr == DXFILEERR_NOMOREOBJECTS)
1840         {
1841             TRACE("No more object\n");
1842             break;
1843         }
1844         else if (hr != DXFILE_OK)
1845         {
1846             ret = D3DRMERR_BADFILE;
1847             goto end;
1848         }
1849
1850         ret = load_data(iface, data, iids, iid_count, load_cb, load_ctx, load_tex_cb, load_tex_ctx, parent_frame);
1851         if (ret != D3DRM_OK)
1852             goto end;
1853
1854         IDirectXFileData_Release(data);
1855         data = NULL;
1856     }
1857
1858     ret = D3DRM_OK;
1859
1860 end:
1861     if (data)
1862         IDirectXFileData_Release(data);
1863     if (enum_object)
1864         IDirectXFileEnumObject_Release(enum_object);
1865     if (file)
1866         IDirectXFile_Release(file);
1867
1868     return ret;
1869 }
1870
1871 static HRESULT WINAPI d3drm3_Tick(IDirect3DRM3 *iface, D3DVALUE tick)
1872 {
1873     FIXME("iface %p, tick %.8e stub!\n", iface, tick);
1874
1875     return E_NOTIMPL;
1876 }
1877
1878 static HRESULT WINAPI d3drm3_CreateProgressiveMesh(IDirect3DRM3 *iface, IDirect3DRMProgressiveMesh **mesh)
1879 {
1880     FIXME("iface %p, mesh %p stub!\n", iface, mesh);
1881
1882     return E_NOTIMPL;
1883 }
1884
1885 static HRESULT WINAPI d3drm3_RegisterClient(IDirect3DRM3 *iface, REFGUID guid, DWORD *id)
1886 {
1887     FIXME("iface %p, guid %s, id %p stub!\n", iface, debugstr_guid(guid), id);
1888
1889     return E_NOTIMPL;
1890 }
1891
1892 static HRESULT WINAPI d3drm3_UnregisterClient(IDirect3DRM3 *iface, REFGUID guid)
1893 {
1894     FIXME("iface %p, guid %s stub!\n", iface, debugstr_guid(guid));
1895
1896     return E_NOTIMPL;
1897 }
1898
1899 static HRESULT WINAPI d3drm3_CreateClippedVisual(IDirect3DRM3 *iface,
1900         IDirect3DRMVisual *visual, IDirect3DRMClippedVisual **clipped_visual)
1901 {
1902     FIXME("iface %p, visual %p, clipped_visual %p stub!\n", iface, visual, clipped_visual);
1903
1904     return E_NOTIMPL;
1905 }
1906
1907 static HRESULT WINAPI d3drm3_SetOptions(IDirect3DRM3 *iface, DWORD flags)
1908 {
1909     FIXME("iface %p, flags %#x stub!\n", iface, flags);
1910
1911     return E_NOTIMPL;
1912 }
1913
1914 static HRESULT WINAPI d3drm3_GetOptions(IDirect3DRM3 *iface, DWORD *flags)
1915 {
1916     FIXME("iface %p, flags %p stub!\n", iface, flags);
1917
1918     return E_NOTIMPL;
1919 }
1920
1921 static const struct IDirect3DRM3Vtbl d3drm3_vtbl =
1922 {
1923     d3drm3_QueryInterface,
1924     d3drm3_AddRef,
1925     d3drm3_Release,
1926     d3drm3_CreateObject,
1927     d3drm3_CreateFrame,
1928     d3drm3_CreateMesh,
1929     d3drm3_CreateMeshBuilder,
1930     d3drm3_CreateFace,
1931     d3drm3_CreateAnimation,
1932     d3drm3_CreateAnimationSet,
1933     d3drm3_CreateTexture,
1934     d3drm3_CreateLight,
1935     d3drm3_CreateLightRGB,
1936     d3drm3_CreateMaterial,
1937     d3drm3_CreateDevice,
1938     d3drm3_CreateDeviceFromSurface,
1939     d3drm3_CreateDeviceFromD3D,
1940     d3drm3_CreateDeviceFromClipper,
1941     d3drm3_CreateTextureFromSurface,
1942     d3drm3_CreateShadow,
1943     d3drm3_CreateViewport,
1944     d3drm3_CreateWrap,
1945     d3drm3_CreateUserVisual,
1946     d3drm3_LoadTexture,
1947     d3drm3_LoadTextureFromResource,
1948     d3drm3_SetSearchPath,
1949     d3drm3_AddSearchPath,
1950     d3drm3_GetSearchPath,
1951     d3drm3_SetDefaultTextureColors,
1952     d3drm3_SetDefaultTextureShades,
1953     d3drm3_GetDevices,
1954     d3drm3_GetNamedObject,
1955     d3drm3_EnumerateObjects,
1956     d3drm3_Load,
1957     d3drm3_Tick,
1958     d3drm3_CreateProgressiveMesh,
1959     d3drm3_RegisterClient,
1960     d3drm3_UnregisterClient,
1961     d3drm3_CreateClippedVisual,
1962     d3drm3_SetOptions,
1963     d3drm3_GetOptions,
1964 };
1965
1966 HRESULT WINAPI Direct3DRMCreate(IDirect3DRM **d3drm)
1967 {
1968     struct d3drm *object;
1969
1970     TRACE("d3drm %p.\n", d3drm);
1971
1972     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1973         return E_OUTOFMEMORY;
1974
1975     object->IDirect3DRM_iface.lpVtbl = &d3drm1_vtbl;
1976     object->IDirect3DRM2_iface.lpVtbl = &d3drm2_vtbl;
1977     object->IDirect3DRM3_iface.lpVtbl = &d3drm3_vtbl;
1978     object->ref1 = 1;
1979     object->iface_count = 1;
1980
1981     *d3drm = &object->IDirect3DRM_iface;
1982
1983     return S_OK;
1984 }
1985
1986 HRESULT WINAPI DllCanUnloadNow(void)
1987 {
1988     return S_FALSE;
1989 }
1990
1991 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv)
1992 {
1993     TRACE("(%s, %s, %p): stub\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
1994
1995     if(!ppv)
1996         return E_INVALIDARG;
1997
1998     return CLASS_E_CLASSNOTAVAILABLE;
1999 }