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