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