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