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

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