dlls/d3drm/d3drm.c

   1 /*
   2  * Implementation of IDirect3DRM Interface
   3  *
   4  * Copyright 2010 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 typedef struct {
  54     IDirect3DRM IDirect3DRM_iface;
  55     IDirect3DRM2 IDirect3DRM2_iface;
  56     IDirect3DRM3 IDirect3DRM3_iface;
  57     LONG ref;
  58 } IDirect3DRMImpl;
  59
  60 static inline IDirect3DRMImpl *impl_from_IDirect3DRM(IDirect3DRM *iface)
  61 {
  62     return CONTAINING_RECORD(iface, IDirect3DRMImpl, IDirect3DRM_iface);
  63 }
  64
  65 static inline IDirect3DRMImpl *impl_from_IDirect3DRM2(IDirect3DRM2 *iface)
  66 {
  67     return CONTAINING_RECORD(iface, IDirect3DRMImpl, IDirect3DRM2_iface);
  68 }
  69
  70 static inline IDirect3DRMImpl *impl_from_IDirect3DRM3(IDirect3DRM3 *iface)
  71 {
  72     return CONTAINING_RECORD(iface, IDirect3DRMImpl, IDirect3DRM3_iface);
  73 }
  74
  75 /*** IUnknown methods ***/
  76 static HRESULT WINAPI IDirect3DRMImpl_QueryInterface(IDirect3DRM* iface, REFIID riid, void** ppvObject)
  77 {
  78     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
  79
  80     TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
  81
  82     *ppvObject = NULL;
  83
  84     if(IsEqualGUID(riid, &IID_IUnknown) ||
  85        IsEqualGUID(riid, &IID_IDirect3DRM))
  86     {
  87         *ppvObject = &This->IDirect3DRM_iface;
  88     }
  89     else if(IsEqualGUID(riid, &IID_IDirect3DRM2))
  90     {
  91         *ppvObject = &This->IDirect3DRM2_iface;
  92     }
  93     else if(IsEqualGUID(riid, &IID_IDirect3DRM3))
  94     {
  95         *ppvObject = &This->IDirect3DRM3_iface;
  96     }
  97     else
  98     {
  99         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 100         return E_NOINTERFACE;
 101     }
 102
 103     IDirect3DRM_AddRef(iface);
 104     return S_OK;
 105 }
 106
 107 static ULONG WINAPI IDirect3DRMImpl_AddRef(IDirect3DRM* iface)
 108 {
 109     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 110     ULONG ref = InterlockedIncrement(&This->ref);
 111
 112     TRACE("(%p/%p)->(): new ref = %d\n", iface, This, ref);
 113
 114     return ref;
 115 }
 116
 117 static ULONG WINAPI IDirect3DRMImpl_Release(IDirect3DRM* iface)
 118 {
 119     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 120     ULONG ref = InterlockedDecrement(&This->ref);
 121
 122     TRACE("(%p/%p)->(): new ref = %d\n", iface, This, ref);
 123
 124     if (!ref)
 125         HeapFree(GetProcessHeap(), 0, This);
 126
 127     return ref;
 128 }
 129
 130 /*** IDirect3DRM methods ***/
 131 static HRESULT WINAPI IDirect3DRMImpl_CreateObject(IDirect3DRM* iface, REFCLSID rclsid, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID *ppvObj)
 132 {
 133     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 134
 135     FIXME("(%p/%p)->(%s,%p,%s,%p): stub\n", iface, This, debugstr_guid(rclsid), pUnkOuter, debugstr_guid(riid), ppvObj);
 136
 137     return E_NOTIMPL;
 138 }
 139
 140 static HRESULT WINAPI IDirect3DRMImpl_CreateFrame(IDirect3DRM* iface, LPDIRECT3DRMFRAME pFrameParent, LPDIRECT3DRMFRAME * ppFrame)
 141 {
 142     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 143
 144     TRACE("(%p/%p)->(%p,%p)\n", iface, This, pFrameParent, ppFrame);
 145
 146     if (pFrameParent)
 147         FIXME("(%p/%p): Parent frame not yet supported\n", iface, This);
 148
 149     return Direct3DRMFrame_create(&IID_IDirect3DRMFrame, (IUnknown**)ppFrame);
 150 }
 151
 152 static HRESULT WINAPI IDirect3DRMImpl_CreateMesh(IDirect3DRM* iface, LPDIRECT3DRMMESH * ppMesh)
 153 {
 154     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 155
 156     FIXME("(%p/%p)->(%p): stub\n", iface, This, ppMesh);
 157
 158     return E_NOTIMPL;
 159 }
 160
 161 static HRESULT WINAPI IDirect3DRMImpl_CreateMeshBuilder(IDirect3DRM* iface, LPDIRECT3DRMMESHBUILDER * ppMeshBuilder)
 162 {
 163     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 164
 165     TRACE("(%p/%p)->(%p)\n", iface, This, ppMeshBuilder);
 166
 167     return Direct3DRMMeshBuilder_create(&IID_IDirect3DRMMeshBuilder, (IUnknown**)ppMeshBuilder);
 168 }
 169
 170 static HRESULT WINAPI IDirect3DRMImpl_CreateFace(IDirect3DRM* iface, LPDIRECT3DRMFACE * ppFace)
 171 {
 172     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 173
 174     FIXME("(%p/%p)->(%p): stub\n", iface, This, ppFace);
 175
 176     return E_NOTIMPL;
 177 }
 178
 179 static HRESULT WINAPI IDirect3DRMImpl_CreateAnimation(IDirect3DRM* iface, LPDIRECT3DRMANIMATION * ppAnimation)
 180 {
 181     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 182
 183     FIXME("(%p/%p)->(%p): stub\n", iface, This, ppAnimation);
 184
 185     return E_NOTIMPL;
 186 }
 187
 188 static HRESULT WINAPI IDirect3DRMImpl_CreateAnimationSet(IDirect3DRM* iface, LPDIRECT3DRMANIMATIONSET * ppAnimationSet)
 189 {
 190     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 191
 192     FIXME("(%p/%p)->(%p): stub\n", iface, This, ppAnimationSet);
 193
 194     return E_NOTIMPL;
 195 }
 196
 197 static HRESULT WINAPI IDirect3DRMImpl_CreateTexture(IDirect3DRM* iface, LPD3DRMIMAGE pImage, LPDIRECT3DRMTEXTURE * ppTexture)
 198 {
 199     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 200
 201     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, pImage, ppTexture);
 202
 203     return E_NOTIMPL;
 204 }
 205
 206 static HRESULT WINAPI IDirect3DRMImpl_CreateLight(IDirect3DRM* iface, D3DRMLIGHTTYPE type,
 207                                                     D3DCOLOR color, LPDIRECT3DRMLIGHT* Light)
 208 {
 209     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 210
 211     TRACE("(%p/%p)->(%d,%d,%p)\n", iface, This, type, color, Light);
 212
 213     return IDirect3DRM3_CreateLight(&This->IDirect3DRM3_iface, type, color, Light);
 214 }
 215
 216 static HRESULT WINAPI IDirect3DRMImpl_CreateLightRGB(IDirect3DRM* iface, D3DRMLIGHTTYPE type,
 217                                                        D3DVALUE red, D3DVALUE green, D3DVALUE blue,
 218                                                        LPDIRECT3DRMLIGHT* Light)
 219 {
 220     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 221
 222     TRACE("(%p/%p)->(%d,%f,%f,%f,%p)\n", iface, This, type, red, green, blue, Light);
 223
 224     return IDirect3DRM3_CreateLightRGB(&This->IDirect3DRM3_iface, type, red, green, blue, Light);
 225 }
 226
 227 static HRESULT WINAPI IDirect3DRMImpl_Material(IDirect3DRM* iface, D3DVALUE m, LPDIRECT3DRMMATERIAL * ppMaterial)
 228 {
 229     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 230
 231     FIXME("(%p/%p)->(%f,%p): stub\n", iface, This, m, ppMaterial);
 232
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI IDirect3DRMImpl_CreateDevice(IDirect3DRM* iface, DWORD width, DWORD height, LPDIRECT3DRMDEVICE * ppDevice)
 237 {
 238     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 239
 240     FIXME("(%p/%p)->(%u,%u,%p): partial stub\n", iface, This, width, height, ppDevice);
 241
 242     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice, (IUnknown**)ppDevice);
 243 }
 244
 245 static HRESULT WINAPI IDirect3DRMImpl_CreateDeviceFromSurface(IDirect3DRM* iface, LPGUID pGUID, LPDIRECTDRAW pDD, LPDIRECTDRAWSURFACE pDDSBack, LPDIRECT3DRMDEVICE * ppDevice)
 246 {
 247     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 248
 249     FIXME("(%p/%p)->(%s,%p,%p,%p): partial stub\n", iface, This, debugstr_guid(pGUID), pDD,
 250           pDDSBack, ppDevice);
 251
 252     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice, (IUnknown**)ppDevice);
 253 }
 254
 255 static HRESULT WINAPI IDirect3DRMImpl_CreateDeviceFromD3D(IDirect3DRM* iface, LPDIRECT3D pD3D, LPDIRECT3DDEVICE pD3DDev, LPDIRECT3DRMDEVICE * ppDevice)
 256 {
 257     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 258
 259     FIXME("(%p/%p)->(%p,%p,%p): partial stub\n", iface, This, pD3D, pD3DDev, ppDevice);
 260
 261     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice, (IUnknown**)ppDevice);
 262 }
 263
 264 static HRESULT WINAPI IDirect3DRMImpl_CreateDeviceFromClipper(IDirect3DRM* iface, LPDIRECTDRAWCLIPPER pDDClipper, LPGUID pGUID, int width, int height, LPDIRECT3DRMDEVICE * ppDevice)
 265 {
 266     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 267
 268     FIXME("(%p/%p)->(%p,%s,%d,%d,%p): partial stub\n", iface, This, pDDClipper,
 269           debugstr_guid(pGUID), width, height, ppDevice);
 270
 271     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice, (IUnknown**)ppDevice);
 272 }
 273
 274 static HRESULT WINAPI IDirect3DRMImpl_CreateTextureFromSurface(IDirect3DRM* iface, LPDIRECTDRAWSURFACE pDDS, LPDIRECT3DRMTEXTURE * ppTexture)
 275 {
 276     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 277
 278     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, pDDS, ppTexture);
 279
 280     return E_NOTIMPL;
 281 }
 282
 283 static HRESULT WINAPI IDirect3DRMImpl_CreateShadow(IDirect3DRM* iface, LPDIRECT3DRMVISUAL pVisual, LPDIRECT3DRMLIGHT pLight, D3DVALUE px, D3DVALUE py, D3DVALUE pz, D3DVALUE nx, D3DVALUE ny, D3DVALUE nz, LPDIRECT3DRMVISUAL * ppVisual)
 284 {
 285     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 286
 287     FIXME("(%p/%p)->(%p,%p,%f,%f,%f,%f,%f,%f,%p): stub\n", iface, This, pVisual, pLight, px, py, pz, nx, ny, nz, ppVisual);
 288
 289     return E_NOTIMPL;
 290 }
 291
 292 static HRESULT WINAPI IDirect3DRMImpl_CreateViewport(IDirect3DRM* iface, LPDIRECT3DRMDEVICE pDevice, LPDIRECT3DRMFRAME pFrame, DWORD xpos, DWORD ypos, DWORD width, DWORD height, LPDIRECT3DRMVIEWPORT * ppViewport)
 293 {
 294     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 295
 296     FIXME("(%p/%p)->(%p,%p,%d,%d,%d,%d,%p): partial stub\n", iface, This, pDevice, pFrame,
 297           xpos, ypos, width, height, ppViewport);
 298
 299     return Direct3DRMViewport_create(&IID_IDirect3DRMViewport, (IUnknown**)ppViewport);
 300 }
 301
 302 static HRESULT WINAPI IDirect3DRMImpl_CreateWrap(IDirect3DRM* iface, D3DRMWRAPTYPE type, LPDIRECT3DRMFRAME pFrame, D3DVALUE ox, D3DVALUE oy, D3DVALUE oz, D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz, D3DVALUE ou, D3DVALUE ov, D3DVALUE su, D3DVALUE sv, LPDIRECT3DRMWRAP * ppWrap)
 303 {
 304     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 305
 306     FIXME("(%p/%p)->(%d,%p,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%p): stub\n", iface, This, type, pFrame, ox, oy, oz, dx, dy, dz, ux, uy, uz, ou, ov, su, sv, ppWrap);
 307
 308     return E_NOTIMPL;
 309 }
 310
 311 static HRESULT WINAPI IDirect3DRMImpl_CreateUserVisual(IDirect3DRM* iface, D3DRMUSERVISUALCALLBACK cb, LPVOID pArg, LPDIRECT3DRMUSERVISUAL * ppUserVisual)
 312 {
 313     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 314
 315     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, cb, pArg, ppUserVisual);
 316
 317     return E_NOTIMPL;
 318 }
 319
 320 static HRESULT WINAPI IDirect3DRMImpl_LoadTexture(IDirect3DRM* iface, const char * filename, LPDIRECT3DRMTEXTURE * ppTexture)
 321 {
 322     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 323
 324     FIXME("(%p/%p)->(%s,%p): stub\n", iface, This, filename, ppTexture);
 325
 326     return E_NOTIMPL;
 327 }
 328
 329 static HRESULT WINAPI IDirect3DRMImpl_LoadTextureFromResource(IDirect3DRM* iface, HRSRC rs, LPDIRECT3DRMTEXTURE * ppTexture)
 330 {
 331     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 332
 333     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, rs, ppTexture);
 334
 335     return E_NOTIMPL;
 336 }
 337
 338 static HRESULT WINAPI IDirect3DRMImpl_SetSearchPath(IDirect3DRM* iface, LPCSTR path)
 339 {
 340     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 341
 342     FIXME("(%p/%p)->(%s): stub\n", iface, This, path);
 343
 344     return E_NOTIMPL;
 345 }
 346
 347 static HRESULT WINAPI IDirect3DRMImpl_AddSearchPath(IDirect3DRM* iface, LPCSTR path)
 348 {
 349     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 350
 351     FIXME("(%p/%p)->(%s): stub\n", iface, This, path);
 352
 353     return E_NOTIMPL;
 354 }
 355
 356 static HRESULT WINAPI IDirect3DRMImpl_GetSearchPath(IDirect3DRM* iface, DWORD *size_return, LPSTR path_return)
 357 {
 358     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 359
 360     FIXME("(%p/%p)->(%p,%s): stub\n", iface, This, size_return, path_return);
 361
 362     return E_NOTIMPL;
 363 }
 364
 365 static HRESULT WINAPI IDirect3DRMImpl_SetDefaultTextureColors(IDirect3DRM* iface, DWORD nb_colors)
 366 {
 367     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 368
 369     FIXME("(%p/%p)->(%d): stub\n", iface, This, nb_colors);
 370
 371     return E_NOTIMPL;
 372 }
 373
 374 static HRESULT WINAPI IDirect3DRMImpl_SetDefaultTextureShades(IDirect3DRM* iface, DWORD nb_shades)
 375 {
 376     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 377
 378     FIXME("(%p/%p)->(%d): stub\n", iface, This, nb_shades);
 379
 380     return E_NOTIMPL;
 381 }
 382
 383 static HRESULT WINAPI IDirect3DRMImpl_GetDevices(IDirect3DRM* iface, LPDIRECT3DRMDEVICEARRAY * ppDeviceArray)
 384 {
 385     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 386
 387     FIXME("(%p/%p)->(%p): stub\n", iface, This, ppDeviceArray);
 388
 389     return E_NOTIMPL;
 390 }
 391
 392 static HRESULT WINAPI IDirect3DRMImpl_GetNamedObject(IDirect3DRM* iface, const char * pName, LPDIRECT3DRMOBJECT * ppObject)
 393 {
 394     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 395
 396     FIXME("(%p/%p)->(%s,%p): stub\n", iface, This, pName, ppObject);
 397
 398     return E_NOTIMPL;
 399 }
 400
 401 static HRESULT WINAPI IDirect3DRMImpl_EnumerateObjects(IDirect3DRM* iface, D3DRMOBJECTCALLBACK cb, LPVOID pArg)
 402 {
 403     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 404
 405     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, pArg);
 406
 407     return E_NOTIMPL;
 408 }
 409
 410 static HRESULT WINAPI IDirect3DRMImpl_Load(IDirect3DRM* iface, LPVOID pObjSource, LPVOID pObjID, LPIID * ppGUIDs, DWORD nb_GUIDs, D3DRMLOADOPTIONS LOFlags, D3DRMLOADCALLBACK LoadProc, LPVOID pArgLP, D3DRMLOADTEXTURECALLBACK LoadTextureProc, LPVOID pArgLTP, LPDIRECT3DRMFRAME pParentFrame)
 411 {
 412     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 413     LPDIRECT3DRMFRAME3 pParentFrame3 = NULL;
 414     HRESULT hr = D3DRM_OK;
 415
 416     TRACE("(%p/%p)->(%p,%p,%p,%d,%d,%p,%p,%p,%p,%p)\n", iface, This, pObjSource, pObjID, ppGUIDs, nb_GUIDs, LOFlags, LoadProc, pArgLP, LoadTextureProc, pArgLTP, pParentFrame);
 417
 418     if (pParentFrame)
 419         hr = IDirect3DRMFrame_QueryInterface(pParentFrame, &IID_IDirect3DRMFrame3, (void**)&pParentFrame3);
 420     if (SUCCEEDED(hr))
 421         hr = IDirect3DRM3_Load(&This->IDirect3DRM3_iface, pObjSource, pObjID, ppGUIDs, nb_GUIDs, LOFlags, LoadProc, pArgLP, LoadTextureProc, pArgLTP, pParentFrame3);
 422     if (pParentFrame3)
 423         IDirect3DRMFrame3_Release(pParentFrame3);
 424
 425     return hr;
 426 }
 427
 428 static HRESULT WINAPI IDirect3DRMImpl_Tick(IDirect3DRM* iface, D3DVALUE tick)
 429 {
 430     IDirect3DRMImpl *This = impl_from_IDirect3DRM(iface);
 431
 432     FIXME("(%p/%p)->(%f): stub\n", iface, This, tick);
 433
 434     return E_NOTIMPL;
 435 }
 436
 437 static const struct IDirect3DRMVtbl Direct3DRM_Vtbl =
 438 {
 439     IDirect3DRMImpl_QueryInterface,
 440     IDirect3DRMImpl_AddRef,
 441     IDirect3DRMImpl_Release,
 442     IDirect3DRMImpl_CreateObject,
 443     IDirect3DRMImpl_CreateFrame,
 444     IDirect3DRMImpl_CreateMesh,
 445     IDirect3DRMImpl_CreateMeshBuilder,
 446     IDirect3DRMImpl_CreateFace,
 447     IDirect3DRMImpl_CreateAnimation,
 448     IDirect3DRMImpl_CreateAnimationSet,
 449     IDirect3DRMImpl_CreateTexture,
 450     IDirect3DRMImpl_CreateLight,
 451     IDirect3DRMImpl_CreateLightRGB,
 452     IDirect3DRMImpl_Material,
 453     IDirect3DRMImpl_CreateDevice,
 454     IDirect3DRMImpl_CreateDeviceFromSurface,
 455     IDirect3DRMImpl_CreateDeviceFromD3D,
 456     IDirect3DRMImpl_CreateDeviceFromClipper,
 457     IDirect3DRMImpl_CreateTextureFromSurface,
 458     IDirect3DRMImpl_CreateShadow,
 459     IDirect3DRMImpl_CreateViewport,
 460     IDirect3DRMImpl_CreateWrap,
 461     IDirect3DRMImpl_CreateUserVisual,
 462     IDirect3DRMImpl_LoadTexture,
 463     IDirect3DRMImpl_LoadTextureFromResource,
 464     IDirect3DRMImpl_SetSearchPath,
 465     IDirect3DRMImpl_AddSearchPath,
 466     IDirect3DRMImpl_GetSearchPath,
 467     IDirect3DRMImpl_SetDefaultTextureColors,
 468     IDirect3DRMImpl_SetDefaultTextureShades,
 469     IDirect3DRMImpl_GetDevices,
 470     IDirect3DRMImpl_GetNamedObject,
 471     IDirect3DRMImpl_EnumerateObjects,
 472     IDirect3DRMImpl_Load,
 473     IDirect3DRMImpl_Tick
 474 };
 475
 476
 477 /*** IUnknown methods ***/
 478 static HRESULT WINAPI IDirect3DRM2Impl_QueryInterface(IDirect3DRM2* iface, REFIID riid,
 479                                                       void** ppvObject)
 480 {
 481     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 482     return IDirect3DRM_QueryInterface(&This->IDirect3DRM_iface, riid, ppvObject);
 483 }
 484
 485 static ULONG WINAPI IDirect3DRM2Impl_AddRef(IDirect3DRM2* iface)
 486 {
 487     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 488     return IDirect3DRM_AddRef(&This->IDirect3DRM_iface);
 489 }
 490
 491 static ULONG WINAPI IDirect3DRM2Impl_Release(IDirect3DRM2* iface)
 492 {
 493     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 494     return IDirect3DRM_Release(&This->IDirect3DRM_iface);
 495 }
 496
 497 /*** IDirect3DRM2 methods ***/
 498 static HRESULT WINAPI IDirect3DRM2Impl_CreateObject(IDirect3DRM2* iface, REFCLSID rclsid,
 499                                                     LPUNKNOWN pUnkOuter, REFIID riid,
 500                                                     LPVOID *ppvObj)
 501 {
 502     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 503
 504     FIXME("(%p/%p)->(%s,%p,%s,%p): stub\n", iface, This, debugstr_guid(rclsid), pUnkOuter,
 505                                             debugstr_guid(riid), ppvObj);
 506
 507     return E_NOTIMPL;
 508 }
 509
 510 static HRESULT WINAPI IDirect3DRM2Impl_CreateFrame(IDirect3DRM2* iface,
 511                                                    LPDIRECT3DRMFRAME pFrameParent,
 512                                                    LPDIRECT3DRMFRAME2 * ppFrame)
 513 {
 514     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 515
 516     TRACE("(%p/%p)->(%p,%p)\n", iface, This, pFrameParent, ppFrame);
 517
 518     if (pFrameParent)
 519         FIXME("(%p/%p): Parent frame not yet supported\n", iface, This);
 520
 521     return Direct3DRMFrame_create(&IID_IDirect3DRMFrame2, (IUnknown**)ppFrame);
 522 }
 523
 524 static HRESULT WINAPI IDirect3DRM2Impl_CreateMesh(IDirect3DRM2* iface, LPDIRECT3DRMMESH * ppMesh)
 525 {
 526     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 527
 528     FIXME("(%p/%p)->(%p): stub\n", iface, This, ppMesh);
 529
 530     return E_NOTIMPL;
 531 }
 532
 533 static HRESULT WINAPI IDirect3DRM2Impl_CreateMeshBuilder(IDirect3DRM2* iface,
 534                                                          LPDIRECT3DRMMESHBUILDER2 * ppMeshBuilder)
 535 {
 536     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 537
 538     TRACE("(%p/%p)->(%p)\n", iface, This, ppMeshBuilder);
 539
 540     return Direct3DRMMeshBuilder_create(&IID_IDirect3DRMMeshBuilder2, (IUnknown**)ppMeshBuilder);
 541 }
 542
 543 static HRESULT WINAPI IDirect3DRM2Impl_CreateFace(IDirect3DRM2* iface, LPDIRECT3DRMFACE * ppFace)
 544 {
 545     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 546
 547     FIXME("(%p/%p)->(%p): stub\n", iface, This, ppFace);
 548
 549     return E_NOTIMPL;
 550 }
 551
 552 static HRESULT WINAPI IDirect3DRM2Impl_CreateAnimation(IDirect3DRM2* iface,
 553                                                        LPDIRECT3DRMANIMATION * ppAnimation)
 554 {
 555     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 556
 557     FIXME("(%p/%p)->(%p): stub\n", iface, This, ppAnimation);
 558
 559     return E_NOTIMPL;
 560 }
 561
 562 static HRESULT WINAPI IDirect3DRM2Impl_CreateAnimationSet(IDirect3DRM2* iface,
 563                                                           LPDIRECT3DRMANIMATIONSET * ppAnimationSet)
 564 {
 565     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 566
 567     FIXME("(%p/%p)->(%p): stub\n", iface, This, ppAnimationSet);
 568
 569     return E_NOTIMPL;
 570 }
 571
 572 static HRESULT WINAPI IDirect3DRM2Impl_CreateTexture(IDirect3DRM2* iface, LPD3DRMIMAGE pImage,
 573                                                      LPDIRECT3DRMTEXTURE2 * ppTexture)
 574 {
 575     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 576
 577     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, pImage, ppTexture);
 578
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI IDirect3DRM2Impl_CreateLight(IDirect3DRM2* iface, D3DRMLIGHTTYPE type,
 583                                                      D3DCOLOR color, LPDIRECT3DRMLIGHT* Light)
 584 {
 585     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 586
 587     TRACE("(%p/%p)->(%d,%d,%p)\n", iface, This, type, color, Light);
 588
 589     return IDirect3DRM3_CreateLight(&This->IDirect3DRM3_iface, type, color, Light);
 590 }
 591
 592 static HRESULT WINAPI IDirect3DRM2Impl_CreateLightRGB(IDirect3DRM2* iface, D3DRMLIGHTTYPE type,
 593                                                         D3DVALUE red, D3DVALUE green, D3DVALUE blue,
 594                                                         LPDIRECT3DRMLIGHT* Light)
 595 {
 596     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 597
 598     TRACE("(%p/%p)->(%d,%f,%f,%f,%p)\n", iface, This, type, red, green, blue, Light);
 599
 600     return IDirect3DRM3_CreateLightRGB(&This->IDirect3DRM3_iface, type, red, green, blue, Light);
 601 }
 602
 603 static HRESULT WINAPI IDirect3DRM2Impl_Material(IDirect3DRM2* iface, D3DVALUE m,
 604                                                 LPDIRECT3DRMMATERIAL * ppMaterial)
 605 {
 606     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 607
 608     FIXME("(%p/%p)->(%f,%p): stub\n", iface, This, m, ppMaterial);
 609
 610     return E_NOTIMPL;
 611 }
 612
 613 static HRESULT WINAPI IDirect3DRM2Impl_CreateDevice(IDirect3DRM2* iface, DWORD width, DWORD height,
 614                                                     LPDIRECT3DRMDEVICE2 * ppDevice)
 615 {
 616     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 617
 618     FIXME("(%p/%p)->(%u,%u,%p): partial stub\n", iface, This, width, height, ppDevice);
 619
 620     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice2, (IUnknown**)ppDevice);
 621 }
 622
 623 static HRESULT WINAPI IDirect3DRM2Impl_CreateDeviceFromSurface(IDirect3DRM2* iface, LPGUID pGUID,
 624                                                                LPDIRECTDRAW pDD,
 625                                                                LPDIRECTDRAWSURFACE pDDSBack,
 626                                                                LPDIRECT3DRMDEVICE2 * ppDevice)
 627 {
 628     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 629
 630     FIXME("(%p/%p)->(%s,%p,%p,%p): partial stub\n", iface, This, debugstr_guid(pGUID),
 631           pDD, pDDSBack, ppDevice);
 632
 633     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice2, (IUnknown**)ppDevice);
 634 }
 635
 636 static HRESULT WINAPI IDirect3DRM2Impl_CreateDeviceFromD3D(IDirect3DRM2* iface, LPDIRECT3D2 pD3D,
 637                                                            LPDIRECT3DDEVICE2 pD3DDev,
 638                                                            LPDIRECT3DRMDEVICE2 * ppDevice)
 639 {
 640     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 641
 642     FIXME("(%p/%p)->(%p,%p,%p): partial stub\n", iface, This, pD3D, pD3DDev, ppDevice);
 643
 644     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice2, (IUnknown**)ppDevice);
 645 }
 646
 647 static HRESULT WINAPI IDirect3DRM2Impl_CreateDeviceFromClipper(IDirect3DRM2* iface,
 648                                                                LPDIRECTDRAWCLIPPER pDDClipper,
 649                                                                LPGUID pGUID, int width, int height,
 650                                                                LPDIRECT3DRMDEVICE2 * ppDevice)
 651 {
 652     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 653
 654     FIXME("(%p/%p)->(%p,%s,%d,%d,%p): partial stub\n", iface, This, pDDClipper,
 655           debugstr_guid(pGUID), width, height, ppDevice);
 656
 657     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice2, (IUnknown**)ppDevice);
 658 }
 659
 660 static HRESULT WINAPI IDirect3DRM2Impl_CreateTextureFromSurface(IDirect3DRM2* iface,
 661                                                                 LPDIRECTDRAWSURFACE pDDS,
 662                                                                 LPDIRECT3DRMTEXTURE2 * ppTexture)
 663 {
 664     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 665
 666     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, pDDS, ppTexture);
 667
 668     return E_NOTIMPL;
 669 }
 670
 671 static HRESULT WINAPI IDirect3DRM2Impl_CreateShadow(IDirect3DRM2* iface, LPDIRECT3DRMVISUAL pVisual,
 672                                                     LPDIRECT3DRMLIGHT pLight,
 673                                                     D3DVALUE px, D3DVALUE py, D3DVALUE pz,
 674                                                     D3DVALUE nx, D3DVALUE ny, D3DVALUE nz,
 675                                                     LPDIRECT3DRMVISUAL * ppVisual)
 676 {
 677     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 678
 679     FIXME("(%p/%p)->(%p,%p,%f,%f,%f,%f,%f,%f,%p): stub\n", iface, This, pVisual, pLight, px, py, pz,
 680                                                            nx, ny, nz, ppVisual);
 681
 682     return E_NOTIMPL;
 683 }
 684
 685 static HRESULT WINAPI IDirect3DRM2Impl_CreateViewport(IDirect3DRM2* iface,
 686                                                       LPDIRECT3DRMDEVICE pDevice,
 687                                                       LPDIRECT3DRMFRAME pFrame,
 688                                                       DWORD xpos, DWORD ypos,
 689                                                       DWORD width, DWORD height,
 690                                                       LPDIRECT3DRMVIEWPORT * ppViewport)
 691 {
 692     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 693
 694     FIXME("(%p/%p)->(%p,%p,%d,%d,%d,%d,%p): partial stub\n", iface, This, pDevice, pFrame,
 695           xpos, ypos, width, height, ppViewport);
 696
 697     return Direct3DRMViewport_create(&IID_IDirect3DRMViewport, (IUnknown**)ppViewport);
 698 }
 699
 700 static HRESULT WINAPI IDirect3DRM2Impl_CreateWrap(IDirect3DRM2* iface, D3DRMWRAPTYPE type,
 701                                                   LPDIRECT3DRMFRAME pFrame,
 702                                                   D3DVALUE ox, D3DVALUE oy, D3DVALUE oz,
 703                                                   D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
 704                                                   D3DVALUE ux, D3DVALUE uy, D3DVALUE uz,
 705                                                   D3DVALUE ou, D3DVALUE ov, D3DVALUE su,
 706                                                   D3DVALUE sv, LPDIRECT3DRMWRAP * ppWrap)
 707 {
 708     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 709
 710     FIXME("(%p/%p)->(%d,%p,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%p): stub\n", iface, This, type,
 711           pFrame, ox, oy, oz, dx, dy, dz, ux, uy, uz, ou, ov, su, sv, ppWrap);
 712
 713     return E_NOTIMPL;
 714 }
 715
 716 static HRESULT WINAPI IDirect3DRM2Impl_CreateUserVisual(IDirect3DRM2* iface,
 717                                                         D3DRMUSERVISUALCALLBACK cb, LPVOID pArg,
 718                                                         LPDIRECT3DRMUSERVISUAL * ppUserVisual)
 719 {
 720     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 721
 722     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, cb, pArg, ppUserVisual);
 723
 724     return E_NOTIMPL;
 725 }
 726
 727 static HRESULT WINAPI IDirect3DRM2Impl_LoadTexture(IDirect3DRM2* iface, const char * filename,
 728                                                    LPDIRECT3DRMTEXTURE2 * ppTexture)
 729 {
 730     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 731
 732     FIXME("(%p/%p)->(%s,%p): stub\n", iface, This, filename, ppTexture);
 733
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI IDirect3DRM2Impl_LoadTextureFromResource(IDirect3DRM2* iface, HMODULE hModule,
 738                                                                LPCSTR strName, LPCSTR strType,
 739                                                                LPDIRECT3DRMTEXTURE2 * ppTexture)
 740 {
 741     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 742
 743     FIXME("(%p/%p)->(%p,%p,%p,%p): stub\n", iface, This, hModule, strName, strType, ppTexture);
 744
 745     return E_NOTIMPL;
 746 }
 747
 748 static HRESULT WINAPI IDirect3DRM2Impl_SetSearchPath(IDirect3DRM2* iface, LPCSTR path)
 749 {
 750     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 751
 752     FIXME("(%p/%p)->(%s): stub\n", iface, This, path);
 753
 754     return E_NOTIMPL;
 755 }
 756
 757 static HRESULT WINAPI IDirect3DRM2Impl_AddSearchPath(IDirect3DRM2* iface, LPCSTR path)
 758 {
 759     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 760
 761     FIXME("(%p/%p)->(%s): stub\n", iface, This, path);
 762
 763     return E_NOTIMPL;
 764 }
 765
 766 static HRESULT WINAPI IDirect3DRM2Impl_GetSearchPath(IDirect3DRM2* iface, DWORD *size_return,
 767                                                      LPSTR path_return)
 768 {
 769     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 770
 771     FIXME("(%p/%p)->(%p,%s): stub\n", iface, This, size_return, path_return);
 772
 773     return E_NOTIMPL;
 774 }
 775
 776 static HRESULT WINAPI IDirect3DRM2Impl_SetDefaultTextureColors(IDirect3DRM2* iface, DWORD nb_colors)
 777 {
 778     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 779
 780     FIXME("(%p/%p)->(%d): stub\n", iface, This, nb_colors);
 781
 782     return E_NOTIMPL;
 783 }
 784
 785 static HRESULT WINAPI IDirect3DRM2Impl_SetDefaultTextureShades(IDirect3DRM2* iface, DWORD nb_shades)
 786 {
 787     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 788
 789     FIXME("(%p/%p)->(%d): stub\n", iface, This, nb_shades);
 790
 791     return E_NOTIMPL;
 792 }
 793
 794 static HRESULT WINAPI IDirect3DRM2Impl_GetDevices(IDirect3DRM2* iface,
 795                                                   LPDIRECT3DRMDEVICEARRAY * ppDeviceArray)
 796 {
 797     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 798
 799     FIXME("(%p/%p)->(%p): stub\n", iface, This, ppDeviceArray);
 800
 801     return E_NOTIMPL;
 802 }
 803
 804 static HRESULT WINAPI IDirect3DRM2Impl_GetNamedObject(IDirect3DRM2* iface, const char * pName,
 805                                                       LPDIRECT3DRMOBJECT * ppObject)
 806 {
 807     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 808
 809     FIXME("(%p/%p)->(%s,%p): stub\n", iface, This, pName, ppObject);
 810
 811     return E_NOTIMPL;
 812 }
 813
 814 static HRESULT WINAPI IDirect3DRM2Impl_EnumerateObjects(IDirect3DRM2* iface, D3DRMOBJECTCALLBACK cb,
 815                                                         LPVOID pArg)
 816 {
 817     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 818
 819     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, pArg);
 820
 821     return E_NOTIMPL;
 822 }
 823
 824 static HRESULT WINAPI IDirect3DRM2Impl_Load(IDirect3DRM2* iface, LPVOID pObjSource, LPVOID pObjID,
 825                                             LPIID * ppGUIDs, DWORD nb_GUIDs,
 826                                             D3DRMLOADOPTIONS LOFlags, D3DRMLOADCALLBACK LoadProc,
 827                                             LPVOID pArgLP, D3DRMLOADTEXTURECALLBACK LoadTextureProc,
 828                                             LPVOID pArgLTP, LPDIRECT3DRMFRAME pParentFrame)
 829 {
 830     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 831     LPDIRECT3DRMFRAME3 pParentFrame3 = NULL;
 832     HRESULT hr = D3DRM_OK;
 833
 834     TRACE("(%p/%p)->(%p,%p,%p,%d,%d,%p,%p,%p,%p,%p)\n", iface, This, pObjSource, pObjID,
 835           ppGUIDs, nb_GUIDs, LOFlags, LoadProc, pArgLP, LoadTextureProc, pArgLTP, pParentFrame);
 836
 837     if (pParentFrame)
 838         hr = IDirect3DRMFrame_QueryInterface(pParentFrame, &IID_IDirect3DRMFrame3, (void**)&pParentFrame3);
 839     if (SUCCEEDED(hr))
 840         hr = IDirect3DRM3_Load(&This->IDirect3DRM3_iface, pObjSource, pObjID, ppGUIDs, nb_GUIDs, LOFlags, LoadProc, pArgLP, LoadTextureProc, pArgLTP, pParentFrame3);
 841     if (pParentFrame3)
 842         IDirect3DRMFrame3_Release(pParentFrame3);
 843
 844     return hr;
 845 }
 846
 847 static HRESULT WINAPI IDirect3DRM2Impl_Tick(IDirect3DRM2* iface, D3DVALUE tick)
 848 {
 849     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 850
 851     FIXME("(%p/%p)->(%f): stub\n", iface, This, tick);
 852
 853     return E_NOTIMPL;
 854 }
 855
 856 static HRESULT WINAPI IDirect3DRM2Impl_CreateProgressiveMesh(IDirect3DRM2* iface,
 857                                                              LPDIRECT3DRMPROGRESSIVEMESH * ppMesh)
 858 {
 859     IDirect3DRMImpl *This = impl_from_IDirect3DRM2(iface);
 860
 861     FIXME("(%p/%p)->(%p): stub\n", iface, This, ppMesh);
 862
 863     return E_NOTIMPL;
 864 }
 865
 866 static const struct IDirect3DRM2Vtbl Direct3DRM2_Vtbl =
 867 {
 868     IDirect3DRM2Impl_QueryInterface,
 869     IDirect3DRM2Impl_AddRef,
 870     IDirect3DRM2Impl_Release,
 871     IDirect3DRM2Impl_CreateObject,
 872     IDirect3DRM2Impl_CreateFrame,
 873     IDirect3DRM2Impl_CreateMesh,
 874     IDirect3DRM2Impl_CreateMeshBuilder,
 875     IDirect3DRM2Impl_CreateFace,
 876     IDirect3DRM2Impl_CreateAnimation,
 877     IDirect3DRM2Impl_CreateAnimationSet,
 878     IDirect3DRM2Impl_CreateTexture,
 879     IDirect3DRM2Impl_CreateLight,
 880     IDirect3DRM2Impl_CreateLightRGB,
 881     IDirect3DRM2Impl_Material,
 882     IDirect3DRM2Impl_CreateDevice,
 883     IDirect3DRM2Impl_CreateDeviceFromSurface,
 884     IDirect3DRM2Impl_CreateDeviceFromD3D,
 885     IDirect3DRM2Impl_CreateDeviceFromClipper,
 886     IDirect3DRM2Impl_CreateTextureFromSurface,
 887     IDirect3DRM2Impl_CreateShadow,
 888     IDirect3DRM2Impl_CreateViewport,
 889     IDirect3DRM2Impl_CreateWrap,
 890     IDirect3DRM2Impl_CreateUserVisual,
 891     IDirect3DRM2Impl_LoadTexture,
 892     IDirect3DRM2Impl_LoadTextureFromResource,
 893     IDirect3DRM2Impl_SetSearchPath,
 894     IDirect3DRM2Impl_AddSearchPath,
 895     IDirect3DRM2Impl_GetSearchPath,
 896     IDirect3DRM2Impl_SetDefaultTextureColors,
 897     IDirect3DRM2Impl_SetDefaultTextureShades,
 898     IDirect3DRM2Impl_GetDevices,
 899     IDirect3DRM2Impl_GetNamedObject,
 900     IDirect3DRM2Impl_EnumerateObjects,
 901     IDirect3DRM2Impl_Load,
 902     IDirect3DRM2Impl_Tick,
 903     IDirect3DRM2Impl_CreateProgressiveMesh
 904 };
 905
 906
 907 /*** IUnknown methods ***/
 908 static HRESULT WINAPI IDirect3DRM3Impl_QueryInterface(IDirect3DRM3* iface, REFIID riid,
 909                                                       void** ppvObject)
 910 {
 911     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
 912     return IDirect3DRM_QueryInterface(&This->IDirect3DRM_iface, riid, ppvObject);
 913 }
 914
 915 static ULONG WINAPI IDirect3DRM3Impl_AddRef(IDirect3DRM3* iface)
 916 {
 917     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
 918     return IDirect3DRM_AddRef(&This->IDirect3DRM_iface);
 919 }
 920
 921 static ULONG WINAPI IDirect3DRM3Impl_Release(IDirect3DRM3* iface)
 922 {
 923     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
 924     return IDirect3DRM_Release(&This->IDirect3DRM_iface);
 925 }
 926
 927 /*** IDirect3DRM3 methods ***/
 928 static HRESULT WINAPI IDirect3DRM3Impl_CreateObject(IDirect3DRM3* iface, REFCLSID rclsid,
 929                                                     LPUNKNOWN unkwn, REFIID riid, LPVOID* object)
 930 {
 931     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
 932
 933     FIXME("(%p/%p)->(%s,%p,%s,%p): stub\n", iface, This, debugstr_guid(rclsid), unkwn,
 934           debugstr_guid(riid), object);
 935
 936     return E_NOTIMPL;
 937 }
 938
 939 static HRESULT WINAPI IDirect3DRM3Impl_CreateFrame(IDirect3DRM3* iface,
 940                                                    LPDIRECT3DRMFRAME3 FrameParent,
 941                                                    LPDIRECT3DRMFRAME3* Frame)
 942 {
 943     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
 944
 945     TRACE("(%p/%p)->(%p,%p)\n", iface, This, FrameParent, Frame);
 946
 947     if (FrameParent)
 948         FIXME("(%p/%p): Parent frame not yet supported\n", iface, This);
 949
 950     return Direct3DRMFrame_create(&IID_IDirect3DRMFrame3, (IUnknown**)Frame);
 951 }
 952
 953 static HRESULT WINAPI IDirect3DRM3Impl_CreateMesh(IDirect3DRM3* iface, LPDIRECT3DRMMESH* Mesh)
 954 {
 955     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
 956
 957     FIXME("(%p/%p)->(%p): stub\n", iface, This, Mesh);
 958
 959     return E_NOTIMPL;
 960 }
 961
 962 static HRESULT WINAPI IDirect3DRM3Impl_CreateMeshBuilder(IDirect3DRM3* iface,
 963                                                          LPDIRECT3DRMMESHBUILDER3* ppMeshBuilder)
 964 {
 965     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
 966
 967     TRACE("(%p/%p)->(%p)\n", iface, This, ppMeshBuilder);
 968
 969     return Direct3DRMMeshBuilder_create(&IID_IDirect3DRMMeshBuilder3, (IUnknown**)ppMeshBuilder);
 970 }
 971
 972 static HRESULT WINAPI IDirect3DRM3Impl_CreateFace(IDirect3DRM3* iface, LPDIRECT3DRMFACE2* Face)
 973 {
 974     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
 975
 976     FIXME("(%p/%p)->(%p): stub\n", iface, This, Face);
 977
 978     return E_NOTIMPL;
 979 }
 980
 981 static HRESULT WINAPI IDirect3DRM3Impl_CreateAnimation(IDirect3DRM3* iface,
 982                                                        LPDIRECT3DRMANIMATION2* Animation)
 983 {
 984     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
 985
 986     FIXME("(%p/%p)->(%p): stub\n", iface, This, Animation);
 987
 988     return E_NOTIMPL;
 989 }
 990
 991 static HRESULT WINAPI IDirect3DRM3Impl_CreateAnimationSet(IDirect3DRM3* iface,
 992                                                           LPDIRECT3DRMANIMATIONSET2* AnimationSet)
 993 {
 994     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
 995
 996     FIXME("(%p/%p)->(%p): stub\n", iface, This, AnimationSet);
 997
 998     return E_NOTIMPL;
 999 }
