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 };
  59
  60 typedef struct {
  61     IDirect3DRMFrameArray IDirect3DRMFrameArray_iface;
  62     LONG ref;
  63     ULONG size;
  64     LPDIRECT3DRMFRAME* frames;
  65 } IDirect3DRMFrameArrayImpl;
  66
  67 typedef struct {
  68     IDirect3DRMVisualArray IDirect3DRMVisualArray_iface;
  69     LONG ref;
  70     ULONG size;
  71     LPDIRECT3DRMVISUAL* visuals;
  72 } IDirect3DRMVisualArrayImpl;
  73
  74 typedef struct {
  75     IDirect3DRMLightArray IDirect3DRMLightArray_iface;
  76     LONG ref;
  77     ULONG size;
  78     LPDIRECT3DRMLIGHT* lights;
  79 } IDirect3DRMLightArrayImpl;
  80
  81 static inline IDirect3DRMFrameImpl *impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface)
  82 {
  83     return CONTAINING_RECORD(iface, IDirect3DRMFrameImpl, IDirect3DRMFrame2_iface);
  84 }
  85
  86 static inline IDirect3DRMFrameImpl *impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
  87 {
  88     return CONTAINING_RECORD(iface, IDirect3DRMFrameImpl, IDirect3DRMFrame3_iface);
  89 }
  90
  91 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface);
  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     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
 598
 599     return E_NOTIMPL;
 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     IDirect3DRMFrameImpl *frame = unsafe_impl_from_IDirect3DRMFrame2((LPDIRECT3DRMFRAME2)child);
 608
 609     TRACE("(%p/%p)->(%p)\n", iface, This, child);
 610
 611     if (!frame)
 612         return D3DRMERR_BADOBJECT;
 613
 614     return IDirect3DRMFrame3_AddChild(&This->IDirect3DRMFrame3_iface, &frame->IDirect3DRMFrame3_iface);
 615 }
 616
 617 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddLight(IDirect3DRMFrame2* iface,
 618                                                        LPDIRECT3DRMLIGHT light)
 619 {
 620     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 621
 622     TRACE("(%p/%p)->(%p)\n", iface, This, light);
 623
 624     return IDirect3DRMFrame3_AddLight(&This->IDirect3DRMFrame3_iface, light);
 625 }
 626
 627 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddMoveCallback(IDirect3DRMFrame2* iface,
 628                                                             D3DRMFRAMEMOVECALLBACK cb, VOID *arg)
 629 {
 630     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 631
 632     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
 633
 634     return E_NOTIMPL;
 635 }
 636
 637 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddTransform(IDirect3DRMFrame2* iface,
 638                                                          D3DRMCOMBINETYPE type,
 639                                                          D3DRMMATRIX4D matrix)
 640 {
 641     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 642
 643     TRACE("(%p/%p)->(%u,%p)\n", iface, This, type, matrix);
 644
 645     return IDirect3DRMFrame3_AddTransform(&This->IDirect3DRMFrame3_iface, type, matrix);
 646 }
 647
 648 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddTranslation(IDirect3DRMFrame2* iface,
 649                                                            D3DRMCOMBINETYPE type,
 650                                                            D3DVALUE x, D3DVALUE y, D3DVALUE z)
 651 {
 652     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 653
 654     FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, x, y, z);
 655
 656     return E_NOTIMPL;
 657 }
 658
 659 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddScale(IDirect3DRMFrame2* iface,
 660                                                      D3DRMCOMBINETYPE type,
 661                                                      D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
 662 {
 663     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 664
 665     FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, sx, sy, sz);
 666
 667     return E_NOTIMPL;
 668 }
 669
 670 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddRotation(IDirect3DRMFrame2* iface,
 671                                                         D3DRMCOMBINETYPE type,
 672                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
 673                                                         D3DVALUE theta)
 674 {
 675     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 676
 677     FIXME("(%p/%p)->(%u,%f,%f,%f,%f): stub\n", iface, This, type, x, y, z, theta);
 678
 679     return E_NOTIMPL;
 680 }
 681
 682 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddVisual(IDirect3DRMFrame2* iface,
 683                                                       LPDIRECT3DRMVISUAL vis)
 684 {
 685     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 686
 687     TRACE("(%p/%p)->(%p)\n", iface, This, vis);
 688
 689     return IDirect3DRMFrame3_AddVisual(&This->IDirect3DRMFrame3_iface, (LPUNKNOWN)vis);
 690 }
 691
 692 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetChildren(IDirect3DRMFrame2* iface,
 693                                                         LPDIRECT3DRMFRAMEARRAY *children)
 694 {
 695     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 696
 697     TRACE("(%p/%p)->(%p)\n", iface, This, children);
 698
 699     return IDirect3DRMFrame3_GetChildren(&This->IDirect3DRMFrame3_iface, children);
 700 }
 701
 702 static D3DCOLOR WINAPI IDirect3DRMFrame2Impl_GetColor(IDirect3DRMFrame2* iface)
 703 {
 704     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 705
 706     FIXME("(%p/%p)->(): stub\n", iface, This);
 707
 708     return 0;
 709 }
 710
 711 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetLights(IDirect3DRMFrame2* iface,
 712                                                       LPDIRECT3DRMLIGHTARRAY *lights)
 713 {
 714     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 715
 716     TRACE("(%p/%p)->(%p)\n", iface, This, lights);
 717
 718     return IDirect3DRMFrame3_GetLights(&This->IDirect3DRMFrame3_iface, lights);
 719 }
 720
 721 static D3DRMMATERIALMODE WINAPI IDirect3DRMFrame2Impl_GetMaterialMode(IDirect3DRMFrame2* iface)
 722 {
 723     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 724
 725     FIXME("(%p/%p)->(): stub\n", iface, This);
 726
 727     return D3DRMMATERIAL_FROMPARENT;
 728 }
 729
 730 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetParent(IDirect3DRMFrame2* iface,
 731                                                       LPDIRECT3DRMFRAME * frame)
 732 {
 733     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 734
 735     TRACE("(%p/%p)->(%p)\n", iface, This, frame);
 736
 737     if (!frame)
 738         return D3DRMERR_BADVALUE;
 739
 740     if (This->parent)
 741     {
 742         *frame = (LPDIRECT3DRMFRAME)&This->parent->IDirect3DRMFrame2_iface;
 743         IDirect3DRMFrame_AddRef(*frame);
 744     }
 745     else
 746     {
 747         *frame = NULL;
 748     }
 749
 750     return D3DRM_OK;
 751 }
 752
 753 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetPosition(IDirect3DRMFrame2* iface,
 754                                                         LPDIRECT3DRMFRAME reference,
 755                                                         LPD3DVECTOR return_position)
 756 {
 757     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 758
 759     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, reference, return_position);
 760
 761     return E_NOTIMPL;
 762 }
 763
 764 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetRotation(IDirect3DRMFrame2* iface,
 765                                                         LPDIRECT3DRMFRAME reference,
 766                                                         LPD3DVECTOR axis, LPD3DVALUE return_theta)
 767 {
 768     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 769
 770     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, axis, return_theta);
 771
 772     return E_NOTIMPL;
 773 }
 774
 775 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetScene(IDirect3DRMFrame2* iface,
 776                                                      LPDIRECT3DRMFRAME * frame)
 777 {
 778     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 779
 780     FIXME("(%p/%p)->(%p): stub\n", iface, This, frame);
 781
 782     return E_NOTIMPL;
 783 }
 784
 785 static D3DRMSORTMODE WINAPI IDirect3DRMFrame2Impl_GetSortMode(IDirect3DRMFrame2* iface)
 786 {
 787     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 788
 789     FIXME("(%p/%p)->(): stub\n", iface, This);
 790
 791     return D3DRMSORT_FROMPARENT;
 792 }
 793
 794 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetTexture(IDirect3DRMFrame2* iface,
 795                                                        LPDIRECT3DRMTEXTURE * tex)
 796 {
 797     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 798
 799     FIXME("(%p/%p)->(%p): stub\n", iface, This, tex);
 800
 801     return E_NOTIMPL;
 802 }
 803
 804 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetTransform(IDirect3DRMFrame2* iface,
 805                                                          D3DRMMATRIX4D return_matrix)
 806 {
 807     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 808
 809     TRACE("(%p/%p)->(%p)\n", iface, This, return_matrix);
 810
 811     memcpy(&return_matrix[0][0], &This->transform[0][0], sizeof(D3DRMMATRIX4D));
 812
 813     return D3DRM_OK;
 814 }
 815
 816 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetVelocity(IDirect3DRMFrame2* iface,
 817                                                         LPDIRECT3DRMFRAME reference,
 818                                                         LPD3DVECTOR return_velocity,
 819                                                         BOOL with_rotation)
 820 {
 821     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 822
 823     FIXME("(%p/%p)->(%p,%p,%d): stub\n", iface, This, reference, return_velocity, with_rotation);
 824
 825     return E_NOTIMPL;
 826 }
 827
 828 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetOrientation(IDirect3DRMFrame2* iface,
 829                                                            LPDIRECT3DRMFRAME reference,
 830                                                            LPD3DVECTOR dir, LPD3DVECTOR 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     IDirect3DRMFrameImpl *child = unsafe_impl_from_IDirect3DRMFrame2((LPDIRECT3DRMFRAME2)frame);
 932
 933     TRACE("(%p/%p)->(%p)\n", iface, This, frame);
 934
 935     if (!child)
 936         return D3DRMERR_BADOBJECT;
 937
 938     return IDirect3DRMFrame3_DeleteChild(&This->IDirect3DRMFrame3_iface, &child->IDirect3DRMFrame3_iface);
 939 }
 940
 941 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteLight(IDirect3DRMFrame2* iface,
 942                                                           LPDIRECT3DRMLIGHT light)
 943 {
 944     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 945
 946     TRACE("(%p/%p)->(%p)\n", iface, This, light);
 947
 948     return IDirect3DRMFrame3_DeleteLight(&This->IDirect3DRMFrame3_iface, light);
 949 }
 950
 951 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteMoveCallback(IDirect3DRMFrame2* iface,
 952                                                                D3DRMFRAMEMOVECALLBACK cb, VOID *arg)
 953 {
 954     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 955
 956     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
 957
 958     return E_NOTIMPL;
 959 }
 960
 961 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteVisual(IDirect3DRMFrame2* iface,
 962                                                          LPDIRECT3DRMVISUAL vis)
 963 {
 964     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 965
 966     TRACE("(%p/%p)->(%p)\n", iface, This, vis);
 967
 968     return IDirect3DRMFrame3_DeleteVisual(&This->IDirect3DRMFrame3_iface, (LPUNKNOWN)vis);
 969 }
 970
 971 static D3DCOLOR WINAPI IDirect3DRMFrame2Impl_GetSceneBackground(IDirect3DRMFrame2* iface)
 972 {
 973     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 974
 975     FIXME("(%p/%p)->(): stub\n", iface, This);
 976
 977     return 0;
 978 }
 979
 980 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetSceneBackgroundDepth(IDirect3DRMFrame2* iface,
 981                                                                     LPDIRECTDRAWSURFACE * surface)
 982 {
 983     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 984
 985     FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
 986
 987     return E_NOTIMPL;
 988 }
 989
 990 static D3DCOLOR WINAPI IDirect3DRMFrame2Impl_GetSceneFogColor(IDirect3DRMFrame2* iface)
 991 {
 992     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 993
 994     FIXME("(%p/%p)->(): stub\n", iface, This);
 995
 996     return 0;
 997 }
 998
 999 static BOOL WINAPI IDirect3DRMFrame2Impl_GetSceneFogEnable(IDirect3DRMFrame2* iface)
