dlls/d3drm/d3drm.c

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