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