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