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