reactos/dll/directx/wine/d3drm/d3drm.c

   1 /*
   2  * Implementation of IDirect3DRM Interface
   3  *
   4  * Copyright 2010, 2012 Christian Costa
   5  * Copyright 2011 André Hentschel
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "d3drm_private.h"
  23
  24 static const char* get_IID_string(const GUID* guid)
  25 {
  26     if (IsEqualGUID(guid, &IID_IDirect3DRMFrame))
  27         return "IID_IDirect3DRMFrame";
  28     else if (IsEqualGUID(guid, &IID_IDirect3DRMFrame2))
  29         return "IID_IDirect3DRMFrame2";
  30     else if (IsEqualGUID(guid, &IID_IDirect3DRMFrame3))
  31         return "IID_IDirect3DRMFrame3";
  32     else if (IsEqualGUID(guid, &IID_IDirect3DRMMeshBuilder))
  33         return "IID_IDirect3DRMMeshBuilder";
  34     else if (IsEqualGUID(guid, &IID_IDirect3DRMMeshBuilder2))
  35         return "IID_IDirect3DRMMeshBuilder2";
  36     else if (IsEqualGUID(guid, &IID_IDirect3DRMMeshBuilder3))
  37         return "IID_IDirect3DRMMeshBuilder3";
  38
  39     return "?";
  40 }
  41
  42 struct d3drm
  43 {
  44     IDirect3DRM IDirect3DRM_iface;
  45     IDirect3DRM2 IDirect3DRM2_iface;
  46     IDirect3DRM3 IDirect3DRM3_iface;
  47     LONG ref1, ref2, ref3, iface_count;
  48 };
  49
  50 static inline struct d3drm *impl_from_IDirect3DRM(IDirect3DRM *iface)
  51 {
  52     return CONTAINING_RECORD(iface, struct d3drm, IDirect3DRM_iface);
  53 }
  54
  55 static inline struct d3drm *impl_from_IDirect3DRM2(IDirect3DRM2 *iface)
  56 {
  57     return CONTAINING_RECORD(iface, struct d3drm, IDirect3DRM2_iface);
  58 }
  59
  60 static inline struct d3drm *impl_from_IDirect3DRM3(IDirect3DRM3 *iface)
  61 {
  62     return CONTAINING_RECORD(iface, struct d3drm, IDirect3DRM3_iface);
  63 }
  64
  65 static void d3drm_destroy(struct d3drm *d3drm)
  66 {
  67     HeapFree(GetProcessHeap(), 0, d3drm);
  68     TRACE("d3drm object %p is being destroyed.\n", d3drm);
  69 }
  70
  71 static HRESULT WINAPI d3drm1_QueryInterface(IDirect3DRM *iface, REFIID riid, void **out)
  72 {
  73     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
  74
  75     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  76
  77     if (IsEqualGUID(riid, &IID_IDirect3DRM)
  78             || IsEqualGUID(riid, &IID_IUnknown))
  79     {
  80         *out = &d3drm->IDirect3DRM_iface;
  81     }
  82     else if (IsEqualGUID(riid, &IID_IDirect3DRM2))
  83     {
  84         *out = &d3drm->IDirect3DRM2_iface;
  85     }
  86     else if (IsEqualGUID(riid, &IID_IDirect3DRM3))
  87     {
  88         *out = &d3drm->IDirect3DRM3_iface;
  89     }
  90     else
  91     {
  92         *out = NULL;
  93         WARN("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(riid));
  94         return CLASS_E_CLASSNOTAVAILABLE;
  95     }
  96
  97     IUnknown_AddRef((IUnknown *)*out);
  98     return S_OK;
  99 }
 100
 101 static ULONG WINAPI d3drm1_AddRef(IDirect3DRM *iface)
 102 {
 103     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 104     ULONG refcount = InterlockedIncrement(&d3drm->ref1);
 105
 106     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 107
 108     if (refcount == 1)
 109         InterlockedIncrement(&d3drm->iface_count);
 110
 111     return refcount;
 112 }
 113
 114 static ULONG WINAPI d3drm1_Release(IDirect3DRM *iface)
 115 {
 116     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 117     ULONG refcount = InterlockedDecrement(&d3drm->ref1);
 118
 119     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 120
 121     if (!refcount && !InterlockedDecrement(&d3drm->iface_count))
 122         d3drm_destroy(d3drm);
 123
 124     return refcount;
 125 }
 126
 127 static HRESULT WINAPI d3drm1_CreateObject(IDirect3DRM *iface,
 128         REFCLSID clsid, IUnknown *outer, REFIID iid, void **out)
 129 {
 130     FIXME("iface %p, clsid %s, outer %p, iid %s, out %p stub!\n",
 131             iface, debugstr_guid(clsid), outer, debugstr_guid(iid), out);
 132
 133     return E_NOTIMPL;
 134 }
 135
 136 static HRESULT WINAPI d3drm1_CreateFrame(IDirect3DRM *iface,
 137         IDirect3DRMFrame *parent_frame, IDirect3DRMFrame **frame)
 138 {
 139     TRACE("iface %p, parent_frame %p, frame %p.\n", iface, parent_frame, frame);
 140
 141     return Direct3DRMFrame_create(&IID_IDirect3DRMFrame, (IUnknown *)parent_frame, (IUnknown **)frame);
 142 }
 143
 144 static HRESULT WINAPI d3drm1_CreateMesh(IDirect3DRM *iface, IDirect3DRMMesh **mesh)
 145 {
 146     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 147
 148     TRACE("iface %p, mesh %p.\n", iface, mesh);
 149
 150     return IDirect3DRM3_CreateMesh(&d3drm->IDirect3DRM3_iface, mesh);
 151 }
 152
 153 static HRESULT WINAPI d3drm1_CreateMeshBuilder(IDirect3DRM *iface, IDirect3DRMMeshBuilder **mesh_builder)
 154 {
 155     TRACE("iface %p, mesh_builder %p.\n", iface, mesh_builder);
 156
 157     return Direct3DRMMeshBuilder_create(&IID_IDirect3DRMMeshBuilder, (IUnknown **)mesh_builder);
 158 }
 159
 160 static HRESULT WINAPI d3drm1_CreateFace(IDirect3DRM *iface, IDirect3DRMFace **face)
 161 {
 162     TRACE("iface %p, face %p.\n", iface, face);
 163
 164     return Direct3DRMFace_create(&IID_IDirect3DRMFace, (IUnknown **)face);
 165 }
 166
 167 static HRESULT WINAPI d3drm1_CreateAnimation(IDirect3DRM *iface, IDirect3DRMAnimation **animation)
 168 {
 169     FIXME("iface %p, animation %p stub!\n", iface, animation);
 170
 171     return E_NOTIMPL;
 172 }
 173
 174 static HRESULT WINAPI d3drm1_CreateAnimationSet(IDirect3DRM *iface, IDirect3DRMAnimationSet **set)
 175 {
 176     FIXME("iface %p, set %p stub!\n", iface, set);
 177
 178     return E_NOTIMPL;
 179 }
 180
 181 static HRESULT WINAPI d3drm1_CreateTexture(IDirect3DRM *iface,
 182         D3DRMIMAGE *image, IDirect3DRMTexture **texture)
 183 {
 184     FIXME("iface %p, image %p, texture %p partial stub.\n", iface, image, texture);
 185
 186     return Direct3DRMTexture_create(&IID_IDirect3DRMTexture, (IUnknown **)texture);
 187 }
 188
 189 static HRESULT WINAPI d3drm1_CreateLight(IDirect3DRM *iface,
 190         D3DRMLIGHTTYPE type, D3DCOLOR color, IDirect3DRMLight **light)
 191 {
 192     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 193
 194     TRACE("iface %p, type %#x, color 0x%08x, light %p.\n", iface, type, color, light);
 195
 196     return IDirect3DRM3_CreateLight(&d3drm->IDirect3DRM3_iface, type, color, light);
 197 }
 198
 199 static HRESULT WINAPI d3drm1_CreateLightRGB(IDirect3DRM *iface, D3DRMLIGHTTYPE type,
 200         D3DVALUE red, D3DVALUE green, D3DVALUE blue, IDirect3DRMLight **light)
 201 {
 202     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 203
 204     TRACE("iface %p, type %#x, red %.8e, green %.8e, blue %.8e, light %p.\n",
 205             iface, type, red, green, blue, light);
 206
 207     return IDirect3DRM3_CreateLightRGB(&d3drm->IDirect3DRM3_iface, type, red, green, blue, light);
 208 }
 209
 210 static HRESULT WINAPI d3drm1_CreateMaterial(IDirect3DRM *iface,
 211         D3DVALUE power, IDirect3DRMMaterial **material)
 212 {
 213     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 214
 215     TRACE("iface %p, power %.8e, material %p.\n", iface, power, material);
 216
 217     return IDirect3DRM3_CreateMaterial(&d3drm->IDirect3DRM3_iface, power, (IDirect3DRMMaterial2 **)material);
 218 }
 219
 220 static HRESULT WINAPI d3drm1_CreateDevice(IDirect3DRM *iface,
 221         DWORD width, DWORD height, IDirect3DRMDevice **device)
 222 {
 223     FIXME("iface %p, width %u, height %u, device %p partial stub!\n", iface, width, height, device);
 224
 225     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice, (IUnknown **)device);
 226 }
 227
 228 static HRESULT WINAPI d3drm1_CreateDeviceFromSurface(IDirect3DRM *iface, GUID *guid,
 229         IDirectDraw *ddraw, IDirectDrawSurface *backbuffer, IDirect3DRMDevice **device)
 230 {
 231     FIXME("iface %p, guid %s, ddraw %p, backbuffer %p, device %p partial stub.\n",
 232             iface, debugstr_guid(guid), ddraw, backbuffer, device);
 233
 234     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice, (IUnknown **)device);
 235 }
 236
 237 static HRESULT WINAPI d3drm1_CreateDeviceFromD3D(IDirect3DRM *iface,
 238         IDirect3D *d3d, IDirect3DDevice *d3d_device, IDirect3DRMDevice **device)
 239 {
 240     FIXME("iface %p, d3d %p, d3d_device %p, device %p partial stub.\n",
 241             iface, d3d, d3d_device, device);
 242
 243     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice, (IUnknown **)device);
 244 }
 245
 246 static HRESULT WINAPI d3drm1_CreateDeviceFromClipper(IDirect3DRM *iface,
 247         IDirectDrawClipper *clipper, GUID *guid, int width, int height,
 248         IDirect3DRMDevice **device)
 249 {
 250     FIXME("iface %p, clipper %p, guid %s, width %d, height %d, device %p.\n",
 251             iface, clipper, debugstr_guid(guid), width, height, device);
 252
 253     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice, (IUnknown **)device);
 254 }
 255
 256 static HRESULT WINAPI d3drm1_CreateTextureFromSurface(IDirect3DRM *iface,
 257         IDirectDrawSurface *surface, IDirect3DRMTexture **texture)
 258 {
 259     FIXME("iface %p, surface %p, texture %p stub!\n", iface, surface, texture);
 260
 261     return E_NOTIMPL;
 262 }
 263
 264 static HRESULT WINAPI d3drm1_CreateShadow(IDirect3DRM *iface, IDirect3DRMVisual *visual,
 265         IDirect3DRMLight *light, D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz,
 266         IDirect3DRMVisual **shadow)
 267 {
 268     FIXME("iface %p, visual %p, light %p, px %.8e, py %.8e, pz %.8e, nx %.8e, ny %.8e, nz %.8e, shadow %p stub!\n",
 269             iface, visual, light, px, py, pz, nx, ny, nz, shadow);
 270
 271     return E_NOTIMPL;
 272 }
 273
 274 static HRESULT WINAPI d3drm1_CreateViewport(IDirect3DRM *iface, IDirect3DRMDevice *device,
 275         IDirect3DRMFrame *camera, DWORD x, DWORD y, DWORD width, DWORD height, IDirect3DRMViewport **viewport)
 276 {
 277     FIXME("iface %p, device %p, camera %p, x %u, y %u, width %u, height %u, viewport %p partial stub!\n",
 278             iface, device, camera, x, y, width, height, viewport);
 279
 280     return Direct3DRMViewport_create(&IID_IDirect3DRMViewport, (IUnknown **)viewport);
 281 }
 282
 283 static HRESULT WINAPI d3drm1_CreateWrap(IDirect3DRM *iface, D3DRMWRAPTYPE type, IDirect3DRMFrame *frame,
 284         D3DVALUE ox, D3DVALUE oy, D3DVALUE oz, D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
 285         D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov, D3DVALUE su, D3DVALUE sv,
 286         IDirect3DRMWrap **wrap)
 287 {
 288     FIXME("iface %p, type %#x, frame %p, ox %.8e, oy %.8e, oz %.8e, dx %.8e, dy %.8e, dz %.8e, "
 289             "ux %.8e, uy %.8e, uz %.8e, ou %.8e, ov %.8e, su %.8e, sv %.8e, wrap %p stub!\n",
 290             iface, type, frame, ox, oy, oz, dx, dy, dz, ux, uy, uz, ou, ov, su, sv, wrap);
 291
 292     return E_NOTIMPL;
 293 }
 294
 295 static HRESULT WINAPI d3drm1_CreateUserVisual(IDirect3DRM *iface,
 296         D3DRMUSERVISUALCALLBACK cb, void *ctx, IDirect3DRMUserVisual **visual)
 297 {
 298     FIXME("iface %p, cb %p, ctx %p visual %p stub!\n", iface, cb, ctx, visual);
 299
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI d3drm1_LoadTexture(IDirect3DRM *iface,
 304         const char *filename, IDirect3DRMTexture **texture)
 305 {
 306     FIXME("iface %p, filename %s, texture %p stub!\n", iface, debugstr_a(filename), texture);
 307
 308     return Direct3DRMTexture_create(&IID_IDirect3DRMTexture, (IUnknown **)texture);
 309 }
 310
 311 static HRESULT WINAPI d3drm1_LoadTextureFromResource(IDirect3DRM *iface,
 312         HRSRC resource, IDirect3DRMTexture **texture)
 313 {
 314     FIXME("iface %p, resource %p, texture %p stub!\n", iface, resource, texture);
 315
 316     return Direct3DRMTexture_create(&IID_IDirect3DRMTexture, (IUnknown **)texture);
 317 }
 318
 319 static HRESULT WINAPI d3drm1_SetSearchPath(IDirect3DRM *iface, const char *path)
 320 {
 321     FIXME("iface %p, path %s stub!\n", iface, debugstr_a(path));
 322
 323     return E_NOTIMPL;
 324 }
 325
 326 static HRESULT WINAPI d3drm1_AddSearchPath(IDirect3DRM *iface, const char *path)
 327 {
 328     FIXME("iface %p, path %s stub!\n", iface, debugstr_a(path));
 329
 330     return E_NOTIMPL;
 331 }
 332
 333 static HRESULT WINAPI d3drm1_GetSearchPath(IDirect3DRM *iface, DWORD *size, char *path)
 334 {
 335     FIXME("iface %p, size %p, path %p stub!\n", iface, size, path);
 336
 337     return E_NOTIMPL;
 338 }
 339
 340 static HRESULT WINAPI d3drm1_SetDefaultTextureColors(IDirect3DRM *iface, DWORD color_count)
 341 {
 342     FIXME("iface %p, color_count %u stub!\n", iface, color_count);
 343
 344     return E_NOTIMPL;
 345 }
 346
 347 static HRESULT WINAPI d3drm1_SetDefaultTextureShades(IDirect3DRM *iface, DWORD shade_count)
 348 {
 349     FIXME("iface %p, shade_count %u stub!\n", iface, shade_count);
 350
 351     return E_NOTIMPL;
 352 }
 353
 354 static HRESULT WINAPI d3drm1_GetDevices(IDirect3DRM *iface, IDirect3DRMDeviceArray **array)
 355 {
 356     FIXME("iface %p, array %p stub!\n", iface, array);
 357
 358     return E_NOTIMPL;
 359 }
 360
 361 static HRESULT WINAPI d3drm1_GetNamedObject(IDirect3DRM *iface,
 362         const char *name, IDirect3DRMObject **object)
 363 {
 364     FIXME("iface %p, name %s, object %p stub!\n", iface, debugstr_a(name), object);
 365
 366     return E_NOTIMPL;
 367 }
 368
 369 static HRESULT WINAPI d3drm1_EnumerateObjects(IDirect3DRM *iface, D3DRMOBJECTCALLBACK cb, void *ctx)
 370 {
 371     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 372
 373     return E_NOTIMPL;
 374 }
 375
 376 static HRESULT WINAPI d3drm1_Load(IDirect3DRM *iface, void *source, void *object_id, IID **iids,
 377         DWORD iid_count, D3DRMLOADOPTIONS flags, D3DRMLOADCALLBACK load_cb, void *load_ctx,
 378         D3DRMLOADTEXTURECALLBACK load_tex_cb, void *load_tex_ctx, IDirect3DRMFrame *parent_frame)
 379 {
 380     struct d3drm *d3drm = impl_from_IDirect3DRM(iface);
 381     IDirect3DRMFrame3 *parent_frame3 = NULL;
 382     HRESULT hr = D3DRM_OK;
 383
 384     TRACE("iface %p, source %p, object_id %p, iids %p, iid_count %u, flags %#x, "
 385             "load_cb %p, load_ctx %p, load_tex_cb %p, load_tex_ctx %p, parent_frame %p.\n",
 386             iface, source, object_id, iids, iid_count, flags,
 387             load_cb, load_ctx, load_tex_cb, load_tex_ctx, parent_frame);
 388
 389     if (parent_frame)
 390         hr = IDirect3DRMFrame_QueryInterface(parent_frame, &IID_IDirect3DRMFrame3, (void **)&parent_frame3);
 391     if (SUCCEEDED(hr))
 392         hr = IDirect3DRM3_Load(&d3drm->IDirect3DRM3_iface, source, object_id, iids, iid_count,
 393                 flags, load_cb, load_ctx, load_tex_cb, load_tex_ctx, parent_frame3);
 394     if (parent_frame3)
 395         IDirect3DRMFrame3_Release(parent_frame3);
 396
 397     return hr;
 398 }
 399
 400 static HRESULT WINAPI d3drm1_Tick(IDirect3DRM *iface, D3DVALUE tick)
 401 {
 402     FIXME("iface %p, tick %.8e stub!\n", iface, tick);
 403
 404     return E_NOTIMPL;
 405 }
 406
 407 static const struct IDirect3DRMVtbl d3drm1_vtbl =
 408 {
 409     d3drm1_QueryInterface,
 410     d3drm1_AddRef,
 411     d3drm1_Release,
 412     d3drm1_CreateObject,
 413     d3drm1_CreateFrame,
 414     d3drm1_CreateMesh,
 415     d3drm1_CreateMeshBuilder,
 416     d3drm1_CreateFace,
 417     d3drm1_CreateAnimation,
 418     d3drm1_CreateAnimationSet,
 419     d3drm1_CreateTexture,
 420     d3drm1_CreateLight,
 421     d3drm1_CreateLightRGB,
 422     d3drm1_CreateMaterial,
 423     d3drm1_CreateDevice,
 424     d3drm1_CreateDeviceFromSurface,
 425     d3drm1_CreateDeviceFromD3D,
 426     d3drm1_CreateDeviceFromClipper,
 427     d3drm1_CreateTextureFromSurface,
 428     d3drm1_CreateShadow,
 429     d3drm1_CreateViewport,
 430     d3drm1_CreateWrap,
 431     d3drm1_CreateUserVisual,
 432     d3drm1_LoadTexture,
 433     d3drm1_LoadTextureFromResource,
 434     d3drm1_SetSearchPath,
 435     d3drm1_AddSearchPath,
 436     d3drm1_GetSearchPath,
 437     d3drm1_SetDefaultTextureColors,
 438     d3drm1_SetDefaultTextureShades,
 439     d3drm1_GetDevices,
 440     d3drm1_GetNamedObject,
 441     d3drm1_EnumerateObjects,
 442     d3drm1_Load,
 443     d3drm1_Tick,
 444 };
 445
 446 static HRESULT WINAPI d3drm2_QueryInterface(IDirect3DRM2 *iface, REFIID riid, void **out)
 447 {
 448     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 449
 450     return d3drm1_QueryInterface(&d3drm->IDirect3DRM_iface, riid, out);
 451 }
 452
 453 static ULONG WINAPI d3drm2_AddRef(IDirect3DRM2 *iface)
 454 {
 455     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 456     ULONG refcount = InterlockedIncrement(&d3drm->ref2);
 457
 458     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 459
 460     if (refcount == 1)
 461         InterlockedIncrement(&d3drm->iface_count);
 462
 463     return refcount;
 464 }
 465
 466 static ULONG WINAPI d3drm2_Release(IDirect3DRM2 *iface)
 467 {
 468     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 469     ULONG refcount = InterlockedDecrement(&d3drm->ref2);
 470
 471     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 472
 473     if (!refcount && !InterlockedDecrement(&d3drm->iface_count))
 474         d3drm_destroy(d3drm);
 475
 476     return refcount;
 477 }
 478
 479 static HRESULT WINAPI d3drm2_CreateObject(IDirect3DRM2 *iface,
 480         REFCLSID clsid, IUnknown *outer, REFIID iid, void **out)
 481 {
 482     FIXME("iface %p, clsid %s, outer %p, iid %s, out %p stub!\n",
 483             iface, debugstr_guid(clsid), outer, debugstr_guid(iid), out);
 484
 485     return E_NOTIMPL;
 486 }
 487
 488 static HRESULT WINAPI d3drm2_CreateFrame(IDirect3DRM2 *iface,
 489         IDirect3DRMFrame *parent_frame, IDirect3DRMFrame2 **frame)
 490 {
 491     TRACE("iface %p, parent_frame %p, frame %p.\n", iface, parent_frame, frame);
 492
 493     return Direct3DRMFrame_create(&IID_IDirect3DRMFrame2, (IUnknown*)parent_frame, (IUnknown**)frame);
 494 }
 495
 496 static HRESULT WINAPI d3drm2_CreateMesh(IDirect3DRM2 *iface, IDirect3DRMMesh **mesh)
 497 {
 498     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 499
 500     TRACE("iface %p, mesh %p.\n", iface, mesh);
 501
 502     return IDirect3DRM3_CreateMesh(&d3drm->IDirect3DRM3_iface, mesh);
 503 }
 504
 505 static HRESULT WINAPI d3drm2_CreateMeshBuilder(IDirect3DRM2 *iface, IDirect3DRMMeshBuilder2 **mesh_builder)
 506 {
 507     TRACE("iface %p, mesh_builder %p.\n", iface, mesh_builder);
 508
 509     return Direct3DRMMeshBuilder_create(&IID_IDirect3DRMMeshBuilder2, (IUnknown **)mesh_builder);
 510 }
 511
 512 static HRESULT WINAPI d3drm2_CreateFace(IDirect3DRM2 *iface, IDirect3DRMFace **face)
 513 {
 514     TRACE("iface %p, face %p.\n", iface, face);
 515
 516     return Direct3DRMFace_create(&IID_IDirect3DRMFace, (IUnknown **)face);
 517 }
 518
 519 static HRESULT WINAPI d3drm2_CreateAnimation(IDirect3DRM2 *iface, IDirect3DRMAnimation **animation)
 520 {
 521     FIXME("iface %p, animation %p stub!\n", iface, animation);
 522
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT WINAPI d3drm2_CreateAnimationSet(IDirect3DRM2 *iface, IDirect3DRMAnimationSet **set)
 527 {
 528     FIXME("iface %p, set %p stub!\n", iface, set);
 529
 530     return E_NOTIMPL;
 531 }
 532
 533 static HRESULT WINAPI d3drm2_CreateTexture(IDirect3DRM2 *iface,
 534         D3DRMIMAGE *image, IDirect3DRMTexture2 **texture)
 535 {
 536     FIXME("iface %p, image %p, texture %p partial stub.\n", iface, image, texture);
 537
 538     return Direct3DRMTexture_create(&IID_IDirect3DRMTexture2, (IUnknown **)texture);
 539 }
 540
 541 static HRESULT WINAPI d3drm2_CreateLight(IDirect3DRM2 *iface,
 542         D3DRMLIGHTTYPE type, D3DCOLOR color, IDirect3DRMLight **light)
 543 {
 544     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 545
 546     TRACE("iface %p, type %#x, color 0x%08x, light %p.\n", iface, type, color, light);
 547
 548     return IDirect3DRM3_CreateLight(&d3drm->IDirect3DRM3_iface, type, color, light);
 549 }
 550
 551 static HRESULT WINAPI d3drm2_CreateLightRGB(IDirect3DRM2 *iface, D3DRMLIGHTTYPE type,
 552         D3DVALUE red, D3DVALUE green, D3DVALUE blue, IDirect3DRMLight **light)
 553 {
 554     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 555
 556     TRACE("iface %p, type %#x, red %.8e, green %.8e, blue %.8e, light %p.\n",
 557             iface, type, red, green, blue, light);
 558
 559     return IDirect3DRM3_CreateLightRGB(&d3drm->IDirect3DRM3_iface, type, red, green, blue, light);
 560 }
 561
 562 static HRESULT WINAPI d3drm2_CreateMaterial(IDirect3DRM2 *iface,
 563         D3DVALUE power, IDirect3DRMMaterial **material)
 564 {
 565     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 566
 567     TRACE("iface %p, power %.8e, material %p.\n", iface, power, material);
 568
 569     return IDirect3DRM3_CreateMaterial(&d3drm->IDirect3DRM3_iface, power, (IDirect3DRMMaterial2 **)material);
 570 }
 571
 572 static HRESULT WINAPI d3drm2_CreateDevice(IDirect3DRM2 *iface,
 573         DWORD width, DWORD height, IDirect3DRMDevice2 **device)
 574 {
 575     FIXME("iface %p, width %u, height %u, device %p.\n", iface, width, height, device);
 576
 577     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice2, (IUnknown **)device);
 578 }
 579
 580 static HRESULT WINAPI d3drm2_CreateDeviceFromSurface(IDirect3DRM2 *iface, GUID *guid,
 581         IDirectDraw *ddraw, IDirectDrawSurface *backbuffer, IDirect3DRMDevice2 **device)
 582 {
 583     FIXME("iface %p, guid %s, ddraw %p, backbuffer %p, device %p partial stub.\n",
 584             iface, debugstr_guid(guid), ddraw, backbuffer, device);
 585
 586     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice2, (IUnknown **)device);
 587 }
 588
 589 static HRESULT WINAPI d3drm2_CreateDeviceFromD3D(IDirect3DRM2 *iface,
 590         IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device, IDirect3DRMDevice2 **device)
 591 {
 592     FIXME("iface %p, d3d %p, d3d_device %p, device %p partial stub.\n",
 593             iface, d3d, d3d_device, device);
 594
 595     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice2, (IUnknown **)device);
 596 }
 597
 598 static HRESULT WINAPI d3drm2_CreateDeviceFromClipper(IDirect3DRM2 *iface,
 599         IDirectDrawClipper *clipper, GUID *guid, int width, int height,
 600         IDirect3DRMDevice2 **device)
 601 {
 602     FIXME("iface %p, clipper %p, guid %s, width %d, height %d, device %p partial stub.\n",
 603             iface, clipper, debugstr_guid(guid), width, height, device);
 604
 605     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice2, (IUnknown **)device);
 606 }
 607
 608 static HRESULT WINAPI d3drm2_CreateTextureFromSurface(IDirect3DRM2 *iface,
 609         IDirectDrawSurface *surface, IDirect3DRMTexture2 **texture)
 610 {
 611     FIXME("iface %p, surface %p, texture %p stub!\n", iface, surface, texture);
 612
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI d3drm2_CreateShadow(IDirect3DRM2 *iface, IDirect3DRMVisual *visual,
 617         IDirect3DRMLight *light, D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz,
 618         IDirect3DRMVisual **shadow)
 619 {
 620     FIXME("iface %p, visual %p, light %p, px %.8e, py %.8e, pz %.8e, nx %.8e, ny %.8e, nz %.8e, shadow %p stub!\n",
 621             iface, visual, light, px, py, pz, nx, ny, nz, shadow);
 622
 623     return E_NOTIMPL;
 624 }
 625
 626 static HRESULT WINAPI d3drm2_CreateViewport(IDirect3DRM2 *iface, IDirect3DRMDevice *device,
 627         IDirect3DRMFrame *camera, DWORD x, DWORD y, DWORD width, DWORD height, IDirect3DRMViewport **viewport)
 628 {
 629     FIXME("iface %p, device %p, camera %p, x %u, y %u, width %u, height %u, viewport %p partial stub!\n",
 630             iface, device, camera, x, y, width, height, viewport);
 631
 632     return Direct3DRMViewport_create(&IID_IDirect3DRMViewport, (IUnknown **)viewport);
 633 }
 634
 635 static HRESULT WINAPI d3drm2_CreateWrap(IDirect3DRM2 *iface, D3DRMWRAPTYPE type, IDirect3DRMFrame *frame,
 636         D3DVALUE ox, D3DVALUE oy, D3DVALUE oz, D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
 637         D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov, D3DVALUE su, D3DVALUE sv,
 638         IDirect3DRMWrap **wrap)
 639 {
 640     FIXME("iface %p, type %#x, frame %p, ox %.8e, oy %.8e, oz %.8e, dx %.8e, dy %.8e, dz %.8e, "
 641             "ux %.8e, uy %.8e, uz %.8e, ou %.8e, ov %.8e, su %.8e, sv %.8e, wrap %p stub!\n",
 642             iface, type, frame, ox, oy, oz, dx, dy, dz, ux, uy, uz, ou, ov, su, sv, wrap);
 643
 644     return E_NOTIMPL;
 645 }
 646
 647 static HRESULT WINAPI d3drm2_CreateUserVisual(IDirect3DRM2 *iface,
 648         D3DRMUSERVISUALCALLBACK cb, void *ctx, IDirect3DRMUserVisual **visual)
 649 {
 650     FIXME("iface %p, cb %p, ctx %p, visual %p stub!\n", iface, cb, ctx, visual);
 651
 652     return E_NOTIMPL;
 653 }
 654
 655 static HRESULT WINAPI d3drm2_LoadTexture(IDirect3DRM2 *iface,
 656         const char *filename, IDirect3DRMTexture2 **texture)
 657 {
 658     FIXME("iface %p, filename %s, texture %p stub!\n", iface, debugstr_a(filename), texture);
 659
 660     return Direct3DRMTexture_create(&IID_IDirect3DRMTexture2, (IUnknown **)texture);
 661 }
 662
 663 static HRESULT WINAPI d3drm2_LoadTextureFromResource(IDirect3DRM2 *iface, HMODULE module,
 664         const char *resource_name, const char *resource_type, IDirect3DRMTexture2 **texture)
 665 {
 666     FIXME("iface %p, resource_name %s, resource_type %s, texture %p stub!\n",
 667             iface, debugstr_a(resource_name), debugstr_a(resource_type), texture);
 668
 669     return Direct3DRMTexture_create(&IID_IDirect3DRMTexture2, (IUnknown **)texture);
 670 }
 671
 672 static HRESULT WINAPI d3drm2_SetSearchPath(IDirect3DRM2 *iface, const char *path)
 673 {
 674     FIXME("iface %p, path %s stub!\n", iface, debugstr_a(path));
 675
 676     return E_NOTIMPL;
 677 }
 678
 679 static HRESULT WINAPI d3drm2_AddSearchPath(IDirect3DRM2 *iface, const char *path)
 680 {
 681     FIXME("iface %p, path %s stub!\n", iface, debugstr_a(path));
 682
 683     return E_NOTIMPL;
 684 }
 685
 686 static HRESULT WINAPI d3drm2_GetSearchPath(IDirect3DRM2 *iface, DWORD *size, char *path)
 687 {
 688     FIXME("iface %p, size %p, path %p stub!\n", iface, size, path);
 689
 690     return E_NOTIMPL;
 691 }
 692
 693 static HRESULT WINAPI d3drm2_SetDefaultTextureColors(IDirect3DRM2 *iface, DWORD color_count)
 694 {
 695     FIXME("iface %p, color_count %u stub!\n", iface, color_count);
 696
 697     return E_NOTIMPL;
 698 }
 699
 700 static HRESULT WINAPI d3drm2_SetDefaultTextureShades(IDirect3DRM2 *iface, DWORD shade_count)
 701 {
 702     FIXME("iface %p, shade_count %u stub!\n", iface, shade_count);
 703
 704     return E_NOTIMPL;
 705 }
 706
 707 static HRESULT WINAPI d3drm2_GetDevices(IDirect3DRM2 *iface, IDirect3DRMDeviceArray **array)
 708 {
 709     FIXME("iface %p, array %p stub!\n", iface, array);
 710
 711     return E_NOTIMPL;
 712 }
 713
 714 static HRESULT WINAPI d3drm2_GetNamedObject(IDirect3DRM2 *iface,
 715         const char *name, IDirect3DRMObject **object)
 716 {
 717     FIXME("iface %p, name %s, object %p stub!\n", iface, debugstr_a(name), object);
 718
 719     return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI d3drm2_EnumerateObjects(IDirect3DRM2 *iface, D3DRMOBJECTCALLBACK cb, void *ctx)
 723 {
 724     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 725
 726     return E_NOTIMPL;
 727 }
 728
 729 static HRESULT WINAPI d3drm2_Load(IDirect3DRM2 *iface, void *source, void *object_id, IID **iids,
 730         DWORD iid_count, D3DRMLOADOPTIONS flags, D3DRMLOADCALLBACK load_cb, void *load_ctx,
 731         D3DRMLOADTEXTURECALLBACK load_tex_cb, void *load_tex_ctx, IDirect3DRMFrame *parent_frame)
 732 {
 733     struct d3drm *d3drm = impl_from_IDirect3DRM2(iface);
 734     IDirect3DRMFrame3 *parent_frame3 = NULL;
 735     HRESULT hr = D3DRM_OK;
 736
 737     TRACE("iface %p, source %p, object_id %p, iids %p, iid_count %u, flags %#x, "
 738             "load_cb %p, load_ctx %p, load_tex_cb %p, load_tex_ctx %p, parent_frame %p.\n",
 739             iface, source, object_id, iids, iid_count, flags,
 740             load_cb, load_ctx, load_tex_cb, load_tex_ctx, parent_frame);
 741
 742     if (parent_frame)
 743         hr = IDirect3DRMFrame_QueryInterface(parent_frame, &IID_IDirect3DRMFrame3, (void **)&parent_frame3);
 744     if (SUCCEEDED(hr))
 745         hr = IDirect3DRM3_Load(&d3drm->IDirect3DRM3_iface, source, object_id, iids, iid_count,
 746                 flags, load_cb, load_ctx, load_tex_cb, load_tex_ctx, parent_frame3);
 747     if (parent_frame3)
 748         IDirect3DRMFrame3_Release(parent_frame3);
 749
 750     return hr;
 751 }
 752
 753 static HRESULT WINAPI d3drm2_Tick(IDirect3DRM2 *iface, D3DVALUE tick)
 754 {
 755     FIXME("iface %p, tick %.8e stub!\n", iface, tick);
 756
 757     return E_NOTIMPL;
 758 }
 759
 760 static HRESULT WINAPI d3drm2_CreateProgressiveMesh(IDirect3DRM2 *iface, IDirect3DRMProgressiveMesh **mesh)
 761 {
 762     FIXME("iface %p, mesh %p stub!\n", iface, mesh);
 763
 764     return E_NOTIMPL;
 765 }
 766
 767 static const struct IDirect3DRM2Vtbl d3drm2_vtbl =
 768 {
 769     d3drm2_QueryInterface,
 770     d3drm2_AddRef,
 771     d3drm2_Release,
 772     d3drm2_CreateObject,
 773     d3drm2_CreateFrame,
 774     d3drm2_CreateMesh,
 775     d3drm2_CreateMeshBuilder,
 776     d3drm2_CreateFace,
 777     d3drm2_CreateAnimation,
 778     d3drm2_CreateAnimationSet,
 779     d3drm2_CreateTexture,
 780     d3drm2_CreateLight,
 781     d3drm2_CreateLightRGB,
 782     d3drm2_CreateMaterial,
 783     d3drm2_CreateDevice,
 784     d3drm2_CreateDeviceFromSurface,
 785     d3drm2_CreateDeviceFromD3D,
 786     d3drm2_CreateDeviceFromClipper,
 787     d3drm2_CreateTextureFromSurface,
 788     d3drm2_CreateShadow,
 789     d3drm2_CreateViewport,
 790     d3drm2_CreateWrap,
 791     d3drm2_CreateUserVisual,
 792     d3drm2_LoadTexture,
 793     d3drm2_LoadTextureFromResource,
 794     d3drm2_SetSearchPath,
 795     d3drm2_AddSearchPath,
 796     d3drm2_GetSearchPath,
 797     d3drm2_SetDefaultTextureColors,
 798     d3drm2_SetDefaultTextureShades,
 799     d3drm2_GetDevices,
 800     d3drm2_GetNamedObject,
 801     d3drm2_EnumerateObjects,
 802     d3drm2_Load,
 803     d3drm2_Tick,
 804     d3drm2_CreateProgressiveMesh,
 805 };
 806
 807 static HRESULT WINAPI d3drm3_QueryInterface(IDirect3DRM3 *iface, REFIID riid, void **out)
 808 {
 809     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
 810
 811     return d3drm1_QueryInterface(&d3drm->IDirect3DRM_iface, riid, out);
 812 }
 813
 814 static ULONG WINAPI d3drm3_AddRef(IDirect3DRM3 *iface)
 815 {
 816     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
 817     ULONG refcount = InterlockedIncrement(&d3drm->ref3);
 818
 819     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 820
 821     if (refcount == 1)
 822         InterlockedIncrement(&d3drm->iface_count);
 823
 824     return refcount;
 825 }
 826
 827 static ULONG WINAPI d3drm3_Release(IDirect3DRM3 *iface)
 828 {
 829     struct d3drm *d3drm = impl_from_IDirect3DRM3(iface);
 830     ULONG refcount = InterlockedDecrement(&d3drm->ref3);
 831
 832     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 833
 834     if (!refcount && !InterlockedDecrement(&d3drm->iface_count))
 835         d3drm_destroy(d3drm);
 836
 837     return refcount;
 838 }
 839
 840 static HRESULT WINAPI d3drm3_CreateObject(IDirect3DRM3 *iface,
 841         REFCLSID clsid, IUnknown *outer, REFIID iid, void **out)
 842 {
 843     FIXME("iface %p, clsid %s, outer %p, iid %s, out %p stub!\n",
 844             iface, debugstr_guid(clsid), outer, debugstr_guid(iid), out);
 845
 846     return E_NOTIMPL;
 847 }
 848
 849 static HRESULT WINAPI d3drm3_CreateFrame(IDirect3DRM3 *iface,
 850         IDirect3DRMFrame3 *parent, IDirect3DRMFrame3 **frame)
 851 {
 852     TRACE("iface %p, parent %p, frame %p.\n", iface, parent, frame);
 853
 854     return Direct3DRMFrame_create(&IID_IDirect3DRMFrame3, (IUnknown *)parent, (IUnknown **)frame);
 855 }
 856
 857 static HRESULT WINAPI d3drm3_CreateMesh(IDirect3DRM3 *iface, IDirect3DRMMesh **mesh)
 858 {
 859     TRACE("iface %p, mesh %p.\n", iface, mesh);
 860
 861     return Direct3DRMMesh_create(mesh);
 862 }
 863
 864 static HRESULT WINAPI d3drm3_CreateMeshBuilder(IDirect3DRM3 *iface, IDirect3DRMMeshBuilder3 **mesh_builder)
 865 {
 866     TRACE("iface %p, mesh_builder %p.\n", iface, mesh_builder);
 867
 868     return Direct3DRMMeshBuilder_create(&IID_IDirect3DRMMeshBuilder3, (IUnknown **)mesh_builder);
 869 }
 870
 871 static HRESULT WINAPI d3drm3_CreateFace(IDirect3DRM3 *iface, IDirect3DRMFace2 **face)
 872 {
 873     TRACE("iface %p, face %p.\n", iface, face);
 874
 875     return Direct3DRMFace_create(&IID_IDirect3DRMFace2, (IUnknown **)face);
 876 }
 877
 878 static HRESULT WINAPI d3drm3_CreateAnimation(IDirect3DRM3 *iface, IDirect3DRMAnimation2 **animation)
 879 {
 880     FIXME("iface %p, animation %p stub!\n", iface, animation);
 881
 882     return E_NOTIMPL;
 883 }
 884
 885 static HRESULT WINAPI d3drm3_CreateAnimationSet(IDirect3DRM3 *iface, IDirect3DRMAnimationSet2 **set)
 886 {
 887     FIXME("iface %p, set %p stub!\n", iface, set);
 888
 889     return E_NOTIMPL;
 890 }
 891
 892 static HRESULT WINAPI d3drm3_CreateTexture(IDirect3DRM3 *iface,
 893         D3DRMIMAGE *image, IDirect3DRMTexture3 **texture)
 894 {
 895     FIXME("iface %p, image %p, texture %p partial stub.\n", iface, image, texture);
 896
 897     return Direct3DRMTexture_create(&IID_IDirect3DRMTexture3, (IUnknown **)texture);
 898 }
 899
 900 static HRESULT WINAPI d3drm3_CreateLight(IDirect3DRM3 *iface,
 901         D3DRMLIGHTTYPE type, D3DCOLOR color, IDirect3DRMLight **light)
 902 {
 903     HRESULT hr;
 904
 905     FIXME("iface %p, type %#x, color 0x%08x, light %p partial stub!\n", iface, type, color, light);
 906
 907     if (SUCCEEDED(hr = Direct3DRMLight_create((IUnknown **)light)))
 908     {
 909         IDirect3DRMLight_SetType(*light, type);
 910         IDirect3DRMLight_SetColor(*light, color);
 911     }
 912
 913     return hr;
 914 }
 915
 916 static HRESULT WINAPI d3drm3_CreateLightRGB(IDirect3DRM3 *iface, D3DRMLIGHTTYPE type,
 917         D3DVALUE red, D3DVALUE green, D3DVALUE blue, IDirect3DRMLight **light)
 918 {
 919     HRESULT hr;
 920
 921     FIXME("iface %p, type %#x, red %.8e, green %.8e, blue %.8e, light %p partial stub!\n",
 922             iface, type, red, green, blue, light);
 923
 924     if (SUCCEEDED(hr = Direct3DRMLight_create((IUnknown **)light)))
 925     {
 926         IDirect3DRMLight_SetType(*light, type);
 927         IDirect3DRMLight_SetColorRGB(*light, red, green, blue);
 928     }
 929
 930     return hr;
 931 }
 932
 933 static HRESULT WINAPI d3drm3_CreateMaterial(IDirect3DRM3 *iface,
 934         D3DVALUE power, IDirect3DRMMaterial2 **material)
 935 {
 936     HRESULT hr;
 937
 938     TRACE("iface %p, power %.8e, material %p.\n", iface, power, material);
 939
 940     if (SUCCEEDED(hr = Direct3DRMMaterial_create(material)))
 941         IDirect3DRMMaterial2_SetPower(*material, power);
 942
 943     return hr;
 944 }
 945
 946 static HRESULT WINAPI d3drm3_CreateDevice(IDirect3DRM3 *iface,
 947         DWORD width, DWORD height, IDirect3DRMDevice3 **device)
 948 {
 949     FIXME("iface %p, width %u, height %u, device %p partial stub!\n", iface, width, height, device);
 950
 951     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice3, (IUnknown **)device);
 952 }
 953
 954 static HRESULT WINAPI d3drm3_CreateDeviceFromSurface(IDirect3DRM3 *iface, GUID *guid,
 955         IDirectDraw *ddraw, IDirectDrawSurface *backbuffer, DWORD flags, IDirect3DRMDevice3 **device)
 956 {
 957     FIXME("iface %p, guid %s, ddraw %p, backbuffer %p, flags %#x, device %p partial stub.\n",
 958             iface, debugstr_guid(guid), ddraw, backbuffer, flags, device);
 959
 960     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice3, (IUnknown **)device);
 961 }
 962
 963 static HRESULT WINAPI d3drm3_CreateDeviceFromD3D(IDirect3DRM3 *iface,
 964         IDirect3D2 *d3d, IDirect3DDevice2 *d3d_device, IDirect3DRMDevice3 **device)
 965 {
 966     FIXME("iface %p, d3d %p, d3d_device %p, device %p partial stub.\n",
 967             iface, d3d, d3d_device, device);
 968
 969     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice3, (IUnknown **)device);
 970 }
 971
 972 static HRESULT WINAPI d3drm3_CreateDeviceFromClipper(IDirect3DRM3 *iface,
 973         IDirectDrawClipper *clipper, GUID *guid, int width, int height,
 974         IDirect3DRMDevice3 **device)
 975 {
 976     FIXME("iface %p, clipper %p, guid %s, width %d, height %d, device %p partial stub.\n",
 977             iface, clipper, debugstr_guid(guid), width, height, device);
 978
 979     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice3, (IUnknown **)device);
 980 }
 981
 982 static HRESULT WINAPI d3drm3_CreateShadow(IDirect3DRM3 *iface, IUnknown *object, IDirect3DRMLight *light,
 983         D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz, IDirect3DRMShadow2 **shadow)
 984 {
 985     FIXME("iface %p, object %p, light %p, px %.8e, py %.8e, pz %.8e, nx %.8e, ny %.8e, nz %.8e, shadow %p stub!\n",
 986             iface, object, light, px, py, pz, nx, ny, nz, shadow);
 987
 988     return E_NOTIMPL;
 989 }
 990
 991 static HRESULT WINAPI d3drm3_CreateTextureFromSurface(IDirect3DRM3 *iface,
 992         IDirectDrawSurface *surface, IDirect3DRMTexture3 **texture)
 993 {
 994     FIXME("iface %p, surface %p, texture %p stub!\n", iface, surface, texture);
 995
 996     return E_NOTIMPL;
 997 }
 998
 999 static HRESULT WINAPI d3drm3_CreateViewport(IDirect3DRM3 *iface, IDirect3DRMDevice3 *device,
1000         IDirect3DRMFrame3 *camera, DWORD x, DWORD y, DWORD width, DWORD height, IDirect3DRMViewport2 **viewport)
1001 {
1002     FIXME("iface %p, device %p, camera %p, x %u, y %u, width %u, height %u, viewport %p partial stub!\n",
1003             iface, device, camera, x, y, width, height, viewport);
1004
1005     return Direct3DRMViewport_create(&IID_IDirect3DRMViewport2, (IUnknown **)viewport);
1006 }
1007
1008 static HRESULT WINAPI d3drm3_CreateWrap(IDirect3DRM3 *iface, D3DRMWRAPTYPE type, IDirect3DRMFrame3 *frame,
1009         D3DVALUE ox, D3DVALUE oy, D3DVALUE oz, D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
1010         D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov, D3DVALUE su, D3DVALUE sv,
1011         IDirect3DRMWrap **wrap)
1012 {
1013     FIXME("iface %p, type %#x, frame %p, ox %.8e, oy %.8e, oz %.8e, dx %.8e, dy %.8e, dz %.8e, "
1014             "ux %.8e, uy %.8e, uz %.8e, ou %.8e, ov %.8e, su %.8e, sv %.8e, wrap %p stub!\n",
1015             iface, type, frame, ox, oy, oz, dx, dy, dz, ux, uy, uz, ou, ov, su, sv, wrap);
1016
1017     return E_NOTIMPL;
1018 }
1019
1020 static HRESULT WINAPI d3drm3_CreateUserVisual(IDirect3DRM3 *iface,
1021         D3DRMUSERVISUALCALLBACK cb, void *ctx, IDirect3DRMUserVisual **visual)
1022 {
1023     FIXME("iface %p, cb %p, ctx %p, visual %p stub!\n", iface, cb, ctx, visual);
1024
1025     return E_NOTIMPL;
1026 }
1027
1028 static HRESULT WINAPI d3drm3_LoadTexture(IDirect3DRM3 *iface,
1029         const char *filename, IDirect3DRMTexture3 **texture)
1030 {
1031     FIXME("iface %p, filename %s, texture %p stub!\n", iface, debugstr_a(filename), texture);
1032
1033     return Direct3DRMTexture_create(&IID_IDirect3DRMTexture3, (IUnknown **)texture);
1034 }
1035
1036 static HRESULT WINAPI d3drm3_LoadTextureFromResource(IDirect3DRM3 *iface, HMODULE module,
1037         const char *resource_name, const char *resource_type, IDirect3DRMTexture3 **texture)
1038 {
1039     FIXME("iface %p, module %p, resource_name %s, resource_type %s, texture %p stub!\n",
1040             iface, module, debugstr_a(resource_name), debugstr_a(resource_type), texture);
1041
1042     return Direct3DRMTexture_create(&IID_IDirect3DRMTexture3, (IUnknown **)texture);
1043 }
1044
1045 static HRESULT WINAPI d3drm3_SetSearchPath(IDirect3DRM3 *iface, const char *path)
1046 {
1047     FIXME("iface %p, path %s stub!\n", iface, debugstr_a(path));
1048
1049     return E_NOTIMPL;
1050 }
1051
1052 static HRESULT WINAPI d3drm3_AddSearchPath(IDirect3DRM3 *iface, const char *path)
1053 {
1054     FIXME("iface %p, path %s stub!\n", iface, debugstr_a(path));
1055
1056     return E_NOTIMPL;
1057 }
1058
1059 static HRESULT WINAPI d3drm3_GetSearchPath(IDirect3DRM3 *iface, DWORD *size, char *path)
1060 {
1061     FIXME("iface %p, size %p, path %p stub!\n", iface, size, path);
1062
1063     return E_NOTIMPL;
1064 }
1065
1066 static HRESULT WINAPI d3drm3_SetDefaultTextureColors(IDirect3DRM3 *iface, DWORD color_count)
1067 {
1068     FIXME("iface %p, color_count %u stub!\n", iface, color_count);
1069
1070     return E_NOTIMPL;
1071 }
1072
1073 static HRESULT WINAPI d3drm3_SetDefaultTextureShades(IDirect3DRM3 *iface, DWORD shade_count)
1074 {
1075     FIXME("iface %p, shade_count %u stub!\n", iface, shade_count);
1076
1077     return E_NOTIMPL;
1078 }
1079
1080 static HRESULT WINAPI d3drm3_GetDevices(IDirect3DRM3 *iface, IDirect3DRMDeviceArray **array)
1081 {
1082     FIXME("iface %p, array %p stub!\n", iface, array);
1083
1084     return E_NOTIMPL;
1085 }
1086
1087 static HRESULT WINAPI d3drm3_GetNamedObject(IDirect3DRM3 *iface,
1088         const char *name, IDirect3DRMObject **object)
1089 {
1090     FIXME("iface %p, name %s, object %p stub!\n", iface, debugstr_a(name), object);
1091
1092     return E_NOTIMPL;
1093 }
1094
1095 static HRESULT WINAPI d3drm3_EnumerateObjects(IDirect3DRM3 *iface, D3DRMOBJECTCALLBACK cb, void *ctx)
1096 {
1097     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1098
1099     return E_NOTIMPL;
1100 }
1101
1102 static HRESULT load_data(IDirect3DRM3 *iface, IDirectXFileData *data_object, IID **GUIDs, DWORD nb_GUIDs, D3DRMLOADCALLBACK LoadProc,
1103                          void *ArgLP, D3DRMLOADTEXTURECALLBACK LoadTextureProc, void *ArgLTP, IDirect3DRMFrame3 *parent_frame)
1104 {
1105     HRESULT ret = D3DRMERR_BADOBJECT;
1106     HRESULT hr;
1107     const GUID* guid;
1108     DWORD i;
1109     BOOL requested = FALSE;
1110
1111     hr = IDirectXFileData_GetType(data_object, &guid);
1112     if (hr != DXFILE_OK)
1113         goto end;
1114
1115     TRACE("Found object type whose GUID = %s\n", debugstr_guid(guid));
1116
1117     /* Load object only if it is top level and requested or if it is part of another object */
1118
1119     if (IsEqualGUID(guid, &TID_D3DRMMesh))
1120     {
1121         TRACE("Found TID_D3DRMMesh\n");
1122
1123         for (i = 0; i < nb_GUIDs; i++)
1124             if (IsEqualGUID(GUIDs[i], &IID_IDirect3DRMMeshBuilder) ||
1125                 IsEqualGUID(GUIDs[i], &IID_IDirect3DRMMeshBuilder2) ||
1126                 IsEqualGUID(GUIDs[i], &IID_IDirect3DRMMeshBuilder3))
1127             {
1128                 requested = TRUE;
1129                 break;
1130             }
1131
1132         if (requested || parent_frame)
1133         {
1134             IDirect3DRMMeshBuilder3 *meshbuilder;
1135
1136             TRACE("Load mesh data\n");
1137
1138             hr = IDirect3DRM3_CreateMeshBuilder(iface, &meshbuilder);
1139             if (SUCCEEDED(hr))
1140             {
1141                 hr = load_mesh_data(meshbuilder, data_object, LoadTextureProc, ArgLTP);
1142                 if (SUCCEEDED(hr))
1143                 {
1144                     /* Only top level objects are notified */
1145                     if (!parent_frame)
1146                     {
1147                         IDirect3DRMObject *object;
1148
1149                         hr = IDirect3DRMMeshBuilder3_QueryInterface(meshbuilder, GUIDs[i], (void**)&object);
1150                         if (SUCCEEDED(hr))
1151                         {
1152                             LoadProc(object, GUIDs[i], ArgLP);
1153                             IDirect3DRMObject_Release(object);
1154                         }
1155                     }
1156                     else
1157                     {
1158                         IDirect3DRMFrame3_AddVisual(parent_frame, (IUnknown*)meshbuilder);
1159                     }
1160                 }
1161                 IDirect3DRMMeshBuilder3_Release(meshbuilder);
1162             }
1163
1164             if (FAILED(hr))
1165                 ERR("Cannot process mesh\n");
1166         }
1167     }
1168     else if (IsEqualGUID(guid, &TID_D3DRMFrame))
1169     {
1170         TRACE("Found TID_D3DRMFrame\n");
1171
1172         for (i = 0; i < nb_GUIDs; i++)
1173             if (IsEqualGUID(GUIDs[i], &IID_IDirect3DRMFrame) ||
1174                 IsEqualGUID(GUIDs[i], &IID_IDirect3DRMFrame2) ||
1175                 IsEqualGUID(GUIDs[i], &IID_IDirect3DRMFrame3))
1176             {
1177                 requested = TRUE;
1178                 break;
1179             }
1180
1181         if (requested || parent_frame)
1182         {
1183             IDirect3DRMFrame3 *frame;
1184
1185             TRACE("Load frame data\n");
1186
1187             hr = IDirect3DRM3_CreateFrame(iface, parent_frame, &frame);
1188             if (SUCCEEDED(hr))
1189             {
1190                 IDirectXFileObject *child;
1191
1192                 while (SUCCEEDED(hr = IDirectXFileData_GetNextObject(data_object, &child)))
1193                 {
1194                     IDirectXFileData *data;
1195                     IDirectXFileDataReference *reference;
1196                     IDirectXFileBinary *binary;
1197
1198                     if (SUCCEEDED(IDirectXFileObject_QueryInterface(child,
1199                             &IID_IDirectXFileBinary, (void **)&binary)))
1200                     {
1201                         FIXME("Binary Object not supported yet\n");
1202                         IDirectXFileBinary_Release(binary);
1203                     }
1204                     else if (SUCCEEDED(IDirectXFileObject_QueryInterface(child,
1205                             &IID_IDirectXFileData, (void **)&data)))
1206                     {
1207                         TRACE("Found Data Object\n");
1208                         hr = load_data(iface, data, GUIDs, nb_GUIDs, LoadProc, ArgLP, LoadTextureProc, ArgLTP, frame);
1209                         IDirectXFileData_Release(data);
1210                     }
1211                     else if (SUCCEEDED(IDirectXFileObject_QueryInterface(child,
1212                             &IID_IDirectXFileDataReference, (void **)&reference)))
1213                     {
1214                         TRACE("Found Data Object Reference\n");
1215                         IDirectXFileDataReference_Resolve(reference, &data);
1216                         hr = load_data(iface, data, GUIDs, nb_GUIDs, LoadProc, ArgLP, LoadTextureProc, ArgLTP, frame);
1217                         IDirectXFileData_Release(data);
1218                         IDirectXFileDataReference_Release(reference);
1219                     }
1220                     IDirectXFileObject_Release(child);
1221                 }
1222
1223                 if (hr != DXFILEERR_NOMOREOBJECTS)
1224                 {
1225                     IDirect3DRMFrame3_Release(frame);
1226                     goto end;
1227                 }
1228                 hr = S_OK;
1229
1230                 /* Only top level objects are notified */
1231                 if (!parent_frame)
1232                 {
1233                     IDirect3DRMObject *object;
1234
1235                     hr = IDirect3DRMFrame3_QueryInterface(frame, GUIDs[i], (void**)&object);
1236                     if (SUCCEEDED(hr))
1237                     {
1238                         LoadProc(object, GUIDs[i], ArgLP);
1239                         IDirect3DRMObject_Release(object);
1240                     }
1241                 }
1242                 IDirect3DRMFrame3_Release(frame);
1243             }
1244
1245             if (FAILED(hr))
1246                 ERR("Cannot process frame\n");
1247         }
1248     }
1249     else if (IsEqualGUID(guid, &TID_D3DRMMaterial))
1250     {
1251         TRACE("Found TID_D3DRMMaterial\n");
1252
1253         /* Cannot be requested so nothing to do */
1254     }
1255     else if (IsEqualGUID(guid, &TID_D3DRMFrameTransformMatrix))
1256     {
1257         TRACE("Found TID_D3DRMFrameTransformMatrix\n");
1258
1259         /* Cannot be requested */
1260         if (parent_frame)
1261         {
1262             D3DRMMATRIX4D *matrix;
1263             DWORD size;
1264
1265             TRACE("Load Frame Transform Matrix data\n");
1266
1267             hr = IDirectXFileData_GetData(data_object, NULL, &size, (void**)&matrix);
1268             if ((hr != DXFILE_OK) || (size != sizeof(matrix)))
1269                 goto end;
1270
1271             hr = IDirect3DRMFrame3_AddTransform(parent_frame, D3DRMCOMBINE_REPLACE, *matrix);
1272             if (FAILED(hr))
1273                 goto end;
1274         }
1275     }
1276     else
1277     {
1278         FIXME("Found unknown TID %s\n", debugstr_guid(guid));
1279     }
1280
1281     ret = D3DRM_OK;
1282
1283 end:
1284
1285     return ret;
1286 }
1287
1288 static HRESULT WINAPI d3drm3_Load(IDirect3DRM3 *iface, void *source, void *object_id, IID **iids,
1289         DWORD iid_count, D3DRMLOADOPTIONS flags, D3DRMLOADCALLBACK load_cb, void *load_ctx,
1290         D3DRMLOADTEXTURECALLBACK load_tex_cb, void *load_tex_ctx, IDirect3DRMFrame3 *parent_frame)
1291 {
1292     DXFILELOADOPTIONS load_options;
1293     IDirectXFile *file = NULL;
1294     IDirectXFileEnumObject *enum_object = NULL;
1295     IDirectXFileData *data = NULL;
1296     HRESULT hr;
1297     const GUID* pGuid;
1298     DWORD size;
1299     struct d3drm_file_header *header;
1300     HRESULT ret = D3DRMERR_BADOBJECT;
1301     DWORD i;
1302
1303     TRACE("iface %p, source %p, object_id %p, iids %p, iid_count %u, flags %#x, "
1304             "load_cb %p, load_ctx %p, load_tex_cb %p, load_tex_ctx %p, parent_frame %p.\n",
1305             iface, source, object_id, iids, iid_count, flags,
1306             load_cb, load_ctx, load_tex_cb, load_tex_ctx, parent_frame);
1307
1308     TRACE("Looking for GUIDs:\n");
1309     for (i = 0; i < iid_count; ++i)
1310         TRACE("- %s (%s)\n", debugstr_guid(iids[i]), get_IID_string(iids[i]));
1311
1312     if (flags == D3DRMLOAD_FROMMEMORY)
1313     {
1314         load_options = DXFILELOAD_FROMMEMORY;
1315     }
1316     else if (flags == D3DRMLOAD_FROMFILE)
1317     {
1318         load_options = DXFILELOAD_FROMFILE;
1319         TRACE("Loading from file %s\n", debugstr_a(source));
1320     }
1321     else
1322     {
1323         FIXME("Load options %#x not supported yet.\n", flags);
1324         return E_NOTIMPL;
1325     }
1326
1327     hr = DirectXFileCreate(&file);
1328     if (hr != DXFILE_OK)
1329         goto end;
1330
1331     hr = IDirectXFile_RegisterTemplates(file, templates, strlen(templates));
1332     if (hr != DXFILE_OK)
1333         goto end;
1334
1335     hr = IDirectXFile_CreateEnumObject(file, source, load_options, &enum_object);
1336     if (hr != DXFILE_OK)
1337         goto end;
1338
1339     hr = IDirectXFileEnumObject_GetNextDataObject(enum_object, &data);
1340     if (hr != DXFILE_OK)
1341         goto end;
1342
1343     hr = IDirectXFileData_GetType(data, &pGuid);
1344     if (hr != DXFILE_OK)
1345         goto end;
1346
1347     TRACE("Found object type whose GUID = %s\n", debugstr_guid(pGuid));
1348
1349     if (!IsEqualGUID(pGuid, &TID_DXFILEHeader))
1350     {
1351         ret = D3DRMERR_BADFILE;
1352         goto end;
1353     }
1354
1355     hr = IDirectXFileData_GetData(data, NULL, &size, (void **)&header);
1356     if ((hr != DXFILE_OK) || (size != sizeof(*header)))
1357         goto end;
1358
1359     TRACE("Version is %u.%u, flags %#x.\n", header->major, header->minor, header->flags);
1360
1361     /* Version must be 1.0.x */
1362     if ((header->major != 1) || (header->minor != 0))
1363     {
1364         ret = D3DRMERR_BADFILE;
1365         goto end;
1366     }
1367
1368     IDirectXFileData_Release(data);
1369     data = NULL;
1370
1371     while (1)
1372     {
1373         hr = IDirectXFileEnumObject_GetNextDataObject(enum_object, &data);
1374         if (hr == DXFILEERR_NOMOREOBJECTS)
1375         {
1376             TRACE("No more object\n");
1377             break;
1378         }
1379         else if (hr != DXFILE_OK)
1380         {
1381             ret = D3DRMERR_BADFILE;
1382             goto end;
1383         }
1384
1385         ret = load_data(iface, data, iids, iid_count, load_cb, load_ctx, load_tex_cb, load_tex_ctx, parent_frame);
1386         if (ret != D3DRM_OK)
1387             goto end;
1388
1389         IDirectXFileData_Release(data);
1390         data = NULL;
1391     }
1392
1393     ret = D3DRM_OK;
1394
1395 end:
1396     if (data)
1397         IDirectXFileData_Release(data);
1398     if (enum_object)
1399         IDirectXFileEnumObject_Release(enum_object);
1400     if (file)
1401         IDirectXFile_Release(file);
1402
1403     return ret;
1404 }
1405
1406 static HRESULT WINAPI d3drm3_Tick(IDirect3DRM3 *iface, D3DVALUE tick)
1407 {
1408     FIXME("iface %p, tick %.8e stub!\n", iface, tick);
1409
1410     return E_NOTIMPL;
1411 }
1412
1413 static HRESULT WINAPI d3drm3_CreateProgressiveMesh(IDirect3DRM3 *iface, IDirect3DRMProgressiveMesh **mesh)
1414 {
1415     FIXME("iface %p, mesh %p stub!\n", iface, mesh);
1416
1417     return E_NOTIMPL;
1418 }
1419
1420 static HRESULT WINAPI d3drm3_RegisterClient(IDirect3DRM3 *iface, REFGUID guid, DWORD *id)
1421 {
1422     FIXME("iface %p, guid %s, id %p stub!\n", iface, debugstr_guid(guid), id);
1423
1424     return E_NOTIMPL;
1425 }
1426
1427 static HRESULT WINAPI d3drm3_UnregisterClient(IDirect3DRM3 *iface, REFGUID guid)
1428 {
1429     FIXME("iface %p, guid %s stub!\n", iface, debugstr_guid(guid));
1430
1431     return E_NOTIMPL;
1432 }
1433
1434 static HRESULT WINAPI d3drm3_CreateClippedVisual(IDirect3DRM3 *iface,
1435         IDirect3DRMVisual *visual, IDirect3DRMClippedVisual **clipped_visual)
1436 {
1437     FIXME("iface %p, visual %p, clipped_visual %p stub!\n", iface, visual, clipped_visual);
1438
1439     return E_NOTIMPL;
1440 }
1441
1442 static HRESULT WINAPI d3drm3_SetOptions(IDirect3DRM3 *iface, DWORD flags)
1443 {
1444     FIXME("iface %p, flags %#x stub!\n", iface, flags);
1445
1446     return E_NOTIMPL;
1447 }
1448
1449 static HRESULT WINAPI d3drm3_GetOptions(IDirect3DRM3 *iface, DWORD *flags)
1450 {
1451     FIXME("iface %p, flags %p stub!\n", iface, flags);
1452
1453     return E_NOTIMPL;
1454 }
1455
1456 static const struct IDirect3DRM3Vtbl d3drm3_vtbl =
1457 {
1458     d3drm3_QueryInterface,
1459     d3drm3_AddRef,
1460     d3drm3_Release,
1461     d3drm3_CreateObject,
1462     d3drm3_CreateFrame,
1463     d3drm3_CreateMesh,
1464     d3drm3_CreateMeshBuilder,
1465     d3drm3_CreateFace,
1466     d3drm3_CreateAnimation,
1467     d3drm3_CreateAnimationSet,
1468     d3drm3_CreateTexture,
1469     d3drm3_CreateLight,
1470     d3drm3_CreateLightRGB,
1471     d3drm3_CreateMaterial,
1472     d3drm3_CreateDevice,
1473     d3drm3_CreateDeviceFromSurface,
1474     d3drm3_CreateDeviceFromD3D,
1475     d3drm3_CreateDeviceFromClipper,
1476     d3drm3_CreateTextureFromSurface,
1477     d3drm3_CreateShadow,
1478     d3drm3_CreateViewport,
1479     d3drm3_CreateWrap,
1480     d3drm3_CreateUserVisual,
1481     d3drm3_LoadTexture,
1482     d3drm3_LoadTextureFromResource,
1483     d3drm3_SetSearchPath,
1484     d3drm3_AddSearchPath,
1485     d3drm3_GetSearchPath,
1486     d3drm3_SetDefaultTextureColors,
1487     d3drm3_SetDefaultTextureShades,
1488     d3drm3_GetDevices,
1489     d3drm3_GetNamedObject,
1490     d3drm3_EnumerateObjects,
1491     d3drm3_Load,
1492     d3drm3_Tick,
1493     d3drm3_CreateProgressiveMesh,
1494     d3drm3_RegisterClient,
1495     d3drm3_UnregisterClient,
1496     d3drm3_CreateClippedVisual,
1497     d3drm3_SetOptions,
1498     d3drm3_GetOptions,
1499 };
1500
1501 HRESULT WINAPI Direct3DRMCreate(IDirect3DRM **d3drm)
1502 {
1503     struct d3drm *object;
1504
1505     TRACE("d3drm %p.\n", d3drm);
1506
1507     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1508         return E_OUTOFMEMORY;
1509
1510     object->IDirect3DRM_iface.lpVtbl = &d3drm1_vtbl;
1511     object->IDirect3DRM2_iface.lpVtbl = &d3drm2_vtbl;
1512     object->IDirect3DRM3_iface.lpVtbl = &d3drm3_vtbl;
1513     object->ref1 = 1;
1514     object->iface_count = 1;
1515
1516     *d3drm = &object->IDirect3DRM_iface;
1517
1518     return S_OK;
1519 }
1520
1521 HRESULT WINAPI DllCanUnloadNow(void)
1522 {
1523     return S_FALSE;
1524 }
1525
1526 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv)
1527 {
1528     TRACE("(%s, %s, %p): stub\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
1529
1530     if(!ppv)
1531         return E_INVALIDARG;
1532
1533     return CLASS_E_CLASSNOTAVAILABLE;
1534 }