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