1000 {
1001     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1002
1003     FIXME("(%p/%p)->(): stub\n", iface, This);
1004
1005     return FALSE;
1006 }
1007
1008 static D3DRMFOGMODE WINAPI IDirect3DRMFrame2Impl_GetSceneFogMode(IDirect3DRMFrame2* iface)
1009 {
1010     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1011
1012     FIXME("(%p/%p)->(): stub\n", iface, This);
1013
1014     return D3DRMFOG_LINEAR;
1015 }
1016
1017 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetSceneFogParams(IDirect3DRMFrame2* iface,
1018                                                               D3DVALUE *return_start,
1019                                                               D3DVALUE *return_end,
1020                                                               D3DVALUE *return_density)
1021 {
1022     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1023
1024     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, return_start, return_end, return_density);
1025
1026     return E_NOTIMPL;
1027 }
1028
1029 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackground(IDirect3DRMFrame2* iface,
1030                                                                D3DCOLOR color)
1031 {
1032     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1033
1034     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
1035
1036     return E_NOTIMPL;
1037 }
1038
1039 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackgroundRGB(IDirect3DRMFrame2* iface,
1040                                                                   D3DVALUE red, D3DVALUE green,
1041                                                                   D3DVALUE blue)
1042 {
1043     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1044
1045     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
1046
1047     return E_NOTIMPL;
1048 }
1049
1050 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackgroundDepth(IDirect3DRMFrame2* iface,
1051                                                                     LPDIRECTDRAWSURFACE surface)
1052 {
1053     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1054
1055     FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
1056
1057     return E_NOTIMPL;
1058 }
1059
1060 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackgroundImage(IDirect3DRMFrame2* iface,
1061                                                                     LPDIRECT3DRMTEXTURE texture)
1062 {
1063     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1064
1065     FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
1066
1067     return E_NOTIMPL;
1068 }
1069
1070 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogEnable(IDirect3DRMFrame2* iface, BOOL enable)
1071 {
1072     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1073
1074     FIXME("(%p/%p)->(%d): stub\n", iface, This, enable);
1075
1076     return E_NOTIMPL;
1077 }
1078
1079 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogColor(IDirect3DRMFrame2* iface,
1080                                                              D3DCOLOR color)
1081 {
1082     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1083
1084     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
1085
1086     return E_NOTIMPL;
1087 }
1088
1089 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogMode(IDirect3DRMFrame2* iface,
1090                                                             D3DRMFOGMODE mode)
1091 {
1092     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1093
1094     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1095
1096     return E_NOTIMPL;
1097 }
1098
1099 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogParams(IDirect3DRMFrame2* iface,
1100                                                               D3DVALUE start, D3DVALUE end,
1101                                                               D3DVALUE density)
1102 {
1103     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1104
1105     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, start, end, density);
1106
1107     return E_NOTIMPL;
1108 }
1109
1110 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetColor(IDirect3DRMFrame2* iface, D3DCOLOR color)
1111 {
1112     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1113
1114     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
1115
1116     return E_NOTIMPL;
1117 }
1118
1119 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetColorRGB(IDirect3DRMFrame2* iface, D3DVALUE red,
1120                                                         D3DVALUE green, D3DVALUE blue)
1121 {
1122     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1123
1124     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
1125
1126     return E_NOTIMPL;
1127 }
1128
1129 static D3DRMZBUFFERMODE WINAPI IDirect3DRMFrame2Impl_GetZbufferMode(IDirect3DRMFrame2* iface)
1130 {
1131     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1132
1133     FIXME("(%p/%p)->(): stub\n", iface, This);
1134
1135     return D3DRMZBUFFER_FROMPARENT;
1136 }
1137
1138 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetMaterialMode(IDirect3DRMFrame2* iface,
1139                                                             D3DRMMATERIALMODE mode)
1140 {
1141     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1142
1143     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1144
1145     return E_NOTIMPL;
1146 }
1147
1148 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetOrientation(IDirect3DRMFrame2* iface,
1149                                                            LPDIRECT3DRMFRAME reference,
1150                                                            D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
1151                                                            D3DVALUE ux, D3DVALUE uy, D3DVALUE uz )
1152 {
1153     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1154
1155     FIXME("(%p/%p)->(%p,%f,%f,%f,%f,%f,%f): stub\n", iface, This, reference,
1156           dx, dy, dz, ux, uy, uz);
1157
1158     return E_NOTIMPL;
1159 }
1160
1161 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetPosition(IDirect3DRMFrame2* iface,
1162                                                         LPDIRECT3DRMFRAME reference,
1163                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z)
1164 {
1165     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1166
1167     FIXME("(%p/%p)->(%p,%f,%f,%f): stub\n", iface, This, reference, x, y, z);
1168
1169     return E_NOTIMPL;
1170 }
1171
1172 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetRotation(IDirect3DRMFrame2* iface,
1173                                                         LPDIRECT3DRMFRAME reference,
1174                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
1175                                                         D3DVALUE theta)
1176 {
1177     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1178
1179     FIXME("(%p/%p)->(%p,%f,%f,%f,%f): stub\n", iface, This, reference, x, y, z, theta);
1180
1181     return E_NOTIMPL;
1182 }
1183
1184 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSortMode(IDirect3DRMFrame2* iface,
1185                                                         D3DRMSORTMODE mode)
1186 {
1187     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1188
1189     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1190
1191     return E_NOTIMPL;
1192 }
1193
1194 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetTexture(IDirect3DRMFrame2* iface,
1195                                                        LPDIRECT3DRMTEXTURE texture)
1196 {
1197     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1198
1199     FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
1200
1201     return E_NOTIMPL;
1202 }
1203
1204 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetTextureTopology(IDirect3DRMFrame2* iface,
1205                                                                BOOL wrap_u, BOOL wrap_v)
1206 {
1207     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1208
1209     FIXME("(%p/%p)->(%d,%d): stub\n", iface, This, wrap_u, wrap_v);
1210
1211     return E_NOTIMPL;
1212 }
1213
1214 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetVelocity(IDirect3DRMFrame2* iface,
1215                                                         LPDIRECT3DRMFRAME reference,
1216                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
1217                                                         BOOL with_rotation)
1218 {
1219     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1220
1221     FIXME("(%p/%p)->(%p,%f,%f,%f,%d): stub\n", iface, This, reference, x, y, z, with_rotation);
1222
1223     return E_NOTIMPL;
1224 }
1225
1226 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetZbufferMode(IDirect3DRMFrame2* iface,
1227                                                            D3DRMZBUFFERMODE mode)
1228 {
1229     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1230
1231     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1232
1233     return E_NOTIMPL;
1234 }
1235
1236 static HRESULT WINAPI IDirect3DRMFrame2Impl_Transform(IDirect3DRMFrame2* iface, D3DVECTOR *d,
1237                                                       D3DVECTOR *s)
1238 {
1239     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1240
1241     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
1242
1243     return E_NOTIMPL;
1244 }
1245
1246 /*** IDirect3DRMFrame2 methods ***/
1247 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddMoveCallback2(IDirect3DRMFrame2* iface,
1248                                                              D3DRMFRAMEMOVECALLBACK cb, VOID *arg,
1249                                                              DWORD flags)
1250 {
1251     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1252
1253     FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, cb, arg, flags);
1254
1255     return E_NOTIMPL;
1256 }
1257
1258 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetBox(IDirect3DRMFrame2* iface, LPD3DRMBOX box)
1259 {
1260     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1261
1262     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
1263
1264     return E_NOTIMPL;
1265 }
1266
1267 static BOOL WINAPI IDirect3DRMFrame2Impl_GetBoxEnable(IDirect3DRMFrame2* iface)
1268 {
1269     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1270
1271     FIXME("(%p/%p)->(): stub\n", iface, This);
1272
1273     return E_NOTIMPL;
1274 }
1275
1276 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetAxes(IDirect3DRMFrame2* iface,
1277                                                     LPD3DVECTOR dir, LPD3DVECTOR up)
1278 {
1279     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1280
1281     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, dir, up);
1282
1283     return E_NOTIMPL;
1284 }
1285
1286 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetMaterial(IDirect3DRMFrame2* iface,
1287                                                         LPDIRECT3DRMMATERIAL *material)
1288 {
1289     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1290
1291     FIXME("(%p/%p)->(%p): stub\n", iface, This, material);
1292
1293     return E_NOTIMPL;
1294 }
1295
1296 static BOOL WINAPI IDirect3DRMFrame2Impl_GetInheritAxes(IDirect3DRMFrame2* iface)
1297 {
1298     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1299
1300     FIXME("(%p/%p)->(): stub\n", iface, This);
1301
1302     return E_NOTIMPL;
1303 }
1304
1305 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetHierarchyBox(IDirect3DRMFrame2* iface,
1306                                                             LPD3DRMBOX box)
1307 {
1308     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
1309
1310     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
1311
1312     return E_NOTIMPL;
1313 }
1314
1315 static const struct IDirect3DRMFrame2Vtbl Direct3DRMFrame2_Vtbl =
1316 {
1317     /*** IUnknown methods ***/
1318     IDirect3DRMFrame2Impl_QueryInterface,
1319     IDirect3DRMFrame2Impl_AddRef,
1320     IDirect3DRMFrame2Impl_Release,
1321     /*** IDirect3DRMObject methods ***/
1322     IDirect3DRMFrame2Impl_Clone,
1323     IDirect3DRMFrame2Impl_AddDestroyCallback,
1324     IDirect3DRMFrame2Impl_DeleteDestroyCallback,
1325     IDirect3DRMFrame2Impl_SetAppData,
1326     IDirect3DRMFrame2Impl_GetAppData,
1327     IDirect3DRMFrame2Impl_SetName,
1328     IDirect3DRMFrame2Impl_GetName,
1329     IDirect3DRMFrame2Impl_GetClassName,
1330     /*** IDirect3DRMFrame methods ***/
1331     IDirect3DRMFrame2Impl_AddChild,
1332     IDirect3DRMFrame2Impl_AddLight,
1333     IDirect3DRMFrame2Impl_AddMoveCallback,
1334     IDirect3DRMFrame2Impl_AddTransform,
1335     IDirect3DRMFrame2Impl_AddTranslation,
1336     IDirect3DRMFrame2Impl_AddScale,
1337     IDirect3DRMFrame2Impl_AddRotation,
1338     IDirect3DRMFrame2Impl_AddVisual,
1339     IDirect3DRMFrame2Impl_GetChildren,
1340     IDirect3DRMFrame2Impl_GetColor,
1341     IDirect3DRMFrame2Impl_GetLights,
1342     IDirect3DRMFrame2Impl_GetMaterialMode,
1343     IDirect3DRMFrame2Impl_GetParent,
1344     IDirect3DRMFrame2Impl_GetPosition,
1345     IDirect3DRMFrame2Impl_GetRotation,
1346     IDirect3DRMFrame2Impl_GetScene,
1347     IDirect3DRMFrame2Impl_GetSortMode,
1348     IDirect3DRMFrame2Impl_GetTexture,
1349     IDirect3DRMFrame2Impl_GetTransform,
1350     IDirect3DRMFrame2Impl_GetVelocity,
1351     IDirect3DRMFrame2Impl_GetOrientation,
1352     IDirect3DRMFrame2Impl_GetVisuals,
1353     IDirect3DRMFrame2Impl_GetTextureTopology,
1354     IDirect3DRMFrame2Impl_InverseTransform,
1355     IDirect3DRMFrame2Impl_Load,
1356     IDirect3DRMFrame2Impl_LookAt,
1357     IDirect3DRMFrame2Impl_Move,
1358     IDirect3DRMFrame2Impl_DeleteChild,
1359     IDirect3DRMFrame2Impl_DeleteLight,
1360     IDirect3DRMFrame2Impl_DeleteMoveCallback,
1361     IDirect3DRMFrame2Impl_DeleteVisual,
1362     IDirect3DRMFrame2Impl_GetSceneBackground,
1363     IDirect3DRMFrame2Impl_GetSceneBackgroundDepth,
1364     IDirect3DRMFrame2Impl_GetSceneFogColor,
1365     IDirect3DRMFrame2Impl_GetSceneFogEnable,
1366     IDirect3DRMFrame2Impl_GetSceneFogMode,
1367     IDirect3DRMFrame2Impl_GetSceneFogParams,
1368     IDirect3DRMFrame2Impl_SetSceneBackground,
1369     IDirect3DRMFrame2Impl_SetSceneBackgroundRGB,
1370     IDirect3DRMFrame2Impl_SetSceneBackgroundDepth,
1371     IDirect3DRMFrame2Impl_SetSceneBackgroundImage,
1372     IDirect3DRMFrame2Impl_SetSceneFogEnable,
1373     IDirect3DRMFrame2Impl_SetSceneFogColor,
1374     IDirect3DRMFrame2Impl_SetSceneFogMode,
1375     IDirect3DRMFrame2Impl_SetSceneFogParams,
1376     IDirect3DRMFrame2Impl_SetColor,
1377     IDirect3DRMFrame2Impl_SetColorRGB,
1378     IDirect3DRMFrame2Impl_GetZbufferMode,
1379     IDirect3DRMFrame2Impl_SetMaterialMode,
1380     IDirect3DRMFrame2Impl_SetOrientation,
1381     IDirect3DRMFrame2Impl_SetPosition,
1382     IDirect3DRMFrame2Impl_SetRotation,
1383     IDirect3DRMFrame2Impl_SetSortMode,
1384     IDirect3DRMFrame2Impl_SetTexture,
1385     IDirect3DRMFrame2Impl_SetTextureTopology,
1386     IDirect3DRMFrame2Impl_SetVelocity,
1387     IDirect3DRMFrame2Impl_SetZbufferMode,
1388     IDirect3DRMFrame2Impl_Transform,
1389     /*** IDirect3DRMFrame2 methods ***/
1390     IDirect3DRMFrame2Impl_AddMoveCallback2,
1391     IDirect3DRMFrame2Impl_GetBox,
1392     IDirect3DRMFrame2Impl_GetBoxEnable,
1393     IDirect3DRMFrame2Impl_GetAxes,
1394     IDirect3DRMFrame2Impl_GetMaterial,
1395     IDirect3DRMFrame2Impl_GetInheritAxes,
1396     IDirect3DRMFrame2Impl_GetHierarchyBox
1397 };
1398
1399 /*** IUnknown methods ***/
1400 static HRESULT WINAPI IDirect3DRMFrame3Impl_QueryInterface(IDirect3DRMFrame3* iface,
1401                                                            REFIID riid, void** object)
1402 {
1403     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1404     return IDirect3DRMFrame_QueryInterface(&This->IDirect3DRMFrame2_iface, riid, object);
1405 }
1406
1407 static ULONG WINAPI IDirect3DRMFrame3Impl_AddRef(IDirect3DRMFrame3* iface)
1408 {
1409     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1410     return IDirect3DRMFrame2_AddRef(&This->IDirect3DRMFrame2_iface);
1411 }
1412
1413 static ULONG WINAPI IDirect3DRMFrame3Impl_Release(IDirect3DRMFrame3* iface)
1414 {
1415     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1416     return IDirect3DRMFrame2_Release(&This->IDirect3DRMFrame2_iface);
1417 }
1418
1419 /*** IDirect3DRMObject methods ***/
1420 static HRESULT WINAPI IDirect3DRMFrame3Impl_Clone(IDirect3DRMFrame3* iface,
1421                                                   LPUNKNOWN unkwn, REFIID riid,
1422                                                   LPVOID* object)
1423 {
1424     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1425
1426     FIXME("(%p/%p)->(%p, %s, %p): stub\n", iface, This, unkwn, debugstr_guid(riid), object);
1427
1428     return E_NOTIMPL;
1429 }
1430
1431 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddDestroyCallback(IDirect3DRMFrame3* iface,
1432                                                                D3DRMOBJECTCALLBACK cb,
1433                                                                LPVOID argument)
1434 {
1435     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1436
1437     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
1438
1439     return E_NOTIMPL;
1440 }
1441
1442 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteDestroyCallback(IDirect3DRMFrame3* iface,
1443                                                                   D3DRMOBJECTCALLBACK cb,
1444                                                                   LPVOID argument)
1445 {
1446     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1447
1448     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
1449
1450     return E_NOTIMPL;
1451 }
1452
1453 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetAppData(IDirect3DRMFrame3* iface,
1454                                                        DWORD data)
1455 {
1456     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1457
1458     FIXME("(%p/%p)->(%u): stub\n", iface, This, data);
1459
1460     return E_NOTIMPL;
1461 }
1462
1463 static DWORD WINAPI IDirect3DRMFrame3Impl_GetAppData(IDirect3DRMFrame3* iface)
1464 {
1465     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1466
1467     FIXME("(%p/%p)->(): stub\n", iface, This);
1468
1469     return 0;
1470 }
1471
1472 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetName(IDirect3DRMFrame3* iface, LPCSTR name)
1473 {
1474     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1475
1476     FIXME("(%p/%p)->(%s): stub\n", iface, This, name);
1477
1478     return E_NOTIMPL;
1479 }
1480
1481 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetName(IDirect3DRMFrame3* iface,
1482                                                     LPDWORD size, LPSTR name)
1483 {
1484     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1485
1486     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
1487
1488     return E_NOTIMPL;
1489 }
1490
1491 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetClassName(IDirect3DRMFrame3* iface,
1492                                                          LPDWORD size, LPSTR name)
1493 {
1494     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1495
1496     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
1497
1498     return E_NOTIMPL;
1499 }
1500
1501 /*** IDirect3DRMFrame methods ***/
1502 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddChild(IDirect3DRMFrame3* iface,
1503                                                      LPDIRECT3DRMFRAME3 child)
1504 {
1505     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1506     IDirect3DRMFrameImpl *child_obj = unsafe_impl_from_IDirect3DRMFrame3(child);
1507
1508     TRACE("(%p/%p)->(%p)\n", iface, This, child);
1509
1510     if (!child_obj)
1511         return D3DRMERR_BADOBJECT;
1512
1513     if (child_obj->parent)
1514     {
1515         IDirect3DRMFrame3* parent = &child_obj->parent->IDirect3DRMFrame3_iface;
1516
1517         if (parent == iface)
1518         {
1519             /* Passed frame is already a child so return success */
1520             return D3DRM_OK;
1521         }
1522         else
1523         {
1524             /* Remove parent and continue */
1525             IDirect3DRMFrame3_DeleteChild(parent, child);
1526         }
1527     }
1528
1529     if ((This->nb_children + 1) > This->children_capacity)
1530     {
1531         ULONG new_capacity;
1532         IDirect3DRMFrame3** children;
1533
1534         if (!This->children_capacity)
1535         {
1536             new_capacity = 16;
1537             children = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMFrame3*));
1538         }
1539         else
1540         {
1541             new_capacity = This->children_capacity * 2;
1542             children = HeapReAlloc(GetProcessHeap(), 0, This->children, new_capacity * sizeof(IDirect3DRMFrame3*));
1543         }
1544
1545         if (!children)
1546             return E_OUTOFMEMORY;
1547
1548         This->children_capacity = new_capacity;
1549         This->children = children;
1550     }
1551
1552     This->children[This->nb_children++] = child;
1553     IDirect3DRMFrame3_AddRef(child);
1554     child_obj->parent = This;
1555
1556     return D3DRM_OK;
1557 }
1558
1559 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddLight(IDirect3DRMFrame3* iface,
1560                                                        LPDIRECT3DRMLIGHT light)
1561 {
1562     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1563     ULONG i;
1564     IDirect3DRMLight** lights;
1565
1566     TRACE("(%p/%p)->(%p)\n", iface, This, light);
1567
1568     if (!light)
1569         return D3DRMERR_BADOBJECT;
1570
1571     /* Check if already existing and return gracefully without increasing ref count */
1572     for (i = 0; i < This->nb_lights; i++)
1573         if (This->lights[i] == light)
1574             return D3DRM_OK;
1575
1576     if ((This->nb_lights + 1) > This->lights_capacity)
1577     {
1578         ULONG new_capacity;
1579
1580         if (!This->lights_capacity)
1581         {
1582             new_capacity = 16;
1583             lights = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMLight*));
1584         }
1585         else
1586         {
1587             new_capacity = This->lights_capacity * 2;
1588             lights = HeapReAlloc(GetProcessHeap(), 0, This->lights, new_capacity * sizeof(IDirect3DRMLight*));
1589         }
1590
1591         if (!lights)
1592             return E_OUTOFMEMORY;
1593
1594         This->lights_capacity = new_capacity;
1595         This->lights = lights;
1596     }
1597
1598     This->lights[This->nb_lights++] = light;
1599     IDirect3DRMLight_AddRef(light);
1600
1601     return D3DRM_OK;
1602 }
1603
1604 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddMoveCallback(IDirect3DRMFrame3* iface,
1605                                                             D3DRMFRAME3MOVECALLBACK cb, VOID *arg,
1606                                                             DWORD flags)
1607 {
1608     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1609
1610     FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, cb, arg, flags);
1611
1612     return E_NOTIMPL;
1613 }
1614
1615 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddTransform(IDirect3DRMFrame3* iface,
1616                                                          D3DRMCOMBINETYPE type,
1617                                                          D3DRMMATRIX4D matrix)
1618 {
1619     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1620
1621     TRACE("(%p/%p)->(%u,%p)\n", iface, This, type, matrix);
1622
1623     switch (type)
1624     {
1625         case D3DRMCOMBINE_REPLACE:
1626             memcpy(&This->transform[0][0], &matrix[0][0], sizeof(D3DRMMATRIX4D));
1627             break;
1628
1629         case D3DRMCOMBINE_BEFORE:
1630             FIXME("D3DRMCOMBINE_BEFORE not supported yed\n");
1631             break;
1632
1633         case D3DRMCOMBINE_AFTER:
1634             FIXME("D3DRMCOMBINE_AFTER not supported yed\n");
1635             break;
1636
1637         default:
1638             WARN("Unknown Combine Type %u\n", type);
1639             return D3DRMERR_BADVALUE;
1640     }
1641
1642     return S_OK;
1643 }
1644
1645 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddTranslation(IDirect3DRMFrame3* iface,
1646                                                            D3DRMCOMBINETYPE type,
1647                                                            D3DVALUE x, D3DVALUE y, D3DVALUE z)
1648 {
1649     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1650
1651     FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, x, y, z);
1652
1653     return E_NOTIMPL;
1654 }
1655
1656 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddScale(IDirect3DRMFrame3* iface,
1657                                                      D3DRMCOMBINETYPE type,
1658                                                      D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1659 {
1660     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1661
1662     FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, sx, sy, sz);
1663
1664     return E_NOTIMPL;
1665 }
1666
1667 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddRotation(IDirect3DRMFrame3* iface,
1668                                                         D3DRMCOMBINETYPE type,
1669                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
1670                                                         D3DVALUE theta)
1671 {
1672     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1673
1674     FIXME("(%p/%p)->(%u,%f,%f,%f,%f): stub\n", iface, This, type, x, y, z, theta);
1675
1676     return E_NOTIMPL;
1677 }
1678
1679 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddVisual(IDirect3DRMFrame3* iface, LPUNKNOWN vis)
1680 {
1681     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1682     ULONG i;
1683     IDirect3DRMVisual** visuals;
1684
1685     TRACE("(%p/%p)->(%p)\n", iface, This, vis);
1686
1687     if (!vis)
1688         return D3DRMERR_BADOBJECT;
1689
1690     /* Check if already existing and return gracefully without increasing ref count */
1691     for (i = 0; i < This->nb_visuals; i++)
1692         if (This->visuals[i] == (IDirect3DRMVisual*)vis)
1693             return D3DRM_OK;
1694
1695     if ((This->nb_visuals + 1) > This->visuals_capacity)
1696     {
1697         ULONG new_capacity;
1698
1699         if (!This->visuals_capacity)
1700         {
1701             new_capacity = 16;
1702             visuals = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMVisual*));
1703         }
1704         else
1705         {
1706             new_capacity = This->visuals_capacity * 2;
1707             visuals = HeapReAlloc(GetProcessHeap(), 0, This->visuals, new_capacity * sizeof(IDirect3DRMVisual*));
1708         }
1709
1710         if (!visuals)
1711             return E_OUTOFMEMORY;
1712
1713         This->visuals_capacity = new_capacity;
1714         This->visuals = visuals;
1715     }
1716
1717     This->visuals[This->nb_visuals++] = (IDirect3DRMVisual*)vis;
1718     IDirect3DRMVisual_AddRef(vis);
1719
1720     return D3DRM_OK;
1721 }
1722
1723 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetChildren(IDirect3DRMFrame3* iface,
1724                                                         LPDIRECT3DRMFRAMEARRAY *children)
1725 {
1726     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1727     IDirect3DRMFrameArrayImpl* obj;
1728     HRESULT hr;
1729
1730     TRACE("(%p/%p)->(%p)\n", iface, This, children);
1731
1732     if (!children)
1733         return D3DRMERR_BADVALUE;
1734
1735     hr = Direct3DRMFrameArray_create(children);
1736
1737     if (hr != D3DRM_OK)
1738         return hr;
1739
1740     obj = (IDirect3DRMFrameArrayImpl*)*children;
1741
1742     obj->size = This->nb_children;
1743     if (This->nb_children)
1744     {
1745         ULONG i;
1746         obj->frames = HeapAlloc(GetProcessHeap(), 0, This->nb_children * sizeof(LPDIRECT3DRMFRAME));
1747         if (!obj->frames)
1748             return E_OUTOFMEMORY;
1749         for (i = 0; i < This->nb_children; i++)
1750             IDirect3DRMFrame3_QueryInterface(This->children[i], &IID_IDirect3DRMFrame, (void**)&obj->frames[i]);
1751     }
1752
1753     return D3DRM_OK;
1754 }
1755
1756 static D3DCOLOR WINAPI IDirect3DRMFrame3Impl_GetColor(IDirect3DRMFrame3* iface)
1757 {
1758     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1759
1760     FIXME("(%p/%p)->(): stub\n", iface, This);
1761
1762     return 0;
1763 }
1764
1765 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetLights(IDirect3DRMFrame3* iface,
1766                                                       LPDIRECT3DRMLIGHTARRAY *lights)
1767 {
1768     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1769     IDirect3DRMLightArrayImpl* obj;
1770     HRESULT hr;
1771
1772     TRACE("(%p/%p)->(%p)\n", iface, This, lights);
1773
1774     if (!lights)
1775         return D3DRMERR_BADVALUE;
1776
1777     hr = Direct3DRMLightArray_create(lights);
1778
1779     if (hr != D3DRM_OK)
1780         return hr;
1781
1782     obj = (IDirect3DRMLightArrayImpl*)*lights;
1783
1784     obj->size = This->nb_lights;
1785     if (This->nb_lights)
1786     {
1787         ULONG i;
1788         obj->lights = HeapAlloc(GetProcessHeap(), 0, This->nb_lights * sizeof(LPDIRECT3DRMLIGHT));
1789         if (!obj->lights)
1790             return E_OUTOFMEMORY;
1791         for (i = 0; i < This->nb_lights; i++)
1792             IDirect3DRMLight_QueryInterface(This->lights[i], &IID_IDirect3DRMLight, (void**)&obj->lights[i]);
1793     }
1794
1795     return D3DRM_OK;
1796 }
1797
1798 static D3DRMMATERIALMODE WINAPI IDirect3DRMFrame3Impl_GetMaterialMode(IDirect3DRMFrame3* iface)
1799 {
1800     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1801
1802     FIXME("(%p/%p)->(): stub\n", iface, This);
1803
1804     return D3DRMMATERIAL_FROMPARENT;
1805 }
1806
1807 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetParent(IDirect3DRMFrame3* iface,
1808                                                       LPDIRECT3DRMFRAME3 * frame)
1809 {
1810     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1811
1812     TRACE("(%p/%p)->(%p)\n", iface, This, frame);
1813
1814     if (!frame)
1815         return D3DRMERR_BADVALUE;
1816
1817     if (This->parent)
1818     {
1819         *frame = &This->parent->IDirect3DRMFrame3_iface;
1820         IDirect3DRMFrame_AddRef(*frame);
1821     }
1822     else
1823     {
1824         *frame = NULL;
1825     }
1826
1827     return D3DRM_OK;
1828 }
1829
1830 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetPosition(IDirect3DRMFrame3* iface,
1831                                                         LPDIRECT3DRMFRAME3 reference,
1832                                                         LPD3DVECTOR return_position)
1833 {
1834     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1835
1836     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, reference, return_position);
1837
1838     return E_NOTIMPL;
1839 }
1840
1841 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetRotation(IDirect3DRMFrame3* iface,
1842                                                         LPDIRECT3DRMFRAME3 reference,
1843                                                         LPD3DVECTOR axis, LPD3DVALUE return_theta)
1844 {
1845     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1846
1847     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, axis, return_theta);
1848
1849     return E_NOTIMPL;
1850 }
1851
1852 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetScene(IDirect3DRMFrame3* iface,
1853                                                      LPDIRECT3DRMFRAME3 * frame)
1854 {
1855     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1856
1857     FIXME("(%p/%p)->(%p): stub\n", iface, This, frame);
1858
1859     return E_NOTIMPL;
1860 }
1861
1862 static D3DRMSORTMODE WINAPI IDirect3DRMFrame3Impl_GetSortMode(IDirect3DRMFrame3* iface)
1863 {
1864     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1865
1866     FIXME("(%p/%p)->(): stub\n", iface, This);
1867
1868     return D3DRMSORT_FROMPARENT;
1869 }
1870
1871 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetTexture(IDirect3DRMFrame3* iface,
1872                                                        LPDIRECT3DRMTEXTURE3 * tex)
1873 {
1874     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1875
1876     FIXME("(%p/%p)->(%p): stub\n", iface, This, tex);
1877
1878     return E_NOTIMPL;
1879 }
1880
1881 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetTransform(IDirect3DRMFrame3* iface,
1882                                                          LPDIRECT3DRMFRAME3 reference,
1883                                                          D3DRMMATRIX4D return_matrix)
1884 {
1885     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1886
1887     TRACE("(%p/%p)->(%p,%p)\n", iface, This, reference, return_matrix);
1888
1889     if (reference)
1890         FIXME("Specifying a frame as the root of the scene different from the current root frame is not supported yet\n");
1891
1892     memcpy(&return_matrix[0][0], &This->transform[0][0], sizeof(D3DRMMATRIX4D));
1893
1894     return D3DRM_OK;
1895 }
1896
1897 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetVelocity(IDirect3DRMFrame3* iface,
1898                                                         LPDIRECT3DRMFRAME3 reference,
1899                                                         LPD3DVECTOR return_velocity,
1900                                                         BOOL with_rotation)
1901 {
1902     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1903
1904     FIXME("(%p/%p)->(%p,%p,%d): stub\n", iface, This, reference, return_velocity, with_rotation);
1905
1906     return E_NOTIMPL;
1907 }
1908
1909 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetOrientation(IDirect3DRMFrame3* iface,
1910                                                            LPDIRECT3DRMFRAME3 reference,
1911                                                            LPD3DVECTOR dir, LPD3DVECTOR up)
1912 {
1913     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1914
1915     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, dir, up);
1916
1917     return E_NOTIMPL;
1918 }
1919
1920 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetVisuals(IDirect3DRMFrame3* iface, LPDWORD num,
1921                                                        LPUNKNOWN *visuals)
1922 {
1923     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1924
1925     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, num, visuals);
1926
1927     return E_NOTIMPL;
1928 }
1929
1930 static HRESULT WINAPI IDirect3DRMFrame3Impl_InverseTransform(IDirect3DRMFrame3* iface,
1931                                                              D3DVECTOR *d, D3DVECTOR *s)
1932 {
1933     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1934
1935     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
1936
1937     return E_NOTIMPL;
1938 }
1939
1940 static HRESULT WINAPI IDirect3DRMFrame3Impl_Load(IDirect3DRMFrame3* iface, LPVOID filename,
1941                                                  LPVOID name, D3DRMLOADOPTIONS loadflags,
1942                                                  D3DRMLOADTEXTURE3CALLBACK cb, LPVOID lpArg)
1943 {
1944     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1945
1946     FIXME("(%p/%p)->(%p,%p,%u,%p,%p): stub\n", iface, This, filename, name, loadflags, cb, lpArg);
1947
1948     return E_NOTIMPL;
1949 }
1950
1951 static HRESULT WINAPI IDirect3DRMFrame3Impl_LookAt(IDirect3DRMFrame3* iface,
1952                                                    LPDIRECT3DRMFRAME3 target,
1953                                                    LPDIRECT3DRMFRAME3 reference,
1954                                                    D3DRMFRAMECONSTRAINT constraint)
1955 {
1956     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1957
1958     FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, target, reference, constraint);
1959
1960     return E_NOTIMPL;
1961 }
1962
1963 static HRESULT WINAPI IDirect3DRMFrame3Impl_Move(IDirect3DRMFrame3* iface, D3DVALUE delta)
1964 {
1965     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1966
1967     FIXME("(%p/%p)->(%f): stub\n", iface, This, delta);
1968
1969     return E_NOTIMPL;
1970 }
1971
1972 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteChild(IDirect3DRMFrame3* iface,
1973                                                         LPDIRECT3DRMFRAME3 frame)
1974 {
1975     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1976     IDirect3DRMFrameImpl *frame_obj = unsafe_impl_from_IDirect3DRMFrame3(frame);
1977     ULONG i;
1978
1979     TRACE("(%p/%p)->(%p)\n", iface, This, frame);
1980
1981     if (!frame_obj)
1982         return D3DRMERR_BADOBJECT;
1983
1984     /* Check if child exists */
1985     for (i = 0; i < This->nb_children; i++)
1986         if (This->children[i] == frame)
1987             break;
1988
1989     if (i == This->nb_children)
1990         return D3DRMERR_BADVALUE;
1991
1992     memmove(This->children + i, This->children + i + 1, sizeof(IDirect3DRMFrame3*) * (This->nb_children - 1 - i));
1993     IDirect3DRMFrame3_Release(frame);
1994     frame_obj->parent = NULL;
1995     This->nb_children--;
1996
1997     return D3DRM_OK;
1998 }
1999
2000 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteLight(IDirect3DRMFrame3* iface,
2001                                                           LPDIRECT3DRMLIGHT light)
2002 {
2003     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2004     ULONG i;
2005
2006     TRACE("(%p/%p)->(%p)\n", iface, This, light);
2007
2008     if (!light)
2009         return D3DRMERR_BADOBJECT;
2010
2011     /* Check if visual exists */
2012     for (i = 0; i < This->nb_lights; i++)
2013         if (This->lights[i] == light)
2014             break;
2015
2016     if (i == This->nb_lights)
2017         return D3DRMERR_BADVALUE;
2018
2019     memmove(This->lights + i, This->lights + i + 1, sizeof(IDirect3DRMLight*) * (This->nb_lights - 1 - i));
2020     IDirect3DRMLight_Release(light);
2021     This->nb_lights--;
2022
2023     return D3DRM_OK;
2024 }
2025
2026 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteMoveCallback(IDirect3DRMFrame3* iface,
2027                                                                D3DRMFRAME3MOVECALLBACK cb,
2028                                                                VOID *arg)
2029 {
2030     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2031
2032     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
2033
2034     return E_NOTIMPL;
2035 }
2036
2037 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteVisual(IDirect3DRMFrame3* iface, LPUNKNOWN vis)
2038 {
2039     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2040     ULONG i;
2041
2042     TRACE("(%p/%p)->(%p)\n", iface, This, vis);
2043
2044     if (!vis)
2045         return D3DRMERR_BADOBJECT;
2046
2047     /* Check if visual exists */
2048     for (i = 0; i < This->nb_visuals; i++)
2049         if (This->visuals[i] == (IDirect3DRMVisual*)vis)
2050             break;
2051
2052     if (i == This->nb_visuals)
2053         return D3DRMERR_BADVALUE;
2054
2055     memmove(This->visuals + i, This->visuals + i + 1, sizeof(IDirect3DRMVisual*) * (This->nb_visuals - 1 - i));
2056     IDirect3DRMVisual_Release(vis);
2057     This->nb_visuals--;
2058
2059     return D3DRM_OK;
2060 }
2061
2062 static D3DCOLOR WINAPI IDirect3DRMFrame3Impl_GetSceneBackground(IDirect3DRMFrame3* iface)
2063 {
2064     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2065
2066     FIXME("(%p/%p)->(): stub\n", iface, This);
2067
2068     return 0;
2069 }
2070
2071 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetSceneBackgroundDepth(IDirect3DRMFrame3* iface,
2072                                                                     LPDIRECTDRAWSURFACE * surface)
2073 {
2074     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2075
2076     FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
2077
2078     return E_NOTIMPL;
2079 }
2080
2081 static D3DCOLOR WINAPI IDirect3DRMFrame3Impl_GetSceneFogColor(IDirect3DRMFrame3* iface)
2082 {
2083     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2084
2085     FIXME("(%p/%p)->(): stub\n", iface, This);
2086
2087     return 0;
2088 }
2089
2090 static BOOL WINAPI IDirect3DRMFrame3Impl_GetSceneFogEnable(IDirect3DRMFrame3* iface)
2091 {
2092     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2093
2094     FIXME("(%p/%p)->(): stub\n", iface, This);
2095
2096     return FALSE;
2097 }
2098
2099 static D3DRMFOGMODE WINAPI IDirect3DRMFrame3Impl_GetSceneFogMode(IDirect3DRMFrame3* iface)
2100 {
2101     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2102
2103     FIXME("(%p/%p)->(): stub\n", iface, This);
2104
2105     return D3DRMFOG_LINEAR;
2106 }
2107
2108 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetSceneFogParams(IDirect3DRMFrame3* iface,
2109                                                               D3DVALUE *return_start,
2110                                                               D3DVALUE *return_end,
2111                                                               D3DVALUE *return_density)
2112 {
2113     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2114
2115     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, return_start, return_end, return_density);
2116
2117     return E_NOTIMPL;
2118 }
2119
2120 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackground(IDirect3DRMFrame3* iface,
2121                                                                D3DCOLOR color)
2122 {
2123     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2124
2125     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
2126
2127     return E_NOTIMPL;
2128 }
2129
2130 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackgroundRGB(IDirect3DRMFrame3* iface,
2131                                                                   D3DVALUE red, D3DVALUE green,
2132                                                                   D3DVALUE blue)
2133 {
2134     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2135
2136     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
2137
2138     return E_NOTIMPL;
2139 }
2140
2141 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackgroundDepth(IDirect3DRMFrame3* iface,
2142                                                                     LPDIRECTDRAWSURFACE surface)
2143 {
2144     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2145
2146     FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
2147
2148     return E_NOTIMPL;
2149 }
2150
2151 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackgroundImage(IDirect3DRMFrame3* iface,
2152                                                                     LPDIRECT3DRMTEXTURE3 texture)
2153 {
2154     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2155
2156     FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
2157
2158     return E_NOTIMPL;
2159 }
2160
2161 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogEnable(IDirect3DRMFrame3* iface, BOOL enable)
2162 {
2163     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2164
2165     FIXME("(%p/%p)->(%d): stub\n", iface, This, enable);
2166
2167     return E_NOTIMPL;
2168 }
2169
2170 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogColor(IDirect3DRMFrame3* iface,
2171                                                              D3DCOLOR color)
2172 {
2173     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2174
2175     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
2176
2177     return E_NOTIMPL;
2178 }
2179
2180 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogMode(IDirect3DRMFrame3* iface,
2181                                                             D3DRMFOGMODE mode)
2182 {
2183     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2184
2185     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
2186
2187     return E_NOTIMPL;
2188 }
2189
2190 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogParams(IDirect3DRMFrame3* iface,
2191                                                               D3DVALUE start, D3DVALUE end,
2192                                                               D3DVALUE density)
2193 {
2194     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2195
2196     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, start, end, density);
2197
2198     return E_NOTIMPL;
2199 }
2200
2201 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetColor(IDirect3DRMFrame3* iface, D3DCOLOR color)
2202 {
2203     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2204
2205     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
2206
2207     return E_NOTIMPL;
2208 }
2209
2210 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetColorRGB(IDirect3DRMFrame3* iface, D3DVALUE red,
2211                                                         D3DVALUE green, D3DVALUE blue)
2212 {
2213     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2214
2215     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
2216
2217     return E_NOTIMPL;
2218 }
2219
2220 static D3DRMZBUFFERMODE WINAPI IDirect3DRMFrame3Impl_GetZbufferMode(IDirect3DRMFrame3* iface)
2221 {
2222     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2223
2224     FIXME("(%p/%p)->(): stub\n", iface, This);
2225
2226     return D3DRMZBUFFER_FROMPARENT;
2227 }
2228
2229 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetMaterialMode(IDirect3DRMFrame3* iface,
2230                                                             D3DRMMATERIALMODE mode)
2231 {
2232     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2233
2234     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
2235
2236     return E_NOTIMPL;
2237 }
2238
2239 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetOrientation(IDirect3DRMFrame3* iface,
2240                                                            LPDIRECT3DRMFRAME3 reference,
2241                                                            D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
2242                                                            D3DVALUE ux, D3DVALUE uy, D3DVALUE uz )
2243 {
2244     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2245
2246     FIXME("(%p/%p)->(%p,%f,%f,%f,%f,%f,%f): stub\n", iface, This, reference,
2247           dx, dy, dz, ux, uy, uz);
2248
2249     return E_NOTIMPL;
2250 }
2251
2252 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetPosition(IDirect3DRMFrame3* iface,
2253                                                         LPDIRECT3DRMFRAME3 reference,
2254                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z)
2255 {
2256     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2257
2258     FIXME("(%p/%p)->(%p,%f,%f,%f): stub\n", iface, This, reference, x, y, z);
2259
2260     return E_NOTIMPL;
2261 }
2262
2263 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetRotation(IDirect3DRMFrame3* iface,
2264                                                         LPDIRECT3DRMFRAME3 reference,
2265                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
2266                                                         D3DVALUE theta)
2267 {
2268     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2269
2270     FIXME("(%p/%p)->(%p,%f,%f,%f,%f): stub\n", iface, This, reference, x, y, z, theta);
2271
2272     return E_NOTIMPL;
2273 }
2274
2275 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSortMode(IDirect3DRMFrame3* iface,
2276                                                         D3DRMSORTMODE mode)
2277 {
2278     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2279
2280     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
2281
2282     return E_NOTIMPL;
2283 }
2284
2285 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetTexture(IDirect3DRMFrame3* iface,
2286                                                        LPDIRECT3DRMTEXTURE3 texture)
2287 {
2288     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2289
2290     FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
2291
2292     return E_NOTIMPL;
2293 }
2294
2295 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetVelocity(IDirect3DRMFrame3* iface,
2296                                                         LPDIRECT3DRMFRAME3 reference,
2297                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
2298                                                         BOOL with_rotation)
2299 {
2300     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2301
2302     FIXME("(%p/%p)->(%p,%f,%f,%f,%d): stub\n", iface, This, reference, x, y, z, with_rotation);
2303
2304     return E_NOTIMPL;
2305 }
2306
2307 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetZbufferMode(IDirect3DRMFrame3* iface,
2308                                                            D3DRMZBUFFERMODE mode)
2309 {
2310     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2311
2312     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
2313
2314     return E_NOTIMPL;
2315 }
2316
2317 static HRESULT WINAPI IDirect3DRMFrame3Impl_Transform(IDirect3DRMFrame3* iface, D3DVECTOR *d,
2318                                                       D3DVECTOR *s)
2319 {
2320     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2321
2322     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
2323
2324     return E_NOTIMPL;
2325 }
2326
2327 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetBox(IDirect3DRMFrame3* iface, LPD3DRMBOX box)
2328 {
2329     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2330
2331     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
2332
2333     return E_NOTIMPL;
2334 }
2335
2336 static BOOL WINAPI IDirect3DRMFrame3Impl_GetBoxEnable(IDirect3DRMFrame3* iface)
2337 {
2338     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2339
2340     FIXME("(%p/%p)->(): stub\n", iface, This);
2341
2342     return E_NOTIMPL;
2343 }
2344
2345 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetAxes(IDirect3DRMFrame3* iface,
2346                                                     LPD3DVECTOR dir, LPD3DVECTOR up)
2347 {
2348     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2349
2350     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, dir, up);
2351
2352     return E_NOTIMPL;
2353 }
2354
2355 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetMaterial(IDirect3DRMFrame3* iface,
2356                                                         LPDIRECT3DRMMATERIAL2 *material)
2357 {
2358     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2359
2360     FIXME("(%p/%p)->(%p): stub\n", iface, This, material);
2361
2362     return E_NOTIMPL;
2363 }
2364
2365 static BOOL WINAPI IDirect3DRMFrame3Impl_GetInheritAxes(IDirect3DRMFrame3* iface)
2366 {
2367     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2368
2369     FIXME("(%p/%p)->(): stub\n", iface, This);
2370
2371     return E_NOTIMPL;
2372 }
2373
2374 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetHierarchyBox(IDirect3DRMFrame3* iface,
2375                                                             LPD3DRMBOX box)
2376 {
2377     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2378
2379     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
2380
2381     return E_NOTIMPL;
2382 }
2383
2384 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetBox(IDirect3DRMFrame3* iface, LPD3DRMBOX box)
2385 {
2386     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2387
2388     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
2389
2390     return E_NOTIMPL;
2391 }
2392
2393 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetBoxEnable(IDirect3DRMFrame3* iface, BOOL enable)
2394 {
2395     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2396
2397     FIXME("(%p/%p)->(%u): stub\n", iface, This, enable);
2398
2399     return E_NOTIMPL;
2400 }
2401
2402 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetAxes(IDirect3DRMFrame3* iface,
2403                                                     D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
2404                                                     D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2405 {
2406     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2407
2408     FIXME("(%p/%p)->(%f,%f,%f,%f,%f,%f): stub\n", iface, This, dx, dy, dz, ux, uy, uz);
2409
2410     return E_NOTIMPL;
2411 }
2412
2413 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetInheritAxes(IDirect3DRMFrame3* iface,
2414                                                            BOOL inherit_from_parent)
2415 {
2416     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2417
2418     FIXME("(%p/%p)->(%u): stub\n", iface, This, inherit_from_parent);
2419
2420     return E_NOTIMPL;
2421 }
2422
2423 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetMaterial(IDirect3DRMFrame3* iface,
2424                                                         LPDIRECT3DRMMATERIAL2 material)
2425 {
2426     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2427
2428     FIXME("(%p/%p)->(%p): stub\n", iface, This, material);
2429
2430     return E_NOTIMPL;
2431 }
2432
2433 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetQuaternion(IDirect3DRMFrame3* iface,
2434                                                           LPDIRECT3DRMFRAME3 reference,
2435                                                           D3DRMQUATERNION *q)
2436 {
2437     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2438
2439     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, reference, q);
2440
2441     return E_NOTIMPL;
2442 }
2443
2444 static HRESULT WINAPI IDirect3DRMFrame3Impl_RayPick(IDirect3DRMFrame3* iface,
2445                                                     LPDIRECT3DRMFRAME3 reference, LPD3DRMRAY ray,
2446                                                     DWORD flags,
2447                                                     LPDIRECT3DRMPICKED2ARRAY *return_visuals)
2448 {
2449     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2450
2451     FIXME("(%p/%p)->(%p,%p,%u,%p): stub\n", iface, This, reference, ray, flags, return_visuals);
2452
2453     return E_NOTIMPL;
2454 }
2455
2456 static HRESULT WINAPI IDirect3DRMFrame3Impl_Save(IDirect3DRMFrame3* iface, LPCSTR filename,
2457                                                  D3DRMXOFFORMAT d3dFormat,
2458                                                  D3DRMSAVEOPTIONS d3dSaveFlags)
2459 {
2460     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2461
2462     FIXME("(%p/%p)->(%p,%u,%u): stub\n", iface, This, filename, d3dFormat, d3dSaveFlags);
2463
2464     return E_NOTIMPL;
2465 }
2466
2467 static HRESULT WINAPI IDirect3DRMFrame3Impl_TransformVectors(IDirect3DRMFrame3* iface,
2468                                                              LPDIRECT3DRMFRAME3 reference,
2469                                                              DWORD num, LPD3DVECTOR dst,
2470                                                              LPD3DVECTOR src)
2471 {
2472     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2473
2474     FIXME("(%p/%p)->(%p,%u,%p,%p): stub\n", iface, This, reference, num, dst, src);
2475
2476     return E_NOTIMPL;
2477 }
2478
2479 static HRESULT WINAPI IDirect3DRMFrame3Impl_InverseTransformVectors(IDirect3DRMFrame3* iface,
2480                                                                     LPDIRECT3DRMFRAME3 reference,
2481                                                                     DWORD num, LPD3DVECTOR dst,
2482                                                                     LPD3DVECTOR src)
2483 {
2484     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2485
2486     FIXME("(%p/%p)->(%p,%u,%p,%p): stub\n", iface, This, reference, num, dst, src);
2487
2488     return E_NOTIMPL;
2489 }
2490
2491 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetTraversalOptions(IDirect3DRMFrame3* iface,
2492                                                                 DWORD flags)
2493 {
2494     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2495
2496     FIXME("(%p/%p)->(%u): stub\n", iface, This, flags);
2497
2498     return E_NOTIMPL;
2499 }
2500
2501 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetTraversalOptions(IDirect3DRMFrame3* iface,
2502                                                                 LPDWORD flags)
2503 {
2504     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2505
2506     FIXME("(%p/%p)->(%p): stub\n", iface, This, flags);
2507
2508     return E_NOTIMPL;
2509 }
2510
2511 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogMethod(IDirect3DRMFrame3* iface,
2512                                                               DWORD flags)
2513 {
2514     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2515
2516     FIXME("(%p/%p)->(%u): stub\n", iface, This, flags);
2517
2518     return E_NOTIMPL;
2519 }
2520
2521 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetSceneFogMethod(IDirect3DRMFrame3* iface,
2522                                                               LPDWORD flags)
2523 {
2524     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2525
2526     FIXME("(%p/%p)->(%p): stub\n", iface, This, flags);
2527
2528     return E_NOTIMPL;
2529 }
2530
2531 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetMaterialOverride(IDirect3DRMFrame3* iface,
2532                                                                 LPD3DRMMATERIALOVERRIDE override)
2533 {
2534     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2535
2536     FIXME("(%p/%p)->(%p): stub\n", iface, This, override);
2537
2538     return E_NOTIMPL;
2539 }
2540
2541 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetMaterialOverride(IDirect3DRMFrame3* iface,
2542                                                                 LPD3DRMMATERIALOVERRIDE override)
2543 {
2544     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2545
2546     FIXME("(%p/%p)->(%p): stub\n", iface, This, override);
2547
2548     return E_NOTIMPL;
2549 }
2550
2551 static const struct IDirect3DRMFrame3Vtbl Direct3DRMFrame3_Vtbl =
2552 {
2553     /*** IUnknown methods ***/
2554     IDirect3DRMFrame3Impl_QueryInterface,
2555     IDirect3DRMFrame3Impl_AddRef,
2556     IDirect3DRMFrame3Impl_Release,
2557     /*** IDirect3DRMObject methods ***/
2558     IDirect3DRMFrame3Impl_Clone,
2559     IDirect3DRMFrame3Impl_AddDestroyCallback,
2560     IDirect3DRMFrame3Impl_DeleteDestroyCallback,
2561     IDirect3DRMFrame3Impl_SetAppData,
2562     IDirect3DRMFrame3Impl_GetAppData,
2563     IDirect3DRMFrame3Impl_SetName,
2564     IDirect3DRMFrame3Impl_GetName,
2565     IDirect3DRMFrame3Impl_GetClassName,
2566     /*** IDirect3DRMFrame3 methods ***/
2567     IDirect3DRMFrame3Impl_AddChild,
2568     IDirect3DRMFrame3Impl_AddLight,
2569     IDirect3DRMFrame3Impl_AddMoveCallback,
2570     IDirect3DRMFrame3Impl_AddTransform,
2571     IDirect3DRMFrame3Impl_AddTranslation,
2572     IDirect3DRMFrame3Impl_AddScale,
2573     IDirect3DRMFrame3Impl_AddRotation,
2574     IDirect3DRMFrame3Impl_AddVisual,
2575     IDirect3DRMFrame3Impl_GetChildren,
2576     IDirect3DRMFrame3Impl_GetColor,
2577     IDirect3DRMFrame3Impl_GetLights,
2578     IDirect3DRMFrame3Impl_GetMaterialMode,
2579     IDirect3DRMFrame3Impl_GetParent,
2580     IDirect3DRMFrame3Impl_GetPosition,
2581     IDirect3DRMFrame3Impl_GetRotation,
2582     IDirect3DRMFrame3Impl_GetScene,
2583     IDirect3DRMFrame3Impl_GetSortMode,
2584     IDirect3DRMFrame3Impl_GetTexture,
2585     IDirect3DRMFrame3Impl_GetTransform,
2586     IDirect3DRMFrame3Impl_GetVelocity,
2587     IDirect3DRMFrame3Impl_GetOrientation,
2588     IDirect3DRMFrame3Impl_GetVisuals,
2589     IDirect3DRMFrame3Impl_InverseTransform,
2590     IDirect3DRMFrame3Impl_Load,
2591     IDirect3DRMFrame3Impl_LookAt,
2592     IDirect3DRMFrame3Impl_Move,
2593     IDirect3DRMFrame3Impl_DeleteChild,
2594     IDirect3DRMFrame3Impl_DeleteLight,
2595     IDirect3DRMFrame3Impl_DeleteMoveCallback,
2596     IDirect3DRMFrame3Impl_DeleteVisual,
2597     IDirect3DRMFrame3Impl_GetSceneBackground,
2598     IDirect3DRMFrame3Impl_GetSceneBackgroundDepth,
2599     IDirect3DRMFrame3Impl_GetSceneFogColor,
2600     IDirect3DRMFrame3Impl_GetSceneFogEnable,
2601     IDirect3DRMFrame3Impl_GetSceneFogMode,
2602     IDirect3DRMFrame3Impl_GetSceneFogParams,
2603     IDirect3DRMFrame3Impl_SetSceneBackground,
2604     IDirect3DRMFrame3Impl_SetSceneBackgroundRGB,
2605     IDirect3DRMFrame3Impl_SetSceneBackgroundDepth,
2606     IDirect3DRMFrame3Impl_SetSceneBackgroundImage,
2607     IDirect3DRMFrame3Impl_SetSceneFogEnable,
2608     IDirect3DRMFrame3Impl_SetSceneFogColor,
2609     IDirect3DRMFrame3Impl_SetSceneFogMode,
2610     IDirect3DRMFrame3Impl_SetSceneFogParams,
2611     IDirect3DRMFrame3Impl_SetColor,
2612     IDirect3DRMFrame3Impl_SetColorRGB,
2613     IDirect3DRMFrame3Impl_GetZbufferMode,
2614     IDirect3DRMFrame3Impl_SetMaterialMode,
2615     IDirect3DRMFrame3Impl_SetOrientation,
2616     IDirect3DRMFrame3Impl_SetPosition,
2617     IDirect3DRMFrame3Impl_SetRotation,
2618     IDirect3DRMFrame3Impl_SetSortMode,
2619     IDirect3DRMFrame3Impl_SetTexture,
2620     IDirect3DRMFrame3Impl_SetVelocity,
2621     IDirect3DRMFrame3Impl_SetZbufferMode,
2622     IDirect3DRMFrame3Impl_Transform,
2623     IDirect3DRMFrame3Impl_GetBox,
2624     IDirect3DRMFrame3Impl_GetBoxEnable,
2625     IDirect3DRMFrame3Impl_GetAxes,
2626     IDirect3DRMFrame3Impl_GetMaterial,
2627     IDirect3DRMFrame3Impl_GetInheritAxes,
2628     IDirect3DRMFrame3Impl_GetHierarchyBox,
2629     IDirect3DRMFrame3Impl_SetBox,
2630     IDirect3DRMFrame3Impl_SetBoxEnable,
2631     IDirect3DRMFrame3Impl_SetAxes,
2632     IDirect3DRMFrame3Impl_SetInheritAxes,
2633     IDirect3DRMFrame3Impl_SetMaterial,
2634     IDirect3DRMFrame3Impl_SetQuaternion,
2635     IDirect3DRMFrame3Impl_RayPick,
2636     IDirect3DRMFrame3Impl_Save,
2637     IDirect3DRMFrame3Impl_TransformVectors,
2638     IDirect3DRMFrame3Impl_InverseTransformVectors,
2639     IDirect3DRMFrame3Impl_SetTraversalOptions,
2640     IDirect3DRMFrame3Impl_GetTraversalOptions,
2641     IDirect3DRMFrame3Impl_SetSceneFogMethod,
2642     IDirect3DRMFrame3Impl_GetSceneFogMethod,
2643     IDirect3DRMFrame3Impl_SetMaterialOverride,
2644     IDirect3DRMFrame3Impl_GetMaterialOverride
2645 };
2646
2647 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface)
2648 {
2649     if (!iface)
2650         return NULL;
2651     assert(iface->lpVtbl == &Direct3DRMFrame2_Vtbl);
2652
2653     return impl_from_IDirect3DRMFrame2(iface);
2654 }
2655
2656 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
2657 {
2658     if (!iface)
2659         return NULL;
2660     assert(iface->lpVtbl == &Direct3DRMFrame3_Vtbl);
2661
2662     return impl_from_IDirect3DRMFrame3(iface);
2663 }
2664
2665 HRESULT Direct3DRMFrame_create(REFIID riid, IUnknown* parent, IUnknown** ret_iface)
2666 {
2667     IDirect3DRMFrameImpl* object;
2668
2669     TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), parent, ret_iface);
2670
2671     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMFrameImpl));
2672     if (!object)
2673     {
2674         ERR("Out of memory\n");
2675         return E_OUTOFMEMORY;
2676     }
2677
2678     object->IDirect3DRMFrame2_iface.lpVtbl = &Direct3DRMFrame2_Vtbl;
2679     object->IDirect3DRMFrame3_iface.lpVtbl = &Direct3DRMFrame3_Vtbl;
2680     object->ref = 1;
2681
2682     memcpy(&object->transform[0][0], &identity[0][0], sizeof(D3DRMMATRIX4D));
2683
2684     if (IsEqualGUID(riid, &IID_IDirect3DRMFrame3))
2685     {
2686         if (parent)
2687             IDirect3DRMFrame3_AddChild((IDirect3DRMFrame3*)parent, &object->IDirect3DRMFrame3_iface);
2688         *ret_iface = (IUnknown*)&object->IDirect3DRMFrame3_iface;
2689     }
2690     else
2691     {
2692         if (parent)
2693             IDirect3DRMFrame2_AddChild((IDirect3DRMFrame2*)parent, (IDirect3DRMFrame*)&object->IDirect3DRMFrame2_iface);
2694         *ret_iface = (IUnknown*)&object->IDirect3DRMFrame2_iface;
2695     }
2696
2697     return S_OK;
2698 }