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