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

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