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