1000
1001 static HRESULT WINAPI IDirect3DRM3Impl_CreateTexture(IDirect3DRM3* iface, LPD3DRMIMAGE Image,
1002                                                      LPDIRECT3DRMTEXTURE3* Texture)
1003 {
1004     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1005
1006     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, Image, Texture);
1007
1008     return E_NOTIMPL;
1009 }
1010
1011 static HRESULT WINAPI IDirect3DRM3Impl_CreateLight(IDirect3DRM3* iface, D3DRMLIGHTTYPE type,
1012                                                      D3DCOLOR color, LPDIRECT3DRMLIGHT* Light)
1013 {
1014     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1015     HRESULT ret;
1016
1017     FIXME("(%p/%p)->(%d,%d,%p): partial stub\n", iface, This, type, color, Light);
1018
1019     ret = Direct3DRMLight_create((IUnknown**)Light);
1020
1021     if (SUCCEEDED(ret))
1022     {
1023         IDirect3DRMLight_SetType(*Light, type);
1024         IDirect3DRMLight_SetColor(*Light, color);
1025     }
1026
1027     return ret;
1028 }
1029
1030 static HRESULT WINAPI IDirect3DRM3Impl_CreateLightRGB(IDirect3DRM3* iface, D3DRMLIGHTTYPE type,
1031                                                         D3DVALUE red, D3DVALUE green, D3DVALUE blue,
1032                                                         LPDIRECT3DRMLIGHT* Light)
1033 {
1034     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1035     HRESULT ret;
1036
1037     FIXME("(%p/%p)->(%d,%f,%f,%f,%p): partial stub\n", iface, This, type, red, green, blue, Light);
1038
1039     ret = Direct3DRMLight_create((IUnknown**)Light);
1040
1041     if (SUCCEEDED(ret))
1042     {
1043         IDirect3DRMLight_SetType(*Light, type);
1044         IDirect3DRMLight_SetColorRGB(*Light, red, green, blue);
1045     }
1046
1047     return ret;
1048 }
1049
1050 static HRESULT WINAPI IDirect3DRM3Impl_Material(IDirect3DRM3* iface, D3DVALUE m,
1051                                                 LPDIRECT3DRMMATERIAL2* Material)
1052 {
1053     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1054
1055     FIXME("(%p/%p)->(%f,%p): stub\n", iface, This, m, Material);
1056
1057     return E_NOTIMPL;
1058 }
1059
1060 static HRESULT WINAPI IDirect3DRM3Impl_CreateDevice(IDirect3DRM3* iface, DWORD width, DWORD height,
1061                                                     LPDIRECT3DRMDEVICE3* device)
1062 {
1063     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1064
1065     FIXME("(%p/%p)->(%d,%d,%p): partial stub\n", iface, This, width, height, device);
1066
1067     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice3, (IUnknown**)device);
1068 }
1069
1070 static HRESULT WINAPI IDirect3DRM3Impl_CreateDeviceFromSurface(IDirect3DRM3* iface, LPGUID pGUID,
1071                                                                LPDIRECTDRAW dd,
1072                                                                LPDIRECTDRAWSURFACE back,
1073                                                                LPDIRECT3DRMDEVICE3* device)
1074 {
1075     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1076
1077     FIXME("(%p/%p)->(%s,%p,%p,%p): partial stub\n", iface, This, debugstr_guid(pGUID), dd, back, device);
1078
1079     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice3, (IUnknown**)device);
1080 }
1081
1082 static HRESULT WINAPI IDirect3DRM3Impl_CreateDeviceFromD3D(IDirect3DRM3* iface, LPDIRECT3D2 d3d,
1083                                                            LPDIRECT3DDEVICE2 d3ddev,
1084                                                            LPDIRECT3DRMDEVICE3* device)
1085 {
1086     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1087
1088     FIXME("(%p/%p)->(%p,%p,%p): partial stub\n", iface, This, d3d, d3ddev, device);
1089
1090     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice3, (IUnknown**)device);
1091 }
1092
1093 static HRESULT WINAPI IDirect3DRM3Impl_CreateDeviceFromClipper(IDirect3DRM3* iface,
1094                                                                LPDIRECTDRAWCLIPPER clipper,
1095                                                                LPGUID GUID, int width, int height,
1096                                                                LPDIRECT3DRMDEVICE3* device)
1097 {
1098     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1099
1100     FIXME("(%p/%p)->(%p,%s,%d,%d,%p): partial stub\n", iface, This, clipper, debugstr_guid(GUID),
1101           width, height, device);
1102
1103     return Direct3DRMDevice_create(&IID_IDirect3DRMDevice3, (IUnknown**)device);
1104 }
1105
1106 static HRESULT WINAPI IDirect3DRM3Impl_CreateShadow(IDirect3DRM3* iface, LPUNKNOWN Visual1,
1107                                                     LPDIRECT3DRMLIGHT Light, D3DVALUE px,
1108                                                     D3DVALUE py, D3DVALUE pz, D3DVALUE nx,
1109                                                     D3DVALUE ny, D3DVALUE nz,
1110                                                     LPDIRECT3DRMSHADOW2* Visual2)
1111 {
1112     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1113
1114     FIXME("(%p/%p)->(%p,%p,%f,%f,%f,%f,%f,%f,%p): stub\n", iface, This, Visual1, Light, px, py, pz,
1115           nx, ny, nz, Visual2);
1116
1117     return E_NOTIMPL;
1118 }
1119
1120 static HRESULT WINAPI IDirect3DRM3Impl_CreateTextureFromSurface(IDirect3DRM3* iface,
1121                                                                 LPDIRECTDRAWSURFACE surface,
1122                                                                 LPDIRECT3DRMTEXTURE3* texture)
1123 {
1124     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1125
1126     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, surface, texture);
1127
1128     return E_NOTIMPL;
1129 }
1130
1131 static HRESULT WINAPI IDirect3DRM3Impl_CreateViewport(IDirect3DRM3* iface,
1132                                                       LPDIRECT3DRMDEVICE3 Device,
1133                                                       LPDIRECT3DRMFRAME3 frame, DWORD xpos,
1134                                                       DWORD ypos, DWORD width, DWORD height,
1135                                                       LPDIRECT3DRMVIEWPORT2* viewport)
1136 {
1137     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1138
1139     FIXME("(%p/%p)->(%p,%p,%d,%d,%d,%d,%p): stub\n", iface, This, Device, frame, xpos, ypos, width,
1140           height, viewport);
1141
1142     return Direct3DRMViewport_create(&IID_IDirect3DRMViewport2, (IUnknown**)viewport);
1143 }
1144
1145 static HRESULT WINAPI IDirect3DRM3Impl_CreateWrap(IDirect3DRM3* iface, D3DRMWRAPTYPE type,
1146                                                   LPDIRECT3DRMFRAME3 frame,
1147                                                   D3DVALUE ox, D3DVALUE oy, D3DVALUE oz,
1148                                                   D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
1149                                                   D3DVALUE ux, D3DVALUE uy, D3DVALUE uz,
1150                                                   D3DVALUE ou, D3DVALUE ov, D3DVALUE su,
1151                                                   D3DVALUE sv, LPDIRECT3DRMWRAP* wrap)
1152 {
1153     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1154
1155     FIXME("(%p/%p)->(%d,%p,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%p): stub\n", iface, This, type,
1156           frame, ox, oy, oz, dx, dy, dz, ux, uy, uz, ou, ov, su, sv, wrap);
1157
1158     return E_NOTIMPL;
1159 }
1160
1161 static HRESULT WINAPI IDirect3DRM3Impl_CreateUserVisual(IDirect3DRM3* iface,
1162                                                         D3DRMUSERVISUALCALLBACK cb, LPVOID arg,
1163                                                         LPDIRECT3DRMUSERVISUAL* UserVisual)
1164 {
1165     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1166
1167     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, cb, arg, UserVisual);
1168
1169     return E_NOTIMPL;
1170 }
1171
1172 static HRESULT WINAPI IDirect3DRM3Impl_LoadTexture(IDirect3DRM3* iface, const char* filename,
1173                                                    LPDIRECT3DRMTEXTURE3* Texture)
1174 {
1175     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1176
1177     FIXME("(%p/%p)->(%s,%p): stub\n", iface, This, filename, Texture);
1178
1179     return E_NOTIMPL;
1180 }
1181
1182 static HRESULT WINAPI IDirect3DRM3Impl_LoadTextureFromResource(IDirect3DRM3* iface, HMODULE mod,
1183                                                                LPCSTR strName, LPCSTR strType,
1184                                                                LPDIRECT3DRMTEXTURE3 * ppTexture)
1185 {
1186     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1187
1188     FIXME("(%p/%p)->(%p,%p,%p,%p): stub\n", iface, This, mod, strName, strType, ppTexture);
1189
1190     return E_NOTIMPL;
1191 }
1192
1193 static HRESULT WINAPI IDirect3DRM3Impl_SetSearchPath(IDirect3DRM3* iface, LPCSTR path)
1194 {
1195     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1196
1197     FIXME("(%p/%p)->(%s): stub\n", iface, This, path);
1198
1199     return E_NOTIMPL;
1200 }
1201
1202 static HRESULT WINAPI IDirect3DRM3Impl_AddSearchPath(IDirect3DRM3* iface, LPCSTR path)
1203 {
1204     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1205
1206     FIXME("(%p/%p)->(%s): stub\n", iface, This, path);
1207
1208     return E_NOTIMPL;
1209 }
1210
1211 static HRESULT WINAPI IDirect3DRM3Impl_GetSearchPath(IDirect3DRM3* iface, DWORD* size_return,
1212                                                      LPSTR path_return)
1213 {
1214     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1215
1216     FIXME("(%p/%p)->(%p,%s): stub\n", iface, This, size_return, path_return);
1217
1218     return E_NOTIMPL;
1219 }
1220
1221 static HRESULT WINAPI IDirect3DRM3Impl_SetDefaultTextureColors(IDirect3DRM3* iface, DWORD nb_colors)
1222 {
1223     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1224
1225     FIXME("(%p/%p)->(%d): stub\n", iface, This, nb_colors);
1226
1227     return E_NOTIMPL;
1228 }
1229
1230 static HRESULT WINAPI IDirect3DRM3Impl_SetDefaultTextureShades(IDirect3DRM3* iface, DWORD nb_shades)
1231 {
1232     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1233
1234     FIXME("(%p/%p)->(%d): stub\n", iface, This, nb_shades);
1235
1236     return E_NOTIMPL;
1237 }
1238
1239 static HRESULT WINAPI IDirect3DRM3Impl_GetDevices(IDirect3DRM3* iface,
1240                                                   LPDIRECT3DRMDEVICEARRAY* DeviceArray)
1241 {
1242     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1243
1244     FIXME("(%p/%p)->(%p): stub\n", iface, This, DeviceArray);
1245
1246     return E_NOTIMPL;
1247 }
1248
1249 static HRESULT WINAPI IDirect3DRM3Impl_GetNamedObject(IDirect3DRM3* iface, const char* Name,
1250                                                       LPDIRECT3DRMOBJECT* Object)
1251 {
1252     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1253
1254     FIXME("(%p/%p)->(%s,%p): stub\n", iface, This, Name, Object);
1255
1256     return E_NOTIMPL;
1257 }
1258
1259 static HRESULT WINAPI IDirect3DRM3Impl_EnumerateObjects(IDirect3DRM3* iface, D3DRMOBJECTCALLBACK cb,
1260                                                         LPVOID arg)
1261 {
1262     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1263
1264     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
1265
1266     return E_NOTIMPL;
1267 }
1268
1269 static HRESULT WINAPI IDirect3DRM3Impl_Load(IDirect3DRM3* iface, LPVOID ObjSource, LPVOID ObjID,
1270                                             LPIID* GUIDs, DWORD nb_GUIDs, D3DRMLOADOPTIONS LOFlags,
1271                                             D3DRMLOADCALLBACK LoadProc, LPVOID ArgLP,
1272                                             D3DRMLOADTEXTURECALLBACK LoadTextureProc, LPVOID ArgLTP,
1273                                             LPDIRECT3DRMFRAME3 ParentFrame)
1274 {
1275     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1276     DXFILELOADOPTIONS load_options;
1277     LPDIRECTXFILE pDXFile = NULL;
1278     LPDIRECTXFILEENUMOBJECT pEnumObject = NULL;
1279     LPDIRECTXFILEDATA pData = NULL;
1280     HRESULT hr;
1281     const GUID* pGuid;
1282     DWORD size;
1283     Header* pHeader;
1284     HRESULT ret = D3DRMERR_BADOBJECT;
1285     DWORD i;
1286
1287     FIXME("(%p/%p)->(%p,%p,%p,%d,%d,%p,%p,%p,%p,%p): partial implementation\n", iface, This, ObjSource, ObjID, GUIDs,
1288           nb_GUIDs, LOFlags, LoadProc, ArgLP, LoadTextureProc, ArgLTP, ParentFrame);
1289
1290     TRACE("Looking for GUIDs:\n");
1291     for (i = 0; i < nb_GUIDs; i++)
1292         TRACE("- %s (%s)\n", debugstr_guid(GUIDs[i]), get_IID_string(GUIDs[i]));
1293
1294     if (LOFlags == D3DRMLOAD_FROMMEMORY)
1295     {
1296         load_options = DXFILELOAD_FROMMEMORY;
1297     }
1298     else if (LOFlags == D3DRMLOAD_FROMFILE)
1299     {
1300         load_options = DXFILELOAD_FROMFILE;
1301         TRACE("Loading from file %s\n", debugstr_a(ObjSource));
1302     }
1303     else
1304     {
1305         FIXME("Load options %d not supported yet\n", LOFlags);
1306         return E_NOTIMPL;
1307     }
1308
1309     hr = DirectXFileCreate(&pDXFile);
1310     if (hr != DXFILE_OK)
1311         goto end;
1312
1313     hr = IDirectXFile_RegisterTemplates(pDXFile, templates, strlen(templates));
1314     if (hr != DXFILE_OK)
1315         goto end;
1316
1317     hr = IDirectXFile_CreateEnumObject(pDXFile, ObjSource, load_options, &pEnumObject);
1318     if (hr != DXFILE_OK)
1319         goto end;
1320
1321     hr = IDirectXFileEnumObject_GetNextDataObject(pEnumObject, &pData);
1322     if (hr != DXFILE_OK)
1323         goto end;
1324
1325     hr = IDirectXFileData_GetType(pData, &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(pData, NULL, &size, (void**)&pHeader);
1338     if ((hr != DXFILE_OK) || (size != sizeof(Header)))
1339         goto end;
1340
1341     TRACE("Version is %d %d %d\n", pHeader->major, pHeader->minor, pHeader->flags);
1342
1343     /* Version must be 1.0.x */
1344     if ((pHeader->major != 1) || (pHeader->minor != 0))
1345     {
1346         ret = D3DRMERR_BADFILE;
1347         goto end;
1348     }
1349
1350     IDirectXFileData_Release(pData);
1351     pData = NULL;
1352
1353     while (1)
1354     {
1355         hr = IDirectXFileEnumObject_GetNextDataObject(pEnumObject, &pData);
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_NOTFOUND;
1364             goto end;
1365         }
1366
1367         hr = IDirectXFileData_GetType(pData, &pGuid);
1368         if (hr != DXFILE_OK)
1369             goto end;
1370
1371         TRACE("Found object type whose GUID = %s\n", debugstr_guid(pGuid));
1372
1373         if (IsEqualGUID(pGuid, &TID_D3DRMMesh))
1374         {
1375             BOOL requested = FALSE;
1376             HRESULT hr;
1377
1378             TRACE("Found TID_D3DRMMesh\n");
1379
1380             for (i = 0; i < nb_GUIDs; i++)
1381                 if (IsEqualGUID(GUIDs[i], &IID_IDirect3DRMMeshBuilder) ||
1382                     IsEqualGUID(GUIDs[i], &IID_IDirect3DRMMeshBuilder2) ||
1383                     IsEqualGUID(GUIDs[i], &IID_IDirect3DRMMeshBuilder3))
1384                 {
1385                     requested = TRUE;
1386                     break;
1387                 }
1388
1389             if (requested)
1390             {
1391                 LPDIRECT3DRMMESHBUILDER3 meshbuilder;
1392
1393                 FIXME("Load mesh data and notify application\n");
1394
1395                 hr = IDirect3DRM3_CreateMeshBuilder(iface, &meshbuilder);
1396                 if (SUCCEEDED(hr))
1397                 {
1398                     LPDIRECT3DRMOBJECT object = NULL;
1399
1400                     hr = IDirect3DRMMeshBuilder3_QueryInterface(meshbuilder, GUIDs[i], (void**)&object);
1401                     if (SUCCEEDED(hr))
1402                     {
1403                         hr = load_mesh_data(meshbuilder, pData);
1404                         if (SUCCEEDED(hr))
1405                             LoadProc(object, GUIDs[i], ArgLP);
1406                         IDirect3DRMObject_Release(object);
1407                     }
1408                     IDirect3DRMMeshBuilder3_Release(meshbuilder);
1409                 }
1410
1411                 if (FAILED(hr))
1412                     ERR("Cannot process mesh\n");
1413             }
1414         }
1415         else if (IsEqualGUID(pGuid, &TID_D3DRMFrame))
1416         {
1417             BOOL requested = FALSE;
1418             HRESULT hr;
1419
1420             TRACE("Found TID_D3DRMFrame\n");
1421
1422             for (i = 0; i < nb_GUIDs; i++)
1423                 if (IsEqualGUID(GUIDs[i], &IID_IDirect3DRMFrame) ||
1424                     IsEqualGUID(GUIDs[i], &IID_IDirect3DRMFrame2) ||
1425                     IsEqualGUID(GUIDs[i], &IID_IDirect3DRMFrame3))
1426                 {
1427                     requested = TRUE;
1428                     break;
1429                 }
1430
1431             if (requested)
1432             {
1433                 LPDIRECT3DRMFRAME3 frame;
1434
1435                 FIXME("Fake frame data and notify application\n");
1436
1437                 hr = IDirect3DRM3_CreateFrame(iface, NULL, &frame);
1438                 if (SUCCEEDED(hr))
1439                 {
1440                     LPDIRECT3DRMOBJECT object;
1441
1442                     hr = IDirect3DRMFrame3_QueryInterface(frame, GUIDs[i], (void**)&object);
1443                     if (SUCCEEDED(hr))
1444                     {
1445                         LoadProc(object, GUIDs[i], ArgLP);
1446                         IDirect3DRMObject_Release(object);
1447                     }
1448                     IDirect3DRMFrame3_Release(frame);
1449                 }
1450
1451                 if (FAILED(hr))
1452                     ERR("Cannot process frame\n");
1453
1454             }
1455         }
1456         else if (IsEqualGUID(pGuid, &TID_D3DRMMaterial))
1457         {
1458             BOOL requested = FALSE;
1459
1460             TRACE("Found TID_D3DRMMaterial\n");
1461
1462             for (i = 0; i < nb_GUIDs; i++)
1463                 if (IsEqualGUID(GUIDs[i], &IID_IDirect3DRMMaterial) ||
1464                     IsEqualGUID(GUIDs[i], &IID_IDirect3DRMMaterial2))
1465                     requested = TRUE;
1466
1467             if (requested)
1468             {
1469                 FIXME("Processing material not supported yet\n");
1470             }
1471         }
1472         else
1473         {
1474             FIXME("Found unknown TID %s\n", debugstr_guid(pGuid));
1475         }
1476         IDirectXFileData_Release(pData);
1477         pData = NULL;
1478     }
1479
1480     ret = D3DRM_OK;
1481
1482 end:
1483     if (pData)
1484         IDirectXFileData_Release(pData);
1485     if (pEnumObject)
1486         IDirectXFileEnumObject_Release(pEnumObject);
1487     if (pDXFile)
1488         IDirectXFile_Release(pDXFile);
1489
1490     return ret;
1491 }
1492
1493 static HRESULT WINAPI IDirect3DRM3Impl_Tick(IDirect3DRM3* iface, D3DVALUE tick)
1494 {
1495     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1496
1497     FIXME("(%p/%p)->(%f): stub\n", iface, This, tick);
1498
1499     return E_NOTIMPL;
1500 }
1501
1502 static HRESULT WINAPI IDirect3DRM3Impl_CreateProgressiveMesh(IDirect3DRM3* iface,
1503                                                              LPDIRECT3DRMPROGRESSIVEMESH Mesh)
1504 {
1505     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1506
1507     FIXME("(%p/%p)->(%p): stub\n", iface, This, Mesh);
1508
1509     return E_NOTIMPL;
1510 }
1511
1512 static HRESULT WINAPI IDirect3DRM3Impl_RegisterClient(IDirect3DRM3* iface, REFGUID rguid,
1513                                                       LPDWORD id)
1514 {
1515     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1516
1517     FIXME("(%p/%p)->(%s, %p): stub\n", iface, This, debugstr_guid(rguid), id);
1518
1519     return E_NOTIMPL;
1520 }
1521
1522 static HRESULT WINAPI IDirect3DRM3Impl_UnregisterClient(IDirect3DRM3* iface, REFGUID rguid)
1523 {
1524     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1525
1526     FIXME("(%p/%p)->(%s): stub\n", iface, This, debugstr_guid(rguid));
1527
1528     return E_NOTIMPL;
1529 }
1530
1531 static HRESULT WINAPI IDirect3DRM3Impl_CreateClippedVisual(IDirect3DRM3* iface,
1532                                                            LPDIRECT3DRMVISUAL vis,
1533                                                            LPDIRECT3DRMCLIPPEDVISUAL* clippedvis)
1534 {
1535     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1536
1537     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, vis, clippedvis);
1538
1539     return E_NOTIMPL;
1540 }
1541
1542 static HRESULT WINAPI IDirect3DRM3Impl_SetOptions(IDirect3DRM3* iface, DWORD opt)
1543 {
1544     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1545
1546     FIXME("(%p/%p)->(%d): stub\n", iface, This, opt);
1547
1548     return E_NOTIMPL;
1549 }
1550
1551 static HRESULT WINAPI IDirect3DRM3Impl_GetOptions(IDirect3DRM3* iface, LPDWORD opt)
1552 {
1553     IDirect3DRMImpl *This = impl_from_IDirect3DRM3(iface);
1554
1555     FIXME("(%p/%p)->(%p): stub\n", iface, This, opt);
1556
1557     return E_NOTIMPL;
1558 }
1559
1560 static const struct IDirect3DRM3Vtbl Direct3DRM3_Vtbl =
1561 {
1562     IDirect3DRM3Impl_QueryInterface,
1563     IDirect3DRM3Impl_AddRef,
1564     IDirect3DRM3Impl_Release,
1565     IDirect3DRM3Impl_CreateObject,
1566     IDirect3DRM3Impl_CreateFrame,
1567     IDirect3DRM3Impl_CreateMesh,
1568     IDirect3DRM3Impl_CreateMeshBuilder,
1569     IDirect3DRM3Impl_CreateFace,
1570     IDirect3DRM3Impl_CreateAnimation,
1571     IDirect3DRM3Impl_CreateAnimationSet,
1572     IDirect3DRM3Impl_CreateTexture,
1573     IDirect3DRM3Impl_CreateLight,
1574     IDirect3DRM3Impl_CreateLightRGB,
1575     IDirect3DRM3Impl_Material,
1576     IDirect3DRM3Impl_CreateDevice,
1577     IDirect3DRM3Impl_CreateDeviceFromSurface,
1578     IDirect3DRM3Impl_CreateDeviceFromD3D,
1579     IDirect3DRM3Impl_CreateDeviceFromClipper,
1580     IDirect3DRM3Impl_CreateTextureFromSurface,
1581     IDirect3DRM3Impl_CreateShadow,
1582     IDirect3DRM3Impl_CreateViewport,
1583     IDirect3DRM3Impl_CreateWrap,
1584     IDirect3DRM3Impl_CreateUserVisual,
1585     IDirect3DRM3Impl_LoadTexture,
1586     IDirect3DRM3Impl_LoadTextureFromResource,
1587     IDirect3DRM3Impl_SetSearchPath,
1588     IDirect3DRM3Impl_AddSearchPath,
1589     IDirect3DRM3Impl_GetSearchPath,
1590     IDirect3DRM3Impl_SetDefaultTextureColors,
1591     IDirect3DRM3Impl_SetDefaultTextureShades,
1592     IDirect3DRM3Impl_GetDevices,
1593     IDirect3DRM3Impl_GetNamedObject,
1594     IDirect3DRM3Impl_EnumerateObjects,
1595     IDirect3DRM3Impl_Load,
1596     IDirect3DRM3Impl_Tick,
1597     IDirect3DRM3Impl_CreateProgressiveMesh,
1598     IDirect3DRM3Impl_RegisterClient,
1599     IDirect3DRM3Impl_UnregisterClient,
1600     IDirect3DRM3Impl_CreateClippedVisual,
1601     IDirect3DRM3Impl_SetOptions,
1602     IDirect3DRM3Impl_GetOptions
1603 };
1604
1605 HRESULT Direct3DRM_create(IUnknown** ppObj)
1606 {
1607     IDirect3DRMImpl* object;
1608
1609     TRACE("(%p)\n", ppObj);
1610
1611     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMImpl));
1612     if (!object)
1613     {
1614         ERR("Out of memory\n");
1615         return E_OUTOFMEMORY;
1616     }
1617
1618     object->IDirect3DRM_iface.lpVtbl = &Direct3DRM_Vtbl;
1619     object->IDirect3DRM2_iface.lpVtbl = &Direct3DRM2_Vtbl;
1620     object->IDirect3DRM3_iface.lpVtbl = &Direct3DRM3_Vtbl;
1621     object->ref = 1;
1622
1623     *ppObj = (IUnknown*)&object->IDirect3DRM_iface;
1624
1625     return S_OK;
1626 }