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