git.oblomov.eu Git - wine/blob - dlls/d3drm/frame.c

   1 /*
   2  * Implementation of IDirect3DRMFrame Interface
   3  *
   4  * Copyright 2011, 2012 André Hentschel
   5  * Copyright 2012 Christian Costa
   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 <assert.h>
  23 #include "wine/debug.h"
  24
  25 #define COBJMACROS
  26
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29
  30 #include "d3drm_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(d3drm);
  33
  34 static D3DRMMATRIX4D identity = {
  35     { 1.0f, 0.0f, 0.0f, 0.0f },
  36     { 0.0f, 1.0f, 0.0f, 0.0f },
  37     { 0.0f, 0.0f, 1.0f, 0.0f },
  38     { 0.0f, 0.0f, 0.0f, 1.0f }
  39 };
  40
  41 typedef struct IDirect3DRMFrameImpl IDirect3DRMFrameImpl;
  42
  43 struct IDirect3DRMFrameImpl {
  44     IDirect3DRMFrame2 IDirect3DRMFrame2_iface;
  45     IDirect3DRMFrame3 IDirect3DRMFrame3_iface;
  46     LONG ref;
  47     IDirect3DRMFrameImpl* parent;
  48     ULONG nb_children;
  49     ULONG children_capacity;
  50     IDirect3DRMFrame3** children;
  51     ULONG nb_visuals;
  52     ULONG visuals_capacity;
  53     IDirect3DRMVisual** visuals;
  54     ULONG nb_lights;
  55     ULONG lights_capacity;
  56     IDirect3DRMLight** lights;
  57     D3DRMMATRIX4D transform;
  58     D3DCOLOR scenebackground;
  59 };
  60
  61 typedef struct {
  62     IDirect3DRMFrameArray IDirect3DRMFrameArray_iface;
  63     LONG ref;
  64     ULONG size;
  65     IDirect3DRMFrame **frames;
  66 } IDirect3DRMFrameArrayImpl;
  67
  68 typedef struct {
  69     IDirect3DRMVisualArray IDirect3DRMVisualArray_iface;
  70     LONG ref;
  71     ULONG size;
  72     IDirect3DRMVisual **visuals;
  73 } IDirect3DRMVisualArrayImpl;
  74
  75 typedef struct {
  76     IDirect3DRMLightArray IDirect3DRMLightArray_iface;
  77     LONG ref;
  78     ULONG size;
  79     IDirect3DRMLight **lights;
  80 } IDirect3DRMLightArrayImpl;
  81
  82 static inline IDirect3DRMFrameImpl *impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface)
  83 {
  84     return CONTAINING_RECORD(iface, IDirect3DRMFrameImpl, IDirect3DRMFrame2_iface);
  85 }
  86
  87 static inline IDirect3DRMFrameImpl *impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
  88 {
  89     return CONTAINING_RECORD(iface, IDirect3DRMFrameImpl, IDirect3DRMFrame3_iface);
  90 }
  91
  92 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface);
  93
  94 static inline IDirect3DRMLightArrayImpl *impl_from_IDirect3DRMLightArray(IDirect3DRMLightArray *iface)
  95 {
  96     return CONTAINING_RECORD(iface, IDirect3DRMLightArrayImpl, IDirect3DRMLightArray_iface);
  97 }
  98
  99 /*** IUnknown methods ***/
 100 static HRESULT WINAPI IDirect3DRMFrameArrayImpl_QueryInterface(IDirect3DRMFrameArray* iface,
 101                                                                REFIID riid, void** object)
 102 {
 103     IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
 104
 105     TRACE("(%p/%p)->(%s, %p)\n", iface, This, debugstr_guid(riid), object);
 106
 107     *object = NULL;
 108
 109     if (IsEqualGUID(riid, &IID_IUnknown) ||
 110         IsEqualGUID(riid, &IID_IDirect3DRMFrameArray))
 111     {
 112         *object = &This->IDirect3DRMFrameArray_iface;
 113     }
 114     else
 115     {
 116         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 117         return E_NOINTERFACE;
 118     }
 119
 120     IDirect3DRMFrameArray_AddRef(iface);
 121     return S_OK;
 122 }
 123
 124 static ULONG WINAPI IDirect3DRMFrameArrayImpl_AddRef(IDirect3DRMFrameArray* iface)
 125 {
 126     IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
 127     ULONG ref = InterlockedIncrement(&This->ref);
 128
 129     TRACE("(%p)->(): new ref = %u\n", This, ref);
 130
 131     return ref;
 132 }
 133
 134 static ULONG WINAPI IDirect3DRMFrameArrayImpl_Release(IDirect3DRMFrameArray* iface)
 135 {
 136     IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
 137     ULONG ref = InterlockedDecrement(&This->ref);
 138     ULONG i;
 139
 140     TRACE("(%p)->(): new ref = %u\n", This, ref);
 141
 142     if (!ref)
 143     {
 144         for (i = 0; i < This->size; i++)
 145             IDirect3DRMFrame_Release(This->frames[i]);
 146         HeapFree(GetProcessHeap(), 0, This->frames);
 147         HeapFree(GetProcessHeap(), 0, This);
 148     }
 149
 150     return ref;
 151 }
 152
 153 /*** IDirect3DRMArray methods ***/
 154 static DWORD WINAPI IDirect3DRMFrameArrayImpl_GetSize(IDirect3DRMFrameArray* iface)
 155 {
 156     IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
 157
 158     TRACE("(%p)->() = %d\n", This,  This->size);
 159
 160     return This->size;
 161 }
 162
 163 /*** IDirect3DRMFrameArray methods ***/
 164 static HRESULT WINAPI IDirect3DRMFrameArrayImpl_GetElement(IDirect3DRMFrameArray *iface,
 165         DWORD index, IDirect3DRMFrame **frame)
 166 {
 167     IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
 168
 169     TRACE("(%p)->(%u, %p)\n", This, index, frame);
 170
 171     if (!frame)
 172         return D3DRMERR_BADVALUE;
 173
 174     *frame = NULL;
 175
 176     if (index >= This->size)
 177         return D3DRMERR_BADVALUE;
 178
 179     IDirect3DRMFrame_AddRef(This->frames[index]);
 180     *frame = This->frames[index];
 181
 182     return D3DRM_OK;
 183 }
 184
 185 static const struct IDirect3DRMFrameArrayVtbl Direct3DRMFrameArray_Vtbl =
 186 {
 187     /*** IUnknown methods ***/
 188     IDirect3DRMFrameArrayImpl_QueryInterface,
 189     IDirect3DRMFrameArrayImpl_AddRef,
 190     IDirect3DRMFrameArrayImpl_Release,
 191     /*** IDirect3DRMArray methods ***/
 192     IDirect3DRMFrameArrayImpl_GetSize,
 193     /*** IDirect3DRMFrameArray methods ***/
 194     IDirect3DRMFrameArrayImpl_GetElement
 195 };
 196
 197 static HRESULT Direct3DRMFrameArray_create(IDirect3DRMFrameArray** obj)
 198 {
 199     IDirect3DRMFrameArrayImpl* object;
 200
 201     TRACE("(%p)\n", obj);
 202
 203     *obj = NULL;
 204
 205     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMFrameArrayImpl));
 206     if (!object)
 207         return E_OUTOFMEMORY;
 208
 209     object->IDirect3DRMFrameArray_iface.lpVtbl = &Direct3DRMFrameArray_Vtbl;
 210     object->ref = 1;
 211
 212     *obj = &object->IDirect3DRMFrameArray_iface;
 213
 214     return S_OK;
 215 }
 216
 217 /*** IUnknown methods ***/
 218 static HRESULT WINAPI IDirect3DRMVisualArrayImpl_QueryInterface(IDirect3DRMVisualArray* iface,
 219                                                                 REFIID riid, void** ret_iface)
 220 {
 221     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ret_iface);
 222
 223     if (IsEqualGUID(riid, &IID_IUnknown) ||
 224         IsEqualGUID(riid, &IID_IDirect3DRMFrameArray))
 225     {
 226         *ret_iface = iface;
 227         IDirect3DRMVisualArray_AddRef(iface);
 228         return S_OK;
 229     }
 230
 231     *ret_iface = NULL;
 232
 233     WARN("Interface %s not implemented\n", debugstr_guid(riid));
 234
 235     return E_NOINTERFACE;
 236 }
 237
 238 static ULONG WINAPI IDirect3DRMVisualArrayImpl_AddRef(IDirect3DRMVisualArray* iface)
 239 {
 240     IDirect3DRMVisualArrayImpl *This = (IDirect3DRMVisualArrayImpl*)iface;
 241     ULONG ref = InterlockedIncrement(&This->ref);
 242
 243     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 244
 245     return ref;
 246 }
 247
 248 static ULONG WINAPI IDirect3DRMVisualArrayImpl_Release(IDirect3DRMVisualArray* iface)
 249 {
 250     IDirect3DRMVisualArrayImpl *This = (IDirect3DRMVisualArrayImpl*)iface;
 251     ULONG ref = InterlockedDecrement(&This->ref);
 252     ULONG i;
 253
 254     TRACE("(%p)->(): new ref = %u\n", iface, ref);
 255
 256     if (!ref)
 257     {
 258         for (i = 0; i < This->size; i++)
 259             IDirect3DRMVisual_Release(This->visuals[i]);
 260         HeapFree(GetProcessHeap(), 0, This->visuals);
 261         HeapFree(GetProcessHeap(), 0, This);
 262     }
 263
 264     return ref;
 265 }
 266
 267 /*** IDirect3DRMArray methods ***/
 268 static DWORD WINAPI IDirect3DRMVisualArrayImpl_GetSize(IDirect3DRMVisualArray* iface)
 269 {
 270     IDirect3DRMVisualArrayImpl *This = (IDirect3DRMVisualArrayImpl*)iface;
 271
 272     TRACE("(%p)->() = %d\n", iface,  This->size);
 273
 274     return This->size;
 275 }
 276
 277 /*** IDirect3DRMVisualArray methods ***/
 278 static HRESULT WINAPI IDirect3DRMVisualArrayImpl_GetElement(IDirect3DRMVisualArray *iface,
 279         DWORD index, IDirect3DRMVisual **visual)
 280 {
 281     IDirect3DRMVisualArrayImpl *This = (IDirect3DRMVisualArrayImpl*)iface;
 282
 283     TRACE("(%p)->(%u, %p)\n", iface, index, visual);
 284
 285     if (!visual)
 286         return D3DRMERR_BADVALUE;
 287
 288     *visual = NULL;
 289
 290     if (index >= This->size)
 291         return D3DRMERR_BADVALUE;
 292
 293     IDirect3DRMVisual_AddRef(This->visuals[index]);
 294     *visual = This->visuals[index];
 295
 296     return D3DRM_OK;
 297 }
 298
 299 static const struct IDirect3DRMVisualArrayVtbl Direct3DRMVisualArray_Vtbl =
 300 {
 301     /*** IUnknown methods ***/
 302     IDirect3DRMVisualArrayImpl_QueryInterface,
 303     IDirect3DRMVisualArrayImpl_AddRef,
 304     IDirect3DRMVisualArrayImpl_Release,
 305     /*** IDirect3DRMArray methods ***/
 306     IDirect3DRMVisualArrayImpl_GetSize,
 307     /*** IDirect3DRMVisualArray methods ***/
 308     IDirect3DRMVisualArrayImpl_GetElement
 309 };
 310
 311 static HRESULT Direct3DRMVisualArray_create(IDirect3DRMVisualArray** ret_iface)
 312 {
 313     IDirect3DRMVisualArrayImpl* object;
 314
 315     TRACE("(%p)\n", ret_iface);
 316
 317     *ret_iface = NULL;
 318
 319     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMVisualArrayImpl));
 320     if (!object)
 321         return E_OUTOFMEMORY;
 322
 323     object->IDirect3DRMVisualArray_iface.lpVtbl = &Direct3DRMVisualArray_Vtbl;
 324     object->ref = 1;
 325
 326     *ret_iface = &object->IDirect3DRMVisualArray_iface;
 327
 328     return S_OK;
 329 }
 330
 331 /*** IUnknown methods ***/
 332 static HRESULT WINAPI IDirect3DRMLightArrayImpl_QueryInterface(IDirect3DRMLightArray* iface,
 333                                                                REFIID riid, void** object)
 334 {
 335     IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
 336
 337     TRACE("(%p/%p)->(%s, %p)\n", iface, This, debugstr_guid(riid), object);
 338
 339     *object = NULL;
 340
 341     if (IsEqualGUID(riid, &IID_IUnknown) ||
 342         IsEqualGUID(riid, &IID_IDirect3DRMLightArray))
 343     {
 344         *object = &This->IDirect3DRMLightArray_iface;
 345     }
 346     else
 347     {
 348         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 349         return E_NOINTERFACE;
 350     }
 351
 352     IDirect3DRMLightArray_AddRef(iface);
 353     return S_OK;
 354 }
 355
 356 static ULONG WINAPI IDirect3DRMLightArrayImpl_AddRef(IDirect3DRMLightArray* iface)
 357 {
 358     IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
 359     ULONG ref = InterlockedIncrement(&This->ref);
 360
 361     TRACE("(%p)->(): new ref = %u\n", This, ref);
 362
 363     return ref;
 364 }
 365
 366 static ULONG WINAPI IDirect3DRMLightArrayImpl_Release(IDirect3DRMLightArray* iface)
 367 {
 368     IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
 369     ULONG ref = InterlockedDecrement(&This->ref);
 370     ULONG i;
 371
 372     TRACE("(%p)->(): new ref = %u\n", This, ref);
 373
 374     if (!ref)
 375     {
 376         for (i = 0; i < This->size; i++)
 377             IDirect3DRMLight_Release(This->lights[i]);
 378         HeapFree(GetProcessHeap(), 0, This->lights);
 379         HeapFree(GetProcessHeap(), 0, This);
 380     }
 381
 382     return ref;
 383 }
 384
 385 /*** IDirect3DRMArray methods ***/
 386 static DWORD WINAPI IDirect3DRMLightArrayImpl_GetSize(IDirect3DRMLightArray* iface)
 387 {
 388     IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
 389
 390     TRACE("(%p)->() = %d\n", This,  This->size);
 391
 392     return This->size;
 393 }
 394
 395 /*** IDirect3DRMLightArray methods ***/
 396 static HRESULT WINAPI IDirect3DRMLightArrayImpl_GetElement(IDirect3DRMLightArray *iface,
 397         DWORD index, IDirect3DRMLight **light)
 398 {
 399     IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
 400
 401     TRACE("(%p)->(%u, %p)\n", This, index, light);
 402
 403     if (!light)
 404         return D3DRMERR_BADVALUE;
 405
 406     *light = NULL;
 407
 408     if (index >= This->size)
 409         return D3DRMERR_BADVALUE;
 410
 411     IDirect3DRMLight_AddRef(This->lights[index]);
 412     *light = This->lights[index];
 413
 414     return D3DRM_OK;
 415 }
 416
 417 static const struct IDirect3DRMLightArrayVtbl Direct3DRMLightArray_Vtbl =
 418 {
 419     /*** IUnknown methods ***/
 420     IDirect3DRMLightArrayImpl_QueryInterface,
 421     IDirect3DRMLightArrayImpl_AddRef,
 422     IDirect3DRMLightArrayImpl_Release,
 423     /*** IDirect3DRMArray methods ***/
 424     IDirect3DRMLightArrayImpl_GetSize,
 425     /*** IDirect3DRMLightArray methods ***/
 426     IDirect3DRMLightArrayImpl_GetElement
 427 };
 428
 429 static HRESULT Direct3DRMLightArray_create(IDirect3DRMLightArray** obj)
 430 {
 431     IDirect3DRMLightArrayImpl* object;
 432
 433     TRACE("(%p)\n", obj);
 434
 435     *obj = NULL;
 436
 437     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMLightArrayImpl));
 438     if (!object)
 439         return E_OUTOFMEMORY;
 440
 441     object->IDirect3DRMLightArray_iface.lpVtbl = &Direct3DRMLightArray_Vtbl;
 442     object->ref = 1;
 443
 444     *obj = &object->IDirect3DRMLightArray_iface;
 445
 446     return S_OK;
 447 }
 448
 449 /*** IUnknown methods ***/
 450 static HRESULT WINAPI IDirect3DRMFrame2Impl_QueryInterface(IDirect3DRMFrame2* iface,
 451                                                            REFIID riid, void** object)
 452 {
 453     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 454
 455     TRACE("(%p/%p)->(%s, %p)\n", iface, This, debugstr_guid(riid), object);
 456
 457     *object = NULL;
 458
 459     if(IsEqualGUID(riid, &IID_IUnknown) ||
 460        IsEqualGUID(riid, &IID_IDirect3DRMFrame) ||
 461        IsEqualGUID(riid, &IID_IDirect3DRMFrame2))
 462     {
 463         *object = &This->IDirect3DRMFrame2_iface;
 464     }
 465     else if(IsEqualGUID(riid, &IID_IDirect3DRMFrame3))
 466     {
 467         *object = &This->IDirect3DRMFrame3_iface;
 468     }
 469     else
 470     {
 471         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 472         return E_NOINTERFACE;
 473     }
 474
 475     IDirect3DRMFrame2_AddRef(iface);
 476     return S_OK;
 477 }
 478
 479 static ULONG WINAPI IDirect3DRMFrame2Impl_AddRef(IDirect3DRMFrame2* iface)
 480 {
 481     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 482     ULONG ref = InterlockedIncrement(&This->ref);
 483
 484     TRACE("(%p)->(): new ref = %d\n", This, ref);
 485
 486     return ref;
 487 }
 488
 489 static ULONG WINAPI IDirect3DRMFrame2Impl_Release(IDirect3DRMFrame2* iface)
 490 {
 491     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 492     ULONG ref = InterlockedDecrement(&This->ref);
 493     ULONG i;
 494
 495     TRACE("(%p)->(): new ref = %d\n", This, ref);
 496
 497     if (!ref)
 498     {
 499         for (i = 0; i < This->nb_children; i++)
 500             IDirect3DRMFrame3_Release(This->children[i]);
 501         HeapFree(GetProcessHeap(), 0, This->children);
 502         for (i = 0; i < This->nb_visuals; i++)
 503             IDirect3DRMVisual_Release(This->visuals[i]);
 504         HeapFree(GetProcessHeap(), 0, This->visuals);
 505         for (i = 0; i < This->nb_lights; i++)
 506             IDirect3DRMLight_Release(This->lights[i]);
 507         HeapFree(GetProcessHeap(), 0, This->lights);
 508         HeapFree(GetProcessHeap(), 0, This);
 509     }
 510
 511     return ref;
 512 }
 513
 514 /*** IDirect3DRMObject methods ***/
 515 static HRESULT WINAPI IDirect3DRMFrame2Impl_Clone(IDirect3DRMFrame2* iface,
 516                                                   LPUNKNOWN unkwn, REFIID riid,
 517                                                   LPVOID* object)
 518 {
 519     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 520
 521     FIXME("(%p/%p)->(%p, %s, %p): stub\n", iface, This, unkwn, debugstr_guid(riid), object);
 522
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddDestroyCallback(IDirect3DRMFrame2* iface,
 527                                                                D3DRMOBJECTCALLBACK cb,
 528                                                                LPVOID argument)
 529 {
 530     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 531
 532     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
 533
 534     return E_NOTIMPL;
 535 }
 536
 537 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteDestroyCallback(IDirect3DRMFrame2* iface,
 538                                                                   D3DRMOBJECTCALLBACK cb,
 539                                                                   LPVOID argument)
 540 {
 541     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 542
 543     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
 544
 545     return E_NOTIMPL;
 546 }
 547
 548 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetAppData(IDirect3DRMFrame2* iface,
 549                                                        DWORD data)
 550 {
 551     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 552
 553     FIXME("(%p/%p)->(%u): stub\n", iface, This, data);
 554
 555     return E_NOTIMPL;
 556 }
 557
 558 static DWORD WINAPI IDirect3DRMFrame2Impl_GetAppData(IDirect3DRMFrame2* iface)
 559 {
 560     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 561
 562     FIXME("(%p/%p)->(): stub\n", iface, This);
 563
 564     return 0;
 565 }
 566
 567 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetName(IDirect3DRMFrame2* iface, LPCSTR name)
 568 {
 569     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 570
 571     FIXME("(%p/%p)->(%s): stub\n", iface, This, name);
 572
 573     return E_NOTIMPL;
 574 }
 575
 576 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetName(IDirect3DRMFrame2* iface,
 577                                                     LPDWORD size, LPSTR name)
 578 {
 579     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 580
 581     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
 582
 583     return E_NOTIMPL;
 584 }
 585
 586 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetClassName(IDirect3DRMFrame2* iface,
 587                                                          LPDWORD size, LPSTR name)
 588 {
 589     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 590
 591     TRACE("(%p/%p)->(%p, %p)\n", iface, This, size, name);
 592
 593     return IDirect3DRMFrame3_GetClassName(&This->IDirect3DRMFrame3_iface, size, name);
 594 }
 595
 596 /*** IDirect3DRMFrame methods ***/
 597 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddChild(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *child)
 598 {
 599     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 600     IDirect3DRMFrame3 *frame;
 601     HRESULT hr;
 602
 603     TRACE("(%p/%p)->(%p)\n", iface, This, child);
 604
 605     if (!child)
 606         return D3DRMERR_BADOBJECT;
 607     hr = IDirect3DRMFrame_QueryInterface(child, &IID_IDirect3DRMFrame3, (void**)&frame);
 608     if (hr != S_OK)
 609         return D3DRMERR_BADOBJECT;
 610     IDirect3DRMFrame_Release(child);
 611
 612     return IDirect3DRMFrame3_AddChild(&This->IDirect3DRMFrame3_iface, frame);
 613 }
 614
 615 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddLight(IDirect3DRMFrame2 *iface, IDirect3DRMLight *light)
 616 {
 617     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 618
 619     TRACE("(%p/%p)->(%p)\n", iface, This, light);
 620
 621     return IDirect3DRMFrame3_AddLight(&This->IDirect3DRMFrame3_iface, light);
 622 }
 623
 624 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddMoveCallback(IDirect3DRMFrame2* iface,
 625                                                             D3DRMFRAMEMOVECALLBACK cb, VOID *arg)
 626 {
 627     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 628
 629     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
 630
 631     return E_NOTIMPL;
 632 }
 633
 634 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddTransform(IDirect3DRMFrame2* iface,
 635                                                          D3DRMCOMBINETYPE type,
 636                                                          D3DRMMATRIX4D matrix)
 637 {
 638     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 639
 640     TRACE("(%p/%p)->(%u,%p)\n", iface, This, type, matrix);
 641
 642     return IDirect3DRMFrame3_AddTransform(&This->IDirect3DRMFrame3_iface, type, matrix);
 643 }
 644
 645 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddTranslation(IDirect3DRMFrame2* iface,
 646                                                            D3DRMCOMBINETYPE type,
 647                                                            D3DVALUE x, D3DVALUE y, D3DVALUE z)
 648 {
 649     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 650
 651     FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, x, y, z);
 652
 653     return E_NOTIMPL;
 654 }
 655
 656 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddScale(IDirect3DRMFrame2* iface,
 657                                                      D3DRMCOMBINETYPE type,
 658                                                      D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
 659 {
 660     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 661
 662     FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, sx, sy, sz);
 663
 664     return E_NOTIMPL;
 665 }
 666
 667 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddRotation(IDirect3DRMFrame2* iface,
 668                                                         D3DRMCOMBINETYPE type,
 669                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
 670                                                         D3DVALUE theta)
 671 {
 672     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 673
 674     FIXME("(%p/%p)->(%u,%f,%f,%f,%f): stub\n", iface, This, type, x, y, z, theta);
 675
 676     return E_NOTIMPL;
 677 }
 678
 679 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddVisual(IDirect3DRMFrame2 *iface, IDirect3DRMVisual *visual)
 680 {
 681     IDirect3DRMFrameImpl *frame = impl_from_IDirect3DRMFrame2(iface);
 682
 683     TRACE("iface %p, visual %p.\n", iface, visual);
 684
 685     return IDirect3DRMFrame3_AddVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
 686 }
 687
 688 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetChildren(IDirect3DRMFrame2* iface,
 689                                                         LPDIRECT3DRMFRAMEARRAY *children)
 690 {
 691     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 692
 693     TRACE("(%p/%p)->(%p)\n", iface, This, children);
 694
 695     return IDirect3DRMFrame3_GetChildren(&This->IDirect3DRMFrame3_iface, children);
 696 }
 697
 698 static D3DCOLOR WINAPI IDirect3DRMFrame2Impl_GetColor(IDirect3DRMFrame2* iface)
 699 {
 700     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 701
 702     FIXME("(%p/%p)->(): stub\n", iface, This);
 703
 704     return 0;
 705 }
 706
 707 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetLights(IDirect3DRMFrame2* iface,
 708                                                       LPDIRECT3DRMLIGHTARRAY *lights)
 709 {
 710     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 711
 712     TRACE("(%p/%p)->(%p)\n", iface, This, lights);
 713
 714     return IDirect3DRMFrame3_GetLights(&This->IDirect3DRMFrame3_iface, lights);
 715 }
 716
 717 static D3DRMMATERIALMODE WINAPI IDirect3DRMFrame2Impl_GetMaterialMode(IDirect3DRMFrame2* iface)
 718 {
 719     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 720
 721     FIXME("(%p/%p)->(): stub\n", iface, This);
 722
 723     return D3DRMMATERIAL_FROMPARENT;
 724 }
 725
 726 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetParent(IDirect3DRMFrame2 *iface, IDirect3DRMFrame **frame)
 727 {
 728     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 729
 730     TRACE("(%p/%p)->(%p)\n", iface, This, frame);
 731
 732     if (!frame)
 733         return D3DRMERR_BADVALUE;
 734
 735     if (This->parent)
 736     {
 737         *frame = (IDirect3DRMFrame *)&This->parent->IDirect3DRMFrame2_iface;
 738         IDirect3DRMFrame_AddRef(*frame);
 739     }
 740     else
 741     {
 742         *frame = NULL;
 743     }
 744
 745     return D3DRM_OK;
 746 }
 747
 748 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetPosition(IDirect3DRMFrame2 *iface,
 749         IDirect3DRMFrame *reference, D3DVECTOR *return_position)
 750 {
 751     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 752
 753     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, reference, return_position);
 754
 755     return E_NOTIMPL;
 756 }
 757
 758 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetRotation(IDirect3DRMFrame2 *iface,
 759         IDirect3DRMFrame *reference, D3DVECTOR *axis, D3DVALUE *return_theta)
 760 {
 761     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 762
 763     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, axis, return_theta);
 764
 765     return E_NOTIMPL;
 766 }
 767
 768 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetScene(IDirect3DRMFrame2 *iface, IDirect3DRMFrame **scene)
 769 {
 770     FIXME("iface %p, frame %p stub!\n", iface, scene);
 771
 772     return E_NOTIMPL;
 773 }
 774
 775 static D3DRMSORTMODE WINAPI IDirect3DRMFrame2Impl_GetSortMode(IDirect3DRMFrame2* iface)
 776 {
 777     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 778
 779     FIXME("(%p/%p)->(): stub\n", iface, This);
 780
 781     return D3DRMSORT_FROMPARENT;
 782 }
 783
 784 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetTexture(IDirect3DRMFrame2* iface,
 785                                                        LPDIRECT3DRMTEXTURE * tex)
 786 {
 787     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 788
 789     FIXME("(%p/%p)->(%p): stub\n", iface, This, tex);
 790
 791     return E_NOTIMPL;
 792 }
 793
 794 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetTransform(IDirect3DRMFrame2* iface,
 795                                                          D3DRMMATRIX4D return_matrix)
 796 {
 797     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 798
 799     TRACE("(%p/%p)->(%p)\n", iface, This, return_matrix);
 800
 801     memcpy(return_matrix, This->transform, sizeof(D3DRMMATRIX4D));
 802
 803     return D3DRM_OK;
 804 }
 805
 806 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetVelocity(IDirect3DRMFrame2 *iface,
 807         IDirect3DRMFrame *reference, D3DVECTOR *return_velocity, BOOL with_rotation)
 808 {
 809     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 810
 811     FIXME("(%p/%p)->(%p,%p,%d): stub\n", iface, This, reference, return_velocity, with_rotation);
 812
 813     return E_NOTIMPL;
 814 }
 815
 816 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetOrientation(IDirect3DRMFrame2 *iface,
 817         IDirect3DRMFrame *reference, D3DVECTOR *dir, D3DVECTOR *up)
 818 {
 819     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 820
 821     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, dir, up);
 822
 823     return E_NOTIMPL;
 824 }
 825
 826 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetVisuals(IDirect3DRMFrame2* iface,
 827                                                        LPDIRECT3DRMVISUALARRAY *visuals)
 828 {
 829     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 830     IDirect3DRMVisualArrayImpl* obj;
 831     HRESULT hr;
 832
 833     TRACE("(%p/%p)->(%p)\n", iface, This, visuals);
 834
 835     if (!visuals)
 836         return D3DRMERR_BADVALUE;
 837
 838     hr = Direct3DRMVisualArray_create(visuals);
 839
 840     if (hr != D3DRM_OK)
 841         return hr;
 842
 843     obj = (IDirect3DRMVisualArrayImpl*)*visuals;
 844
 845     obj->size = This->nb_visuals;
 846     if (This->nb_visuals)
 847     {
 848         ULONG i;
 849         if (!(obj->visuals = HeapAlloc(GetProcessHeap(), 0, This->nb_visuals * sizeof(*obj->visuals))))
 850             return E_OUTOFMEMORY;
 851         for (i = 0; i < This->nb_visuals; i++)
 852         {
 853             obj->visuals[i] = This->visuals[i];
 854             IDirect3DRMVisual_AddRef(This->visuals[i]);
 855         }
 856     }
 857
 858     return D3DRM_OK;
 859 }
 860
 861 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetTextureTopology(IDirect3DRMFrame2* iface,
 862                                                                BOOL *wrap_u, BOOL *wrap_v)
 863 {
 864     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 865
 866     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, wrap_u, wrap_v);
 867
 868     return E_NOTIMPL;
 869 }
 870
 871 static HRESULT WINAPI IDirect3DRMFrame2Impl_InverseTransform(IDirect3DRMFrame2* iface,
 872                                                              D3DVECTOR *d, D3DVECTOR *s)
 873 {
 874     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 875
 876     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
 877
 878     return E_NOTIMPL;
 879 }
 880
 881 static HRESULT WINAPI IDirect3DRMFrame2Impl_Load(IDirect3DRMFrame2* iface, LPVOID filename,
 882                                                  LPVOID name, D3DRMLOADOPTIONS loadflags,
 883                                                  D3DRMLOADTEXTURECALLBACK cb, LPVOID lpArg)
 884 {
 885     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 886
 887     FIXME("(%p/%p)->(%p,%p,%u,%p,%p): stub\n", iface, This, filename, name, loadflags, cb, lpArg);
 888
 889     return E_NOTIMPL;
 890 }
 891
 892 static HRESULT WINAPI IDirect3DRMFrame2Impl_LookAt(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *target,
 893         IDirect3DRMFrame *reference, D3DRMFRAMECONSTRAINT constraint)
 894 {
 895     FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
 896
 897     return E_NOTIMPL;
 898 }
 899
 900 static HRESULT WINAPI IDirect3DRMFrame2Impl_Move(IDirect3DRMFrame2* iface, D3DVALUE delta)
 901 {
 902     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 903
 904     FIXME("(%p/%p)->(%f): stub\n", iface, This, delta);
 905
 906     return E_NOTIMPL;
 907 }
 908
 909 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteChild(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *frame)
 910 {
 911     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 912     IDirect3DRMFrame3 *child;
 913     HRESULT hr;
 914
 915     TRACE("(%p/%p)->(%p)\n", iface, This, frame);
 916
 917     if (!frame)
 918         return D3DRMERR_BADOBJECT;
 919     hr = IDirect3DRMFrame_QueryInterface(frame, &IID_IDirect3DRMFrame3, (void**)&child);
 920     if (hr != S_OK)
 921         return D3DRMERR_BADOBJECT;
 922     IDirect3DRMFrame_Release(frame);
 923
 924     return IDirect3DRMFrame3_DeleteChild(&This->IDirect3DRMFrame3_iface, child);
 925 }
 926
 927 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteLight(IDirect3DRMFrame2 *iface, IDirect3DRMLight *light)
 928 {
 929     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 930
 931     TRACE("(%p/%p)->(%p)\n", iface, This, light);
 932
 933     return IDirect3DRMFrame3_DeleteLight(&This->IDirect3DRMFrame3_iface, light);
 934 }
 935
 936 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteMoveCallback(IDirect3DRMFrame2* iface,
 937                                                                D3DRMFRAMEMOVECALLBACK cb, VOID *arg)
 938 {
 939     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 940
 941     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
 942
 943     return E_NOTIMPL;
 944 }
 945
 946 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteVisual(IDirect3DRMFrame2 *iface, IDirect3DRMVisual *visual)
 947 {
 948     IDirect3DRMFrameImpl *frame = impl_from_IDirect3DRMFrame2(iface);
 949
 950     TRACE("iface %p, visual %p.\n", iface, visual);
 951
 952     return IDirect3DRMFrame3_DeleteVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
 953 }
 954
 955 static D3DCOLOR WINAPI IDirect3DRMFrame2Impl_GetSceneBackground(IDirect3DRMFrame2* iface)
 956 {
 957     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 958
 959     TRACE("(%p/%p)->()\n", iface, This);
 960
 961     return IDirect3DRMFrame3_GetSceneBackground(&This->IDirect3DRMFrame3_iface);
 962 }
 963
 964 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetSceneBackgroundDepth(IDirect3DRMFrame2 *iface,
 965         IDirectDrawSurface **surface)
 966 {
 967     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 968
 969     FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
 970
 971     return E_NOTIMPL;
 972 }
 973
 974 static D3DCOLOR WINAPI IDirect3DRMFrame2Impl_GetSceneFogColor(IDirect3DRMFrame2* iface)
 975 {
 976     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 977
 978     FIXME("(%p/%p)->(): stub\n", iface, This);
 979
 980     return 0;
 981 }
 982
 983 static BOOL WINAPI IDirect3DRMFrame2Impl_GetSceneFogEnable(IDirect3DRMFrame2* iface)
 984 {
 985     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 986
 987     FIXME("(%p/%p)->(): stub\n", iface, This);
 988
 989     return FALSE;
 990 }
 991
 992 static D3DRMFOGMODE WINAPI IDirect3DRMFrame2Impl_GetSceneFogMode(IDirect3DRMFrame2* iface)
 993 {
 994     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 995
 996     FIXME("(%p/%p)->(): stub\n", iface, This);
 997
 998     return D3DRMFOG_LINEAR;
 999 }
1000
1001 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetSceneFogParams(IDirect3DRMFrame2* iface,
1002                                                               D3DVALUE *return_start,
1003                                                               D3DVALUE *return_end,
1004                                                               D3DVALUE *return_density)
1005 {
1006     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1007
1008     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, return_start, return_end, return_density);
1009
1010     return E_NOTIMPL;
1011 }
1012
1013 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackground(IDirect3DRMFrame2* iface,
1014                                                                D3DCOLOR color)
1015 {
1016     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1017
1018     TRACE("(%p/%p)->(%u)\n", iface, This, color);
1019
1020     return IDirect3DRMFrame3_SetSceneBackground(&This->IDirect3DRMFrame3_iface, color);
1021 }
1022
1023 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackgroundRGB(IDirect3DRMFrame2* iface,
1024                                                                   D3DVALUE red, D3DVALUE green,
1025                                                                   D3DVALUE blue)
1026 {
1027     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1028
1029     TRACE("(%p/%p)->(%f,%f,%f)\n", iface, This, red, green, blue);
1030
1031     return IDirect3DRMFrame3_SetSceneBackgroundRGB(&This->IDirect3DRMFrame3_iface, red, green, blue);
1032 }
1033
1034 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackgroundDepth(IDirect3DRMFrame2 *iface,
1035         IDirectDrawSurface *surface)
1036 {
1037     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1038
1039     FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
1040
1041     return E_NOTIMPL;
1042 }
1043
1044 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackgroundImage(IDirect3DRMFrame2* iface,
1045                                                                     LPDIRECT3DRMTEXTURE texture)
1046 {
1047     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1048
1049     FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
1050
1051     return E_NOTIMPL;
1052 }
1053
1054 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogEnable(IDirect3DRMFrame2* iface, BOOL enable)
1055 {
1056     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1057
1058     FIXME("(%p/%p)->(%d): stub\n", iface, This, enable);
1059
1060     return E_NOTIMPL;
1061 }
1062
1063 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogColor(IDirect3DRMFrame2* iface,
1064                                                              D3DCOLOR color)
1065 {
1066     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1067
1068     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
1069
1070     return E_NOTIMPL;
1071 }
1072
1073 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogMode(IDirect3DRMFrame2* iface,
1074                                                             D3DRMFOGMODE mode)
1075 {
1076     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1077
1078     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1079
1080     return E_NOTIMPL;
1081 }
1082
1083 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogParams(IDirect3DRMFrame2* iface,
1084                                                               D3DVALUE start, D3DVALUE end,
1085                                                               D3DVALUE density)
1086 {
1087     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1088
1089     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, start, end, density);
1090
1091     return E_NOTIMPL;
1092 }
1093
1094 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetColor(IDirect3DRMFrame2* iface, D3DCOLOR color)
1095 {
1096     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1097
1098     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
1099
1100     return E_NOTIMPL;
1101 }
1102
1103 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetColorRGB(IDirect3DRMFrame2* iface, D3DVALUE red,
1104                                                         D3DVALUE green, D3DVALUE blue)
1105 {
1106     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1107
1108     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
1109
1110     return E_NOTIMPL;
1111 }
1112
1113 static D3DRMZBUFFERMODE WINAPI IDirect3DRMFrame2Impl_GetZbufferMode(IDirect3DRMFrame2* iface)
1114 {
1115     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1116
1117     FIXME("(%p/%p)->(): stub\n", iface, This);
1118
1119     return D3DRMZBUFFER_FROMPARENT;
1120 }
1121
1122 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetMaterialMode(IDirect3DRMFrame2* iface,
1123                                                             D3DRMMATERIALMODE mode)
1124 {
1125     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1126
1127     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1128
1129     return E_NOTIMPL;
1130 }
1131
1132 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetOrientation(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *reference,
1133         D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
1134 {
1135     FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
1136             iface, reference, dx, dy, dz, ux, uy, uz);
1137
1138     return E_NOTIMPL;
1139 }
1140
1141 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetPosition(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *reference,
1142         D3DVALUE x, D3DVALUE y, D3DVALUE z)
1143 {
1144     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
1145
1146     return E_NOTIMPL;
1147 }
1148
1149 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetRotation(IDirect3DRMFrame2 *iface,
1150         IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1151 {
1152     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
1153             iface, reference, x, y, z, theta);
1154
1155     return E_NOTIMPL;
1156 }
1157
1158 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSortMode(IDirect3DRMFrame2* iface,
1159                                                         D3DRMSORTMODE mode)
1160 {
1161     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1162
1163     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1164
1165     return E_NOTIMPL;
1166 }
1167
1168 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetTexture(IDirect3DRMFrame2* iface,
1169                                                        LPDIRECT3DRMTEXTURE texture)
1170 {
1171     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1172
1173     FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
1174
1175     return E_NOTIMPL;
1176 }
1177
1178 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetTextureTopology(IDirect3DRMFrame2* iface,
1179                                                                BOOL wrap_u, BOOL wrap_v)
1180 {
1181     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1182
1183     FIXME("(%p/%p)->(%d,%d): stub\n", iface, This, wrap_u, wrap_v);
1184
1185     return E_NOTIMPL;
1186 }
1187
1188 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetVelocity(IDirect3DRMFrame2 *iface,
1189         IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
1190 {
1191     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x stub!\n",
1192             iface, reference, x, y, z, with_rotation);
1193
1194     return E_NOTIMPL;
1195 }
1196
1197 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetZbufferMode(IDirect3DRMFrame2* iface,
1198                                                            D3DRMZBUFFERMODE mode)
1199 {
1200     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1201
1202     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1203
1204     return E_NOTIMPL;
1205 }
1206
1207 static HRESULT WINAPI IDirect3DRMFrame2Impl_Transform(IDirect3DRMFrame2* iface, D3DVECTOR *d,
1208                                                       D3DVECTOR *s)
1209 {
1210     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1211
1212     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
1213
1214     return E_NOTIMPL;
1215 }
1216
1217 /*** IDirect3DRMFrame2 methods ***/
1218 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddMoveCallback2(IDirect3DRMFrame2* iface,
1219                                                              D3DRMFRAMEMOVECALLBACK cb, VOID *arg,
1220                                                              DWORD flags)
1221 {
1222     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1223
1224     FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, cb, arg, flags);
1225
1226     return E_NOTIMPL;
1227 }
1228
1229 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetBox(IDirect3DRMFrame2 *iface, D3DRMBOX *box)
1230 {
1231     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1232
1233     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
1234
1235     return E_NOTIMPL;
1236 }
1237
1238 static BOOL WINAPI IDirect3DRMFrame2Impl_GetBoxEnable(IDirect3DRMFrame2* iface)
1239 {
1240     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1241
1242     FIXME("(%p/%p)->(): stub\n", iface, This);
1243
1244     return E_NOTIMPL;
1245 }
1246
1247 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetAxes(IDirect3DRMFrame2 *iface,
1248         D3DVECTOR *dir, D3DVECTOR *up)
1249 {
1250     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1251
1252     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, dir, up);
1253
1254     return E_NOTIMPL;
1255 }
1256
1257 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetMaterial(IDirect3DRMFrame2* iface,
1258                                                         LPDIRECT3DRMMATERIAL *material)
1259 {
1260     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1261
1262     FIXME("(%p/%p)->(%p): stub\n", iface, This, material);
1263
1264     return E_NOTIMPL;
1265 }
1266
1267 static BOOL WINAPI IDirect3DRMFrame2Impl_GetInheritAxes(IDirect3DRMFrame2* iface)
1268 {
1269     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1270
1271     FIXME("(%p/%p)->(): stub\n", iface, This);
1272
1273     return E_NOTIMPL;
1274 }
1275
1276 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetHierarchyBox(IDirect3DRMFrame2 *iface, D3DRMBOX *box)
1277 {
1278     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1279
1280     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
1281
1282     return E_NOTIMPL;
1283 }
1284
1285 static const struct IDirect3DRMFrame2Vtbl Direct3DRMFrame2_Vtbl =
1286 {
1287     /*** IUnknown methods ***/
1288     IDirect3DRMFrame2Impl_QueryInterface,
1289     IDirect3DRMFrame2Impl_AddRef,
1290     IDirect3DRMFrame2Impl_Release,
1291     /*** IDirect3DRMObject methods ***/
1292     IDirect3DRMFrame2Impl_Clone,
1293     IDirect3DRMFrame2Impl_AddDestroyCallback,
1294     IDirect3DRMFrame2Impl_DeleteDestroyCallback,
1295     IDirect3DRMFrame2Impl_SetAppData,
1296     IDirect3DRMFrame2Impl_GetAppData,
1297     IDirect3DRMFrame2Impl_SetName,
1298     IDirect3DRMFrame2Impl_GetName,
1299     IDirect3DRMFrame2Impl_GetClassName,
1300     /*** IDirect3DRMFrame methods ***/
1301     IDirect3DRMFrame2Impl_AddChild,
1302     IDirect3DRMFrame2Impl_AddLight,
1303     IDirect3DRMFrame2Impl_AddMoveCallback,
1304     IDirect3DRMFrame2Impl_AddTransform,
1305     IDirect3DRMFrame2Impl_AddTranslation,
1306     IDirect3DRMFrame2Impl_AddScale,
1307     IDirect3DRMFrame2Impl_AddRotation,
1308     IDirect3DRMFrame2Impl_AddVisual,
1309     IDirect3DRMFrame2Impl_GetChildren,
1310     IDirect3DRMFrame2Impl_GetColor,
1311     IDirect3DRMFrame2Impl_GetLights,
1312     IDirect3DRMFrame2Impl_GetMaterialMode,
1313     IDirect3DRMFrame2Impl_GetParent,
1314     IDirect3DRMFrame2Impl_GetPosition,
1315     IDirect3DRMFrame2Impl_GetRotation,
1316     IDirect3DRMFrame2Impl_GetScene,
1317     IDirect3DRMFrame2Impl_GetSortMode,
1318     IDirect3DRMFrame2Impl_GetTexture,
1319     IDirect3DRMFrame2Impl_GetTransform,
1320     IDirect3DRMFrame2Impl_GetVelocity,
1321     IDirect3DRMFrame2Impl_GetOrientation,
1322     IDirect3DRMFrame2Impl_GetVisuals,
1323     IDirect3DRMFrame2Impl_GetTextureTopology,
1324     IDirect3DRMFrame2Impl_InverseTransform,
1325     IDirect3DRMFrame2Impl_Load,
1326     IDirect3DRMFrame2Impl_LookAt,
1327     IDirect3DRMFrame2Impl_Move,
1328     IDirect3DRMFrame2Impl_DeleteChild,
1329     IDirect3DRMFrame2Impl_DeleteLight,
1330     IDirect3DRMFrame2Impl_DeleteMoveCallback,
1331     IDirect3DRMFrame2Impl_DeleteVisual,
1332     IDirect3DRMFrame2Impl_GetSceneBackground,
1333     IDirect3DRMFrame2Impl_GetSceneBackgroundDepth,
1334     IDirect3DRMFrame2Impl_GetSceneFogColor,
1335     IDirect3DRMFrame2Impl_GetSceneFogEnable,
1336     IDirect3DRMFrame2Impl_GetSceneFogMode,
1337     IDirect3DRMFrame2Impl_GetSceneFogParams,
1338     IDirect3DRMFrame2Impl_SetSceneBackground,
1339     IDirect3DRMFrame2Impl_SetSceneBackgroundRGB,
1340     IDirect3DRMFrame2Impl_SetSceneBackgroundDepth,
1341     IDirect3DRMFrame2Impl_SetSceneBackgroundImage,
1342     IDirect3DRMFrame2Impl_SetSceneFogEnable,
1343     IDirect3DRMFrame2Impl_SetSceneFogColor,
1344     IDirect3DRMFrame2Impl_SetSceneFogMode,
1345     IDirect3DRMFrame2Impl_SetSceneFogParams,
1346     IDirect3DRMFrame2Impl_SetColor,
1347     IDirect3DRMFrame2Impl_SetColorRGB,
1348     IDirect3DRMFrame2Impl_GetZbufferMode,
1349     IDirect3DRMFrame2Impl_SetMaterialMode,
1350     IDirect3DRMFrame2Impl_SetOrientation,
1351     IDirect3DRMFrame2Impl_SetPosition,
1352     IDirect3DRMFrame2Impl_SetRotation,
1353     IDirect3DRMFrame2Impl_SetSortMode,
1354     IDirect3DRMFrame2Impl_SetTexture,
1355     IDirect3DRMFrame2Impl_SetTextureTopology,
1356     IDirect3DRMFrame2Impl_SetVelocity,
1357     IDirect3DRMFrame2Impl_SetZbufferMode,
1358     IDirect3DRMFrame2Impl_Transform,
1359     /*** IDirect3DRMFrame2 methods ***/
1360     IDirect3DRMFrame2Impl_AddMoveCallback2,
1361     IDirect3DRMFrame2Impl_GetBox,
1362     IDirect3DRMFrame2Impl_GetBoxEnable,
1363     IDirect3DRMFrame2Impl_GetAxes,
1364     IDirect3DRMFrame2Impl_GetMaterial,
1365     IDirect3DRMFrame2Impl_GetInheritAxes,
1366     IDirect3DRMFrame2Impl_GetHierarchyBox
1367 };
1368
1369 /*** IUnknown methods ***/
1370 static HRESULT WINAPI IDirect3DRMFrame3Impl_QueryInterface(IDirect3DRMFrame3* iface,
1371                                                            REFIID riid, void** object)
1372 {
1373     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1374     return IDirect3DRMFrame_QueryInterface(&This->IDirect3DRMFrame2_iface, riid, object);
1375 }
1376
1377 static ULONG WINAPI IDirect3DRMFrame3Impl_AddRef(IDirect3DRMFrame3* iface)
1378 {
1379     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1380     return IDirect3DRMFrame2_AddRef(&This->IDirect3DRMFrame2_iface);
1381 }
1382
1383 static ULONG WINAPI IDirect3DRMFrame3Impl_Release(IDirect3DRMFrame3* iface)
1384 {
1385     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1386     return IDirect3DRMFrame2_Release(&This->IDirect3DRMFrame2_iface);
1387 }
1388
1389 /*** IDirect3DRMObject methods ***/
1390 static HRESULT WINAPI IDirect3DRMFrame3Impl_Clone(IDirect3DRMFrame3* iface,
1391                                                   LPUNKNOWN unkwn, REFIID riid,
1392                                                   LPVOID* object)
1393 {
1394     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1395
1396     FIXME("(%p/%p)->(%p, %s, %p): stub\n", iface, This, unkwn, debugstr_guid(riid), object);
1397
1398     return E_NOTIMPL;
1399 }
1400
1401 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddDestroyCallback(IDirect3DRMFrame3* iface,
1402                                                                D3DRMOBJECTCALLBACK cb,
1403                                                                LPVOID argument)
1404 {
1405     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1406
1407     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
1408
1409     return E_NOTIMPL;
1410 }
1411
1412 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteDestroyCallback(IDirect3DRMFrame3* iface,
1413                                                                   D3DRMOBJECTCALLBACK cb,
1414                                                                   LPVOID argument)
1415 {
1416     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1417
1418     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
1419
1420     return E_NOTIMPL;
1421 }
1422
1423 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetAppData(IDirect3DRMFrame3* iface,
1424                                                        DWORD data)
1425 {
1426     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1427
1428     FIXME("(%p/%p)->(%u): stub\n", iface, This, data);
1429
1430     return E_NOTIMPL;
1431 }
1432
1433 static DWORD WINAPI IDirect3DRMFrame3Impl_GetAppData(IDirect3DRMFrame3* iface)
1434 {
1435     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1436
1437     FIXME("(%p/%p)->(): stub\n", iface, This);
1438
1439     return 0;
1440 }
1441
1442 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetName(IDirect3DRMFrame3* iface, LPCSTR name)
1443 {
1444     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1445
1446     FIXME("(%p/%p)->(%s): stub\n", iface, This, name);
1447
1448     return E_NOTIMPL;
1449 }
1450
1451 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetName(IDirect3DRMFrame3* iface,
1452                                                     LPDWORD size, LPSTR name)
1453 {
1454     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1455
1456     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
1457
1458     return E_NOTIMPL;
1459 }
1460
1461 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetClassName(IDirect3DRMFrame3* iface,
1462                                                          LPDWORD size, LPSTR name)
1463 {
1464     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1465
1466     TRACE("(%p/%p)->(%p, %p)\n", iface, This, size, name);
1467
1468     if (!size || *size < strlen("Frame") || !name)
1469         return E_INVALIDARG;
1470
1471     strcpy(name, "Frame");
1472     *size = sizeof("Frame");
1473
1474     return D3DRM_OK;
1475 }
1476
1477 /*** IDirect3DRMFrame methods ***/
1478 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddChild(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *child)
1479 {
1480     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1481     IDirect3DRMFrameImpl *child_obj = unsafe_impl_from_IDirect3DRMFrame3(child);
1482
1483     TRACE("(%p/%p)->(%p)\n", iface, This, child);
1484
1485     if (!child_obj)
1486         return D3DRMERR_BADOBJECT;
1487
1488     if (child_obj->parent)
1489     {
1490         IDirect3DRMFrame3* parent = &child_obj->parent->IDirect3DRMFrame3_iface;
1491
1492         if (parent == iface)
1493         {
1494             /* Passed frame is already a child so return success */
1495             return D3DRM_OK;
1496         }
1497         else
1498         {
1499             /* Remove parent and continue */
1500             IDirect3DRMFrame3_DeleteChild(parent, child);
1501         }
1502     }
1503
1504     if ((This->nb_children + 1) > This->children_capacity)
1505     {
1506         ULONG new_capacity;
1507         IDirect3DRMFrame3** children;
1508
1509         if (!This->children_capacity)
1510         {
1511             new_capacity = 16;
1512             children = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMFrame3*));
1513         }
1514         else
1515         {
1516             new_capacity = This->children_capacity * 2;
1517             children = HeapReAlloc(GetProcessHeap(), 0, This->children, new_capacity * sizeof(IDirect3DRMFrame3*));
1518         }
1519
1520         if (!children)
1521             return E_OUTOFMEMORY;
1522
1523         This->children_capacity = new_capacity;
1524         This->children = children;
1525     }
1526
1527     This->children[This->nb_children++] = child;
1528     IDirect3DRMFrame3_AddRef(child);
1529     child_obj->parent = This;
1530
1531     return D3DRM_OK;
1532 }
1533
1534 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddLight(IDirect3DRMFrame3 *iface, IDirect3DRMLight *light)
1535 {
1536     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1537     ULONG i;
1538     IDirect3DRMLight** lights;
1539
1540     TRACE("(%p/%p)->(%p)\n", iface, This, light);
1541
1542     if (!light)
1543         return D3DRMERR_BADOBJECT;
1544
1545     /* Check if already existing and return gracefully without increasing ref count */
1546     for (i = 0; i < This->nb_lights; i++)
1547         if (This->lights[i] == light)
1548             return D3DRM_OK;
1549
1550     if ((This->nb_lights + 1) > This->lights_capacity)
1551     {
1552         ULONG new_capacity;
1553
1554         if (!This->lights_capacity)
1555         {
1556             new_capacity = 16;
1557             lights = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMLight*));
1558         }
1559         else
1560         {
1561             new_capacity = This->lights_capacity * 2;
1562             lights = HeapReAlloc(GetProcessHeap(), 0, This->lights, new_capacity * sizeof(IDirect3DRMLight*));
1563         }
1564
1565         if (!lights)
1566             return E_OUTOFMEMORY;
1567
1568         This->lights_capacity = new_capacity;
1569         This->lights = lights;
1570     }
1571
1572     This->lights[This->nb_lights++] = light;
1573     IDirect3DRMLight_AddRef(light);
1574
1575     return D3DRM_OK;
1576 }
1577
1578 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddMoveCallback(IDirect3DRMFrame3* iface,
1579                                                             D3DRMFRAME3MOVECALLBACK cb, VOID *arg,
1580                                                             DWORD flags)
1581 {
1582     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1583
1584     FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, cb, arg, flags);
1585
1586     return E_NOTIMPL;
1587 }
1588
1589 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddTransform(IDirect3DRMFrame3* iface,
1590                                                          D3DRMCOMBINETYPE type,
1591                                                          D3DRMMATRIX4D matrix)
1592 {
1593     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1594
1595     TRACE("(%p/%p)->(%u,%p)\n", iface, This, type, matrix);
1596
1597     switch (type)
1598     {
1599         case D3DRMCOMBINE_REPLACE:
1600             memcpy(This->transform, matrix, sizeof(D3DRMMATRIX4D));
1601             break;
1602
1603         case D3DRMCOMBINE_BEFORE:
1604             FIXME("D3DRMCOMBINE_BEFORE not supported yed\n");
1605             break;
1606
1607         case D3DRMCOMBINE_AFTER:
1608             FIXME("D3DRMCOMBINE_AFTER not supported yed\n");
1609             break;
1610
1611         default:
1612             WARN("Unknown Combine Type %u\n", type);
1613             return D3DRMERR_BADVALUE;
1614     }
1615
1616     return S_OK;
1617 }
1618
1619 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddTranslation(IDirect3DRMFrame3* iface,
1620                                                            D3DRMCOMBINETYPE type,
1621                                                            D3DVALUE x, D3DVALUE y, D3DVALUE z)
1622 {
1623     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1624
1625     FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, x, y, z);
1626
1627     return E_NOTIMPL;
1628 }
1629
1630 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddScale(IDirect3DRMFrame3* iface,
1631                                                      D3DRMCOMBINETYPE type,
1632                                                      D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1633 {
1634     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1635
1636     FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, sx, sy, sz);
1637
1638     return E_NOTIMPL;
1639 }
1640
1641 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddRotation(IDirect3DRMFrame3* iface,
1642                                                         D3DRMCOMBINETYPE type,
1643                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
1644                                                         D3DVALUE theta)
1645 {
1646     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1647
1648     FIXME("(%p/%p)->(%u,%f,%f,%f,%f): stub\n", iface, This, type, x, y, z, theta);
1649
1650     return E_NOTIMPL;
1651 }
1652
1653 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddVisual(IDirect3DRMFrame3* iface, LPUNKNOWN vis)
1654 {
1655     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1656     ULONG i;
1657     IDirect3DRMVisual** visuals;
1658
1659     TRACE("(%p/%p)->(%p)\n", iface, This, vis);
1660
1661     if (!vis)
1662         return D3DRMERR_BADOBJECT;
1663
1664     /* Check if already existing and return gracefully without increasing ref count */
1665     for (i = 0; i < This->nb_visuals; i++)
1666         if (This->visuals[i] == (IDirect3DRMVisual*)vis)
1667             return D3DRM_OK;
1668
1669     if ((This->nb_visuals + 1) > This->visuals_capacity)
1670     {
1671         ULONG new_capacity;
1672
1673         if (!This->visuals_capacity)
1674         {
1675             new_capacity = 16;
1676             visuals = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMVisual*));
1677         }
1678         else
1679         {
1680             new_capacity = This->visuals_capacity * 2;
1681             visuals = HeapReAlloc(GetProcessHeap(), 0, This->visuals, new_capacity * sizeof(IDirect3DRMVisual*));
1682         }
1683
1684         if (!visuals)
1685             return E_OUTOFMEMORY;
1686
1687         This->visuals_capacity = new_capacity;
1688         This->visuals = visuals;
1689     }
1690
1691     This->visuals[This->nb_visuals++] = (IDirect3DRMVisual*)vis;
1692     IDirect3DRMVisual_AddRef(vis);
1693
1694     return D3DRM_OK;
1695 }
1696
1697 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetChildren(IDirect3DRMFrame3* iface,
1698                                                         LPDIRECT3DRMFRAMEARRAY *children)
1699 {
1700     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1701     IDirect3DRMFrameArrayImpl* obj;
1702     HRESULT hr;
1703
1704     TRACE("(%p/%p)->(%p)\n", iface, This, children);
1705
1706     if (!children)
1707         return D3DRMERR_BADVALUE;
1708
1709     hr = Direct3DRMFrameArray_create(children);
1710
1711     if (hr != D3DRM_OK)
1712         return hr;
1713
1714     obj = (IDirect3DRMFrameArrayImpl*)*children;
1715
1716     obj->size = This->nb_children;
1717     if (This->nb_children)
1718     {
1719         ULONG i;
1720         if (!(obj->frames = HeapAlloc(GetProcessHeap(), 0, This->nb_children * sizeof(*obj->frames))))
1721             return E_OUTOFMEMORY;
1722         for (i = 0; i < This->nb_children; i++)
1723             IDirect3DRMFrame3_QueryInterface(This->children[i], &IID_IDirect3DRMFrame, (void**)&obj->frames[i]);
1724     }
1725
1726     return D3DRM_OK;
1727 }
1728
1729 static D3DCOLOR WINAPI IDirect3DRMFrame3Impl_GetColor(IDirect3DRMFrame3* iface)
1730 {
1731     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1732
1733     FIXME("(%p/%p)->(): stub\n", iface, This);
1734
1735     return 0;
1736 }
1737
1738 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetLights(IDirect3DRMFrame3* iface,
1739                                                       LPDIRECT3DRMLIGHTARRAY *lights)
1740 {
1741     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1742     IDirect3DRMLightArrayImpl* obj;
1743     HRESULT hr;
1744
1745     TRACE("(%p/%p)->(%p)\n", iface, This, lights);
1746
1747     if (!lights)
1748         return D3DRMERR_BADVALUE;
1749
1750     hr = Direct3DRMLightArray_create(lights);
1751
1752     if (hr != D3DRM_OK)
1753         return hr;
1754
1755     obj = (IDirect3DRMLightArrayImpl*)*lights;
1756
1757     obj->size = This->nb_lights;
1758     if (This->nb_lights)
1759     {
1760         ULONG i;
1761         if (!(obj->lights = HeapAlloc(GetProcessHeap(), 0, This->nb_lights * sizeof(*obj->lights))))
1762             return E_OUTOFMEMORY;
1763         for (i = 0; i < This->nb_lights; i++)
1764             IDirect3DRMLight_QueryInterface(This->lights[i], &IID_IDirect3DRMLight, (void**)&obj->lights[i]);
1765     }
1766
1767     return D3DRM_OK;
1768 }
1769
1770 static D3DRMMATERIALMODE WINAPI IDirect3DRMFrame3Impl_GetMaterialMode(IDirect3DRMFrame3* iface)
1771 {
1772     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1773
1774     FIXME("(%p/%p)->(): stub\n", iface, This);
1775
1776     return D3DRMMATERIAL_FROMPARENT;
1777 }
1778
1779 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetParent(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 **frame)
1780 {
1781     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1782
1783     TRACE("(%p/%p)->(%p)\n", iface, This, frame);
1784
1785     if (!frame)
1786         return D3DRMERR_BADVALUE;
1787
1788     if (This->parent)
1789     {
1790         *frame = &This->parent->IDirect3DRMFrame3_iface;
1791         IDirect3DRMFrame_AddRef(*frame);
1792     }
1793     else
1794     {
1795         *frame = NULL;
1796     }
1797
1798     return D3DRM_OK;
1799 }
1800
1801 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetPosition(IDirect3DRMFrame3 *iface,
1802         IDirect3DRMFrame3 *reference, D3DVECTOR *return_position)
1803 {
1804     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1805
1806     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, reference, return_position);
1807
1808     return E_NOTIMPL;
1809 }
1810
1811 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetRotation(IDirect3DRMFrame3 *iface,
1812         IDirect3DRMFrame3 *reference, D3DVECTOR *axis, D3DVALUE *return_theta)
1813 {
1814     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1815
1816     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, axis, return_theta);
1817
1818     return E_NOTIMPL;
1819 }
1820
1821 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetScene(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 **scene)
1822 {
1823     FIXME("iface %p, scene %p stub!\n", iface, scene);
1824
1825     return E_NOTIMPL;
1826 }
1827
1828 static D3DRMSORTMODE WINAPI IDirect3DRMFrame3Impl_GetSortMode(IDirect3DRMFrame3* iface)
1829 {
1830     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1831
1832     FIXME("(%p/%p)->(): stub\n", iface, This);
1833
1834     return D3DRMSORT_FROMPARENT;
1835 }
1836
1837 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetTexture(IDirect3DRMFrame3* iface,
1838                                                        LPDIRECT3DRMTEXTURE3 * tex)
1839 {
1840     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1841
1842     FIXME("(%p/%p)->(%p): stub\n", iface, This, tex);
1843
1844     return E_NOTIMPL;
1845 }
1846
1847 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetTransform(IDirect3DRMFrame3 *iface,
1848         IDirect3DRMFrame3 *reference, D3DRMMATRIX4D return_matrix)
1849 {
1850     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1851
1852     TRACE("(%p/%p)->(%p,%p)\n", iface, This, reference, return_matrix);
1853
1854     if (reference)
1855         FIXME("Specifying a frame as the root of the scene different from the current root frame is not supported yet\n");
1856
1857     memcpy(return_matrix, This->transform, sizeof(D3DRMMATRIX4D));
1858
1859     return D3DRM_OK;
1860 }
1861
1862 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetVelocity(IDirect3DRMFrame3 *iface,
1863         IDirect3DRMFrame3 *reference, D3DVECTOR *return_velocity, BOOL with_rotation)
1864 {
1865     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1866
1867     FIXME("(%p/%p)->(%p,%p,%d): stub\n", iface, This, reference, return_velocity, with_rotation);
1868
1869     return E_NOTIMPL;
1870 }
1871
1872 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetOrientation(IDirect3DRMFrame3 *iface,
1873         IDirect3DRMFrame3 *reference, D3DVECTOR *dir, D3DVECTOR *up)
1874 {
1875     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1876
1877     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, dir, up);
1878
1879     return E_NOTIMPL;
1880 }
1881
1882 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetVisuals(IDirect3DRMFrame3* iface, LPDWORD num,
1883                                                        LPUNKNOWN *visuals)
1884 {
1885     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1886
1887     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, num, visuals);
1888
1889     return E_NOTIMPL;
1890 }
1891
1892 static HRESULT WINAPI IDirect3DRMFrame3Impl_InverseTransform(IDirect3DRMFrame3* iface,
1893                                                              D3DVECTOR *d, D3DVECTOR *s)
1894 {
1895     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1896
1897     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
1898
1899     return E_NOTIMPL;
1900 }
1901
1902 static HRESULT WINAPI IDirect3DRMFrame3Impl_Load(IDirect3DRMFrame3* iface, LPVOID filename,
1903                                                  LPVOID name, D3DRMLOADOPTIONS loadflags,
1904                                                  D3DRMLOADTEXTURE3CALLBACK cb, LPVOID lpArg)
1905 {
1906     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1907
1908     FIXME("(%p/%p)->(%p,%p,%u,%p,%p): stub\n", iface, This, filename, name, loadflags, cb, lpArg);
1909
1910     return E_NOTIMPL;
1911 }
1912
1913 static HRESULT WINAPI IDirect3DRMFrame3Impl_LookAt(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *target,
1914         IDirect3DRMFrame3 *reference, D3DRMFRAMECONSTRAINT constraint)
1915 {
1916     FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1917
1918     return E_NOTIMPL;
1919 }
1920
1921 static HRESULT WINAPI IDirect3DRMFrame3Impl_Move(IDirect3DRMFrame3* iface, D3DVALUE delta)
1922 {
1923     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1924
1925     FIXME("(%p/%p)->(%f): stub\n", iface, This, delta);
1926
1927     return E_NOTIMPL;
1928 }
1929
1930 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteChild(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *frame)
1931 {
1932     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1933     IDirect3DRMFrameImpl *frame_obj = unsafe_impl_from_IDirect3DRMFrame3(frame);
1934     ULONG i;
1935
1936     TRACE("(%p/%p)->(%p)\n", iface, This, frame);
1937
1938     if (!frame_obj)
1939         return D3DRMERR_BADOBJECT;
1940
1941     /* Check if child exists */
1942     for (i = 0; i < This->nb_children; i++)
1943         if (This->children[i] == frame)
1944             break;
1945
1946     if (i == This->nb_children)
1947         return D3DRMERR_BADVALUE;
1948
1949     memmove(This->children + i, This->children + i + 1, sizeof(IDirect3DRMFrame3*) * (This->nb_children - 1 - i));
1950     IDirect3DRMFrame3_Release(frame);
1951     frame_obj->parent = NULL;
1952     This->nb_children--;
1953
1954     return D3DRM_OK;
1955 }
1956
1957 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteLight(IDirect3DRMFrame3 *iface, IDirect3DRMLight *light)
1958 {
1959     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1960     ULONG i;
1961
1962     TRACE("(%p/%p)->(%p)\n", iface, This, light);
1963
1964     if (!light)
1965         return D3DRMERR_BADOBJECT;
1966
1967     /* Check if visual exists */
1968     for (i = 0; i < This->nb_lights; i++)
1969         if (This->lights[i] == light)
1970             break;
1971
1972     if (i == This->nb_lights)
1973         return D3DRMERR_BADVALUE;
1974
1975     memmove(This->lights + i, This->lights + i + 1, sizeof(IDirect3DRMLight*) * (This->nb_lights - 1 - i));
1976     IDirect3DRMLight_Release(light);
1977     This->nb_lights--;
1978
1979     return D3DRM_OK;
1980 }
1981
1982 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteMoveCallback(IDirect3DRMFrame3* iface,
1983                                                                D3DRMFRAME3MOVECALLBACK cb,
1984                                                                VOID *arg)
1985 {
1986     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1987
1988     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
1989
1990     return E_NOTIMPL;
1991 }
1992
1993 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteVisual(IDirect3DRMFrame3* iface, LPUNKNOWN vis)
1994 {
1995     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1996     ULONG i;
1997
1998     TRACE("(%p/%p)->(%p)\n", iface, This, vis);
1999
2000     if (!vis)
2001         return D3DRMERR_BADOBJECT;
2002
2003     /* Check if visual exists */
2004     for (i = 0; i < This->nb_visuals; i++)
2005         if (This->visuals[i] == (IDirect3DRMVisual*)vis)
2006             break;
2007
2008     if (i == This->nb_visuals)
2009         return D3DRMERR_BADVALUE;
2010
2011     memmove(This->visuals + i, This->visuals + i + 1, sizeof(IDirect3DRMVisual*) * (This->nb_visuals - 1 - i));
2012     IDirect3DRMVisual_Release(vis);
2013     This->nb_visuals--;
2014
2015     return D3DRM_OK;
2016 }
2017
2018 static D3DCOLOR WINAPI IDirect3DRMFrame3Impl_GetSceneBackground(IDirect3DRMFrame3* iface)
2019 {
2020     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2021
2022     TRACE("(%p/%p)->()\n", iface, This);
2023
2024     return This->scenebackground;
2025 }
2026
2027 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetSceneBackgroundDepth(IDirect3DRMFrame3 *iface,
2028         IDirectDrawSurface **surface)
2029 {
2030     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2031
2032     FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
2033
2034     return E_NOTIMPL;
2035 }
2036
2037 static D3DCOLOR WINAPI IDirect3DRMFrame3Impl_GetSceneFogColor(IDirect3DRMFrame3* iface)
2038 {
2039     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2040
2041     FIXME("(%p/%p)->(): stub\n", iface, This);
2042
2043     return 0;
2044 }
2045
2046 static BOOL WINAPI IDirect3DRMFrame3Impl_GetSceneFogEnable(IDirect3DRMFrame3* iface)
2047 {
2048     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2049
2050     FIXME("(%p/%p)->(): stub\n", iface, This);
2051
2052     return FALSE;
2053 }
2054
2055 static D3DRMFOGMODE WINAPI IDirect3DRMFrame3Impl_GetSceneFogMode(IDirect3DRMFrame3* iface)
2056 {
2057     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2058
2059     FIXME("(%p/%p)->(): stub\n", iface, This);
2060
2061     return D3DRMFOG_LINEAR;
2062 }
2063
2064 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetSceneFogParams(IDirect3DRMFrame3* iface,
2065                                                               D3DVALUE *return_start,
2066                                                               D3DVALUE *return_end,
2067                                                               D3DVALUE *return_density)
2068 {
2069     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2070
2071     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, return_start, return_end, return_density);
2072
2073     return E_NOTIMPL;
2074 }
2075
2076 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackground(IDirect3DRMFrame3* iface,
2077                                                                D3DCOLOR color)
2078 {
2079     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2080
2081     TRACE("(%p/%p)->(%u)\n", iface, This, color);
2082
2083     This->scenebackground = color;
2084
2085     return D3DRM_OK;
2086 }
2087
2088 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackgroundRGB(IDirect3DRMFrame3* iface,
2089                                                                   D3DVALUE red, D3DVALUE green,
2090                                                                   D3DVALUE blue)
2091 {
2092     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2093
2094     TRACE("(%p/%p)->(%f,%f,%f)\n", iface, This, red, green, blue);
2095
2096     This->scenebackground = RGBA_MAKE((BYTE)(red * 255.0f),
2097             (BYTE)(green * 255.0f), (BYTE)(blue * 255.0f), 0xff);
2098
2099     return D3DRM_OK;
2100 }
2101
2102 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackgroundDepth(IDirect3DRMFrame3 *iface,
2103         IDirectDrawSurface *surface)
2104 {
2105     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2106
2107     FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
2108
2109     return E_NOTIMPL;
2110 }
2111
2112 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackgroundImage(IDirect3DRMFrame3* iface,
2113                                                                     LPDIRECT3DRMTEXTURE3 texture)
2114 {
2115     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2116
2117     FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
2118
2119     return E_NOTIMPL;
2120 }
2121
2122 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogEnable(IDirect3DRMFrame3* iface, BOOL enable)
2123 {
2124     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2125
2126     FIXME("(%p/%p)->(%d): stub\n", iface, This, enable);
2127
2128     return E_NOTIMPL;
2129 }
2130
2131 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogColor(IDirect3DRMFrame3* iface,
2132                                                              D3DCOLOR color)
2133 {
2134     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2135
2136     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
2137
2138     return E_NOTIMPL;
2139 }
2140
2141 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogMode(IDirect3DRMFrame3* iface,
2142                                                             D3DRMFOGMODE mode)
2143 {
2144     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2145
2146     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
2147
2148     return E_NOTIMPL;
2149 }
2150
2151 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogParams(IDirect3DRMFrame3* iface,
2152                                                               D3DVALUE start, D3DVALUE end,
2153                                                               D3DVALUE density)
2154 {
2155     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2156
2157     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, start, end, density);
2158
2159     return E_NOTIMPL;
2160 }
2161
2162 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetColor(IDirect3DRMFrame3* iface, D3DCOLOR color)
2163 {
2164     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2165
2166     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
2167
2168     return E_NOTIMPL;
2169 }
2170
2171 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetColorRGB(IDirect3DRMFrame3* iface, D3DVALUE red,
2172                                                         D3DVALUE green, D3DVALUE blue)
2173 {
2174     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2175
2176     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
2177
2178     return E_NOTIMPL;
2179 }
2180
2181 static D3DRMZBUFFERMODE WINAPI IDirect3DRMFrame3Impl_GetZbufferMode(IDirect3DRMFrame3* iface)
2182 {
2183     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2184
2185     FIXME("(%p/%p)->(): stub\n", iface, This);
2186
2187     return D3DRMZBUFFER_FROMPARENT;
2188 }
2189
2190 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetMaterialMode(IDirect3DRMFrame3* iface,
2191                                                             D3DRMMATERIALMODE mode)
2192 {
2193     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2194
2195     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
2196
2197     return E_NOTIMPL;
2198 }
2199
2200 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetOrientation(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *reference,
2201         D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2202 {
2203     FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2204             iface, reference, dx, dy, dz, ux, uy, uz);
2205
2206     return E_NOTIMPL;
2207 }
2208
2209 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetPosition(IDirect3DRMFrame3 *iface,
2210         IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2211 {
2212     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2213
2214     return E_NOTIMPL;
2215 }
2216
2217 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetRotation(IDirect3DRMFrame3 *iface,
2218         IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2219 {
2220     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2221             iface, reference, x, y, z, theta);
2222
2223     return E_NOTIMPL;
2224 }
2225
2226 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSortMode(IDirect3DRMFrame3* iface,
2227                                                         D3DRMSORTMODE mode)
2228 {
2229     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2230
2231     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
2232
2233     return E_NOTIMPL;
2234 }
2235
2236 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetTexture(IDirect3DRMFrame3* iface,
2237                                                        LPDIRECT3DRMTEXTURE3 texture)
2238 {
2239     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2240
2241     FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
2242
2243     return E_NOTIMPL;
2244 }
2245
2246 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetVelocity(IDirect3DRMFrame3 *iface,
2247         IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2248 {
2249     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x.\n",
2250             iface, reference, x, y, z, with_rotation);
2251
2252     return E_NOTIMPL;
2253 }
2254
2255 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetZbufferMode(IDirect3DRMFrame3* iface,
2256                                                            D3DRMZBUFFERMODE mode)
2257 {
2258     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2259
2260     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
2261
2262     return E_NOTIMPL;
2263 }
2264
2265 static HRESULT WINAPI IDirect3DRMFrame3Impl_Transform(IDirect3DRMFrame3* iface, D3DVECTOR *d,
2266                                                       D3DVECTOR *s)
2267 {
2268     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2269
2270     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
2271
2272     return E_NOTIMPL;
2273 }
2274
2275 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2276 {
2277     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2278
2279     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
2280
2281     return E_NOTIMPL;
2282 }
2283
2284 static BOOL WINAPI IDirect3DRMFrame3Impl_GetBoxEnable(IDirect3DRMFrame3* iface)
2285 {
2286     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2287
2288     FIXME("(%p/%p)->(): stub\n", iface, This);
2289
2290     return E_NOTIMPL;
2291 }
2292
2293 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetAxes(IDirect3DRMFrame3 *iface, D3DVECTOR *dir, D3DVECTOR *up)
2294 {
2295     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2296
2297     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, dir, up);
2298
2299     return E_NOTIMPL;
2300 }
2301
2302 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetMaterial(IDirect3DRMFrame3* iface,
2303                                                         LPDIRECT3DRMMATERIAL2 *material)
2304 {
2305     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2306
2307     FIXME("(%p/%p)->(%p): stub\n", iface, This, material);
2308
2309     return E_NOTIMPL;
2310 }
2311
2312 static BOOL WINAPI IDirect3DRMFrame3Impl_GetInheritAxes(IDirect3DRMFrame3* iface)
2313 {
2314     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2315
2316     FIXME("(%p/%p)->(): stub\n", iface, This);
2317
2318     return E_NOTIMPL;
2319 }
2320
2321 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetHierarchyBox(IDirect3DRMFrame3* iface, D3DRMBOX *box)
2322 {
2323     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2324
2325     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
2326
2327     return E_NOTIMPL;
2328 }
2329
2330 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2331 {
2332     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2333
2334     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
2335
2336     return E_NOTIMPL;
2337 }
2338
2339 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetBoxEnable(IDirect3DRMFrame3* iface, BOOL enable)
2340 {
2341     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2342
2343     FIXME("(%p/%p)->(%u): stub\n", iface, This, enable);
2344
2345     return E_NOTIMPL;
2346 }
2347
2348 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetAxes(IDirect3DRMFrame3* iface,
2349                                                     D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
2350                                                     D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2351 {
2352     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2353
2354     FIXME("(%p/%p)->(%f,%f,%f,%f,%f,%f): stub\n", iface, This, dx, dy, dz, ux, uy, uz);
2355
2356     return E_NOTIMPL;
2357 }
2358
2359 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetInheritAxes(IDirect3DRMFrame3* iface,
2360                                                            BOOL inherit_from_parent)
2361 {
2362     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2363
2364     FIXME("(%p/%p)->(%u): stub\n", iface, This, inherit_from_parent);
2365
2366     return E_NOTIMPL;
2367 }
2368
2369 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetMaterial(IDirect3DRMFrame3* iface,
2370                                                         LPDIRECT3DRMMATERIAL2 material)
2371 {
2372     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2373
2374     FIXME("(%p/%p)->(%p): stub\n", iface, This, material);
2375
2376     return E_NOTIMPL;
2377 }
2378
2379 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetQuaternion(IDirect3DRMFrame3 *iface,
2380         IDirect3DRMFrame3 *reference, D3DRMQUATERNION *q)
2381 {
2382     FIXME("iface %p, reference %p, q %p stub!\n", iface, reference, q);
2383
2384     return E_NOTIMPL;
2385 }
2386
2387 static HRESULT WINAPI IDirect3DRMFrame3Impl_RayPick(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *reference,
2388         D3DRMRAY *ray, DWORD flags, IDirect3DRMPicked2Array **return_visuals)
2389 {
2390     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2391
2392     FIXME("(%p/%p)->(%p,%p,%u,%p): stub\n", iface, This, reference, ray, flags, return_visuals);
2393
2394     return E_NOTIMPL;
2395 }
2396
2397 static HRESULT WINAPI IDirect3DRMFrame3Impl_Save(IDirect3DRMFrame3* iface, LPCSTR filename,
2398                                                  D3DRMXOFFORMAT d3dFormat,
2399                                                  D3DRMSAVEOPTIONS d3dSaveFlags)
2400 {
2401     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2402
2403     FIXME("(%p/%p)->(%p,%u,%u): stub\n", iface, This, filename, d3dFormat, d3dSaveFlags);
2404
2405     return E_NOTIMPL;
2406 }
2407
2408 static HRESULT WINAPI IDirect3DRMFrame3Impl_TransformVectors(IDirect3DRMFrame3 *iface,
2409         IDirect3DRMFrame3 *reference, DWORD num, D3DVECTOR *dst, D3DVECTOR *src)
2410 {
2411     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2412
2413     FIXME("(%p/%p)->(%p,%u,%p,%p): stub\n", iface, This, reference, num, dst, src);
2414
2415     return E_NOTIMPL;
2416 }
2417
2418 static HRESULT WINAPI IDirect3DRMFrame3Impl_InverseTransformVectors(IDirect3DRMFrame3 *iface,
2419         IDirect3DRMFrame3 *reference, DWORD num, D3DVECTOR *dst, D3DVECTOR *src)
2420 {
2421     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2422
2423     FIXME("(%p/%p)->(%p,%u,%p,%p): stub\n", iface, This, reference, num, dst, src);
2424
2425     return E_NOTIMPL;
2426 }
2427
2428 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetTraversalOptions(IDirect3DRMFrame3* iface,
2429                                                                 DWORD flags)
2430 {
2431     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2432
2433     FIXME("(%p/%p)->(%u): stub\n", iface, This, flags);
2434
2435     return E_NOTIMPL;
2436 }
2437
2438 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetTraversalOptions(IDirect3DRMFrame3* iface,
2439                                                                 LPDWORD flags)
2440 {
2441     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2442
2443     FIXME("(%p/%p)->(%p): stub\n", iface, This, flags);
2444
2445     return E_NOTIMPL;
2446 }
2447
2448 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogMethod(IDirect3DRMFrame3* iface,
2449                                                               DWORD flags)
2450 {
2451     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2452
2453     FIXME("(%p/%p)->(%u): stub\n", iface, This, flags);
2454
2455     return E_NOTIMPL;
2456 }
2457
2458 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetSceneFogMethod(IDirect3DRMFrame3* iface,
2459                                                               LPDWORD flags)
2460 {
2461     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2462
2463     FIXME("(%p/%p)->(%p): stub\n", iface, This, flags);
2464
2465     return E_NOTIMPL;
2466 }
2467
2468 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetMaterialOverride(IDirect3DRMFrame3 *iface,
2469         D3DRMMATERIALOVERRIDE *override)
2470 {
2471     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2472
2473     FIXME("(%p/%p)->(%p): stub\n", iface, This, override);
2474
2475     return E_NOTIMPL;
2476 }
2477
2478 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetMaterialOverride(IDirect3DRMFrame3 *iface,
2479         D3DRMMATERIALOVERRIDE *override)
2480 {
2481     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2482
2483     FIXME("(%p/%p)->(%p): stub\n", iface, This, override);
2484
2485     return E_NOTIMPL;
2486 }
2487
2488 static const struct IDirect3DRMFrame3Vtbl Direct3DRMFrame3_Vtbl =
2489 {
2490     /*** IUnknown methods ***/
2491     IDirect3DRMFrame3Impl_QueryInterface,
2492     IDirect3DRMFrame3Impl_AddRef,
2493     IDirect3DRMFrame3Impl_Release,
2494     /*** IDirect3DRMObject methods ***/
2495     IDirect3DRMFrame3Impl_Clone,
2496     IDirect3DRMFrame3Impl_AddDestroyCallback,
2497     IDirect3DRMFrame3Impl_DeleteDestroyCallback,
2498     IDirect3DRMFrame3Impl_SetAppData,
2499     IDirect3DRMFrame3Impl_GetAppData,
2500     IDirect3DRMFrame3Impl_SetName,
2501     IDirect3DRMFrame3Impl_GetName,
2502     IDirect3DRMFrame3Impl_GetClassName,
2503     /*** IDirect3DRMFrame3 methods ***/
2504     IDirect3DRMFrame3Impl_AddChild,
2505     IDirect3DRMFrame3Impl_AddLight,
2506     IDirect3DRMFrame3Impl_AddMoveCallback,
2507     IDirect3DRMFrame3Impl_AddTransform,
2508     IDirect3DRMFrame3Impl_AddTranslation,
2509     IDirect3DRMFrame3Impl_AddScale,
2510     IDirect3DRMFrame3Impl_AddRotation,
2511     IDirect3DRMFrame3Impl_AddVisual,
2512     IDirect3DRMFrame3Impl_GetChildren,
2513     IDirect3DRMFrame3Impl_GetColor,
2514     IDirect3DRMFrame3Impl_GetLights,
2515     IDirect3DRMFrame3Impl_GetMaterialMode,
2516     IDirect3DRMFrame3Impl_GetParent,
2517     IDirect3DRMFrame3Impl_GetPosition,
2518     IDirect3DRMFrame3Impl_GetRotation,
2519     IDirect3DRMFrame3Impl_GetScene,
2520     IDirect3DRMFrame3Impl_GetSortMode,
2521     IDirect3DRMFrame3Impl_GetTexture,
2522     IDirect3DRMFrame3Impl_GetTransform,
2523     IDirect3DRMFrame3Impl_GetVelocity,
2524     IDirect3DRMFrame3Impl_GetOrientation,
2525     IDirect3DRMFrame3Impl_GetVisuals,
2526     IDirect3DRMFrame3Impl_InverseTransform,
2527     IDirect3DRMFrame3Impl_Load,
2528     IDirect3DRMFrame3Impl_LookAt,
2529     IDirect3DRMFrame3Impl_Move,
2530     IDirect3DRMFrame3Impl_DeleteChild,
2531     IDirect3DRMFrame3Impl_DeleteLight,
2532     IDirect3DRMFrame3Impl_DeleteMoveCallback,
2533     IDirect3DRMFrame3Impl_DeleteVisual,
2534     IDirect3DRMFrame3Impl_GetSceneBackground,
2535     IDirect3DRMFrame3Impl_GetSceneBackgroundDepth,
2536     IDirect3DRMFrame3Impl_GetSceneFogColor,
2537     IDirect3DRMFrame3Impl_GetSceneFogEnable,
2538     IDirect3DRMFrame3Impl_GetSceneFogMode,
2539     IDirect3DRMFrame3Impl_GetSceneFogParams,
2540     IDirect3DRMFrame3Impl_SetSceneBackground,
2541     IDirect3DRMFrame3Impl_SetSceneBackgroundRGB,
2542     IDirect3DRMFrame3Impl_SetSceneBackgroundDepth,
2543     IDirect3DRMFrame3Impl_SetSceneBackgroundImage,
2544     IDirect3DRMFrame3Impl_SetSceneFogEnable,
2545     IDirect3DRMFrame3Impl_SetSceneFogColor,
2546     IDirect3DRMFrame3Impl_SetSceneFogMode,
2547     IDirect3DRMFrame3Impl_SetSceneFogParams,
2548     IDirect3DRMFrame3Impl_SetColor,
2549     IDirect3DRMFrame3Impl_SetColorRGB,
2550     IDirect3DRMFrame3Impl_GetZbufferMode,
2551     IDirect3DRMFrame3Impl_SetMaterialMode,
2552     IDirect3DRMFrame3Impl_SetOrientation,
2553     IDirect3DRMFrame3Impl_SetPosition,
2554     IDirect3DRMFrame3Impl_SetRotation,
2555     IDirect3DRMFrame3Impl_SetSortMode,
2556     IDirect3DRMFrame3Impl_SetTexture,
2557     IDirect3DRMFrame3Impl_SetVelocity,
2558     IDirect3DRMFrame3Impl_SetZbufferMode,
2559     IDirect3DRMFrame3Impl_Transform,
2560     IDirect3DRMFrame3Impl_GetBox,
2561     IDirect3DRMFrame3Impl_GetBoxEnable,
2562     IDirect3DRMFrame3Impl_GetAxes,
2563     IDirect3DRMFrame3Impl_GetMaterial,
2564     IDirect3DRMFrame3Impl_GetInheritAxes,
2565     IDirect3DRMFrame3Impl_GetHierarchyBox,
2566     IDirect3DRMFrame3Impl_SetBox,
2567     IDirect3DRMFrame3Impl_SetBoxEnable,
2568     IDirect3DRMFrame3Impl_SetAxes,
2569     IDirect3DRMFrame3Impl_SetInheritAxes,
2570     IDirect3DRMFrame3Impl_SetMaterial,
2571     IDirect3DRMFrame3Impl_SetQuaternion,
2572     IDirect3DRMFrame3Impl_RayPick,
2573     IDirect3DRMFrame3Impl_Save,
2574     IDirect3DRMFrame3Impl_TransformVectors,
2575     IDirect3DRMFrame3Impl_InverseTransformVectors,
2576     IDirect3DRMFrame3Impl_SetTraversalOptions,
2577     IDirect3DRMFrame3Impl_GetTraversalOptions,
2578     IDirect3DRMFrame3Impl_SetSceneFogMethod,
2579     IDirect3DRMFrame3Impl_GetSceneFogMethod,
2580     IDirect3DRMFrame3Impl_SetMaterialOverride,
2581     IDirect3DRMFrame3Impl_GetMaterialOverride
2582 };
2583
2584 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
2585 {
2586     if (!iface)
2587         return NULL;
2588     assert(iface->lpVtbl == &Direct3DRMFrame3_Vtbl);
2589
2590     return impl_from_IDirect3DRMFrame3(iface);
2591 }
2592
2593 HRESULT Direct3DRMFrame_create(REFIID riid, IUnknown* parent, IUnknown** ret_iface)
2594 {
2595     IDirect3DRMFrameImpl* object;
2596     HRESULT hr;
2597
2598     TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), parent, ret_iface);
2599
2600     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMFrameImpl));
2601     if (!object)
2602         return E_OUTOFMEMORY;
2603
2604     object->IDirect3DRMFrame2_iface.lpVtbl = &Direct3DRMFrame2_Vtbl;
2605     object->IDirect3DRMFrame3_iface.lpVtbl = &Direct3DRMFrame3_Vtbl;
2606     object->ref = 1;
2607     object->scenebackground = RGBA_MAKE(0, 0, 0, 0xff);
2608
2609     memcpy(object->transform, identity, sizeof(D3DRMMATRIX4D));
2610
2611     if (parent)
2612     {
2613         IDirect3DRMFrame3 *p;
2614
2615         hr = IDirect3DRMFrame_QueryInterface(parent, &IID_IDirect3DRMFrame3, (void**)&p);
2616         if (hr != S_OK)
2617         {
2618             HeapFree(GetProcessHeap(), 0, object);
2619             return hr;
2620         }
2621         IDirect3DRMFrame_Release(parent);
2622         IDirect3DRMFrame3_AddChild(p, &object->IDirect3DRMFrame3_iface);
2623     }
2624
2625     hr = IDirect3DRMFrame3_QueryInterface(&object->IDirect3DRMFrame3_iface, riid, (void**)ret_iface);
2626     IDirect3DRMFrame3_Release(&object->IDirect3DRMFrame3_iface);
2627     return S_OK;
2628 }