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 struct d3drm_frame
  42 {
  43     IDirect3DRMFrame2 IDirect3DRMFrame2_iface;
  44     IDirect3DRMFrame3 IDirect3DRMFrame3_iface;
  45     LONG ref;
  46     struct d3drm_frame *parent;
  47     ULONG nb_children;
  48     ULONG children_capacity;
  49     IDirect3DRMFrame3** children;
  50     ULONG nb_visuals;
  51     ULONG visuals_capacity;
  52     IDirect3DRMVisual** visuals;
  53     ULONG nb_lights;
  54     ULONG lights_capacity;
  55     IDirect3DRMLight** lights;
  56     D3DRMMATRIX4D transform;
  57     D3DCOLOR scenebackground;
  58 };
  59
  60 struct d3drm_frame_array
  61 {
  62     IDirect3DRMFrameArray IDirect3DRMFrameArray_iface;
  63     LONG ref;
  64     ULONG size;
  65     IDirect3DRMFrame **frames;
  66 };
  67
  68 struct d3drm_visual_array
  69 {
  70     IDirect3DRMVisualArray IDirect3DRMVisualArray_iface;
  71     LONG ref;
  72     ULONG size;
  73     IDirect3DRMVisual **visuals;
  74 };
  75
  76 struct d3drm_light_array
  77 {
  78     IDirect3DRMLightArray IDirect3DRMLightArray_iface;
  79     LONG ref;
  80     ULONG size;
  81     IDirect3DRMLight **lights;
  82 };
  83
  84 static inline struct d3drm_frame *impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface)
  85 {
  86     return CONTAINING_RECORD(iface, struct d3drm_frame, IDirect3DRMFrame2_iface);
  87 }
  88
  89 static inline struct d3drm_frame *impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
  90 {
  91     return CONTAINING_RECORD(iface, struct d3drm_frame, IDirect3DRMFrame3_iface);
  92 }
  93
  94 static inline struct d3drm_frame *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface);
  95
  96 static inline struct d3drm_frame_array *impl_from_IDirect3DRMFrameArray(IDirect3DRMFrameArray *iface)
  97 {
  98     return CONTAINING_RECORD(iface, struct d3drm_frame_array, IDirect3DRMFrameArray_iface);
  99 }
 100
 101 static inline struct d3drm_visual_array *impl_from_IDirect3DRMVisualArray(IDirect3DRMVisualArray *iface)
 102 {
 103     return CONTAINING_RECORD(iface, struct d3drm_visual_array, IDirect3DRMVisualArray_iface);
 104 }
 105
 106 static inline struct d3drm_light_array *impl_from_IDirect3DRMLightArray(IDirect3DRMLightArray *iface)
 107 {
 108     return CONTAINING_RECORD(iface, struct d3drm_light_array, IDirect3DRMLightArray_iface);
 109 }
 110
 111 static HRESULT WINAPI d3drm_frame_array_QueryInterface(IDirect3DRMFrameArray *iface, REFIID riid, void **out)
 112 {
 113     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 114
 115     if (IsEqualGUID(riid, &IID_IDirect3DRMFrameArray)
 116             || IsEqualGUID(riid, &IID_IUnknown))
 117     {
 118         IDirect3DRMFrameArray_AddRef(iface);
 119         *out = iface;
 120         return S_OK;
 121     }
 122
 123     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 124
 125     *out = NULL;
 126     return E_NOINTERFACE;
 127 }
 128
 129 static ULONG WINAPI d3drm_frame_array_AddRef(IDirect3DRMFrameArray *iface)
 130 {
 131     struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
 132     ULONG refcount = InterlockedIncrement(&array->ref);
 133
 134     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 135
 136     return refcount;
 137 }
 138
 139 static ULONG WINAPI d3drm_frame_array_Release(IDirect3DRMFrameArray *iface)
 140 {
 141     struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
 142     ULONG refcount = InterlockedDecrement(&array->ref);
 143     ULONG i;
 144
 145     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 146
 147     if (!refcount)
 148     {
 149         for (i = 0; i < array->size; ++i)
 150         {
 151             IDirect3DRMFrame_Release(array->frames[i]);
 152         }
 153         HeapFree(GetProcessHeap(), 0, array->frames);
 154         HeapFree(GetProcessHeap(), 0, array);
 155     }
 156
 157     return refcount;
 158 }
 159
 160 static DWORD WINAPI d3drm_frame_array_GetSize(IDirect3DRMFrameArray *iface)
 161 {
 162     struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
 163
 164     TRACE("iface %p.\n", iface);
 165
 166     return array->size;
 167 }
 168
 169 static HRESULT WINAPI d3drm_frame_array_GetElement(IDirect3DRMFrameArray *iface,
 170         DWORD index, IDirect3DRMFrame **frame)
 171 {
 172     struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
 173
 174     TRACE("iface %p, index %u, frame %p.\n", iface, index, frame);
 175
 176     if (!frame)
 177         return D3DRMERR_BADVALUE;
 178
 179     if (index >= array->size)
 180     {
 181         *frame = NULL;
 182         return D3DRMERR_BADVALUE;
 183     }
 184
 185     IDirect3DRMFrame_AddRef(array->frames[index]);
 186     *frame = array->frames[index];
 187
 188     return D3DRM_OK;
 189 }
 190
 191 static const struct IDirect3DRMFrameArrayVtbl d3drm_frame_array_vtbl =
 192 {
 193     d3drm_frame_array_QueryInterface,
 194     d3drm_frame_array_AddRef,
 195     d3drm_frame_array_Release,
 196     d3drm_frame_array_GetSize,
 197     d3drm_frame_array_GetElement,
 198 };
 199
 200 static struct d3drm_frame_array *d3drm_frame_array_create(unsigned int frame_count, IDirect3DRMFrame3 **frames)
 201 {
 202     struct d3drm_frame_array *array;
 203     unsigned int i;
 204
 205     if (!(array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*array))))
 206         return NULL;
 207
 208     array->IDirect3DRMFrameArray_iface.lpVtbl = &d3drm_frame_array_vtbl;
 209     array->ref = 1;
 210     array->size = frame_count;
 211
 212     if (frame_count)
 213     {
 214         if (!(array->frames = HeapAlloc(GetProcessHeap(), 0, frame_count * sizeof(*array->frames))))
 215         {
 216             HeapFree(GetProcessHeap(), 0, array);
 217             return NULL;
 218         }
 219
 220         for (i = 0; i < frame_count; ++i)
 221         {
 222             IDirect3DRMFrame3_QueryInterface(frames[i], &IID_IDirect3DRMFrame, (void **)&array->frames[i]);
 223         }
 224     }
 225
 226     return array;
 227 }
 228
 229 static HRESULT WINAPI d3drm_visual_array_QueryInterface(IDirect3DRMVisualArray *iface, REFIID riid, void **out)
 230 {
 231     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 232
 233     if (IsEqualGUID(riid, &IID_IDirect3DRMVisualArray)
 234             || IsEqualGUID(riid, &IID_IUnknown))
 235     {
 236         IDirect3DRMVisualArray_AddRef(iface);
 237         *out = iface;
 238         return S_OK;
 239     }
 240
 241     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 242
 243     *out = NULL;
 244     return E_NOINTERFACE;
 245 }
 246
 247 static ULONG WINAPI d3drm_visual_array_AddRef(IDirect3DRMVisualArray *iface)
 248 {
 249     struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
 250     ULONG refcount = InterlockedIncrement(&array->ref);
 251
 252     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 253
 254     return refcount;
 255 }
 256
 257 static ULONG WINAPI d3drm_visual_array_Release(IDirect3DRMVisualArray *iface)
 258 {
 259     struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
 260     ULONG refcount = InterlockedDecrement(&array->ref);
 261     ULONG i;
 262
 263     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 264
 265     if (!refcount)
 266     {
 267         for (i = 0; i < array->size; ++i)
 268         {
 269             IDirect3DRMVisual_Release(array->visuals[i]);
 270         }
 271         HeapFree(GetProcessHeap(), 0, array->visuals);
 272         HeapFree(GetProcessHeap(), 0, array);
 273     }
 274
 275     return refcount;
 276 }
 277
 278 static DWORD WINAPI d3drm_visual_array_GetSize(IDirect3DRMVisualArray *iface)
 279 {
 280     struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
 281
 282     TRACE("iface %p.\n", iface);
 283
 284     return array->size;
 285 }
 286
 287 static HRESULT WINAPI d3drm_visual_array_GetElement(IDirect3DRMVisualArray *iface,
 288         DWORD index, IDirect3DRMVisual **visual)
 289 {
 290     struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
 291
 292     TRACE("iface %p, index %u, visual %p.\n", iface, index, visual);
 293
 294     if (!visual)
 295         return D3DRMERR_BADVALUE;
 296
 297     if (index >= array->size)
 298     {
 299         *visual = NULL;
 300         return D3DRMERR_BADVALUE;
 301     }
 302
 303     IDirect3DRMVisual_AddRef(array->visuals[index]);
 304     *visual = array->visuals[index];
 305
 306     return D3DRM_OK;
 307 }
 308
 309 static const struct IDirect3DRMVisualArrayVtbl d3drm_visual_array_vtbl =
 310 {
 311     d3drm_visual_array_QueryInterface,
 312     d3drm_visual_array_AddRef,
 313     d3drm_visual_array_Release,
 314     d3drm_visual_array_GetSize,
 315     d3drm_visual_array_GetElement,
 316 };
 317
 318 static struct d3drm_visual_array *d3drm_visual_array_create(unsigned int visual_count, IDirect3DRMVisual **visuals)
 319 {
 320     struct d3drm_visual_array *array;
 321     unsigned int i;
 322
 323     if (!(array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*array))))
 324         return NULL;
 325
 326     array->IDirect3DRMVisualArray_iface.lpVtbl = &d3drm_visual_array_vtbl;
 327     array->ref = 1;
 328     array->size = visual_count;
 329
 330     if (visual_count)
 331     {
 332         if (!(array->visuals = HeapAlloc(GetProcessHeap(), 0, visual_count * sizeof(*array->visuals))))
 333         {
 334             HeapFree(GetProcessHeap(), 0, array);
 335             return NULL;
 336         }
 337
 338         for (i = 0; i < visual_count; ++i)
 339         {
 340             array->visuals[i] = visuals[i];
 341             IDirect3DRMVisual_AddRef(array->visuals[i]);
 342         }
 343     }
 344
 345     return array;
 346 }
 347
 348 static HRESULT WINAPI d3drm_light_array_QueryInterface(IDirect3DRMLightArray *iface, REFIID riid, void **out)
 349 {
 350     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 351
 352     if (IsEqualGUID(riid, &IID_IDirect3DRMLightArray)
 353             || IsEqualGUID(riid, &IID_IUnknown))
 354     {
 355         IDirect3DRMLightArray_AddRef(iface);
 356         *out = iface;
 357         return S_OK;
 358     }
 359
 360     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 361
 362     *out = NULL;
 363     return E_NOINTERFACE;
 364 }
 365
 366 static ULONG WINAPI d3drm_light_array_AddRef(IDirect3DRMLightArray *iface)
 367 {
 368     struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
 369     ULONG refcount = InterlockedIncrement(&array->ref);
 370
 371     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 372
 373     return refcount;
 374 }
 375
 376 static ULONG WINAPI d3drm_light_array_Release(IDirect3DRMLightArray *iface)
 377 {
 378     struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
 379     ULONG refcount = InterlockedDecrement(&array->ref);
 380     ULONG i;
 381
 382     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 383
 384     if (!refcount)
 385     {
 386         for (i = 0; i < array->size; ++i)
 387         {
 388             IDirect3DRMLight_Release(array->lights[i]);
 389         }
 390         HeapFree(GetProcessHeap(), 0, array->lights);
 391         HeapFree(GetProcessHeap(), 0, array);
 392     }
 393
 394     return refcount;
 395 }
 396
 397 static DWORD WINAPI d3drm_light_array_GetSize(IDirect3DRMLightArray *iface)
 398 {
 399     struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
 400
 401     TRACE("iface %p.\n", iface);
 402
 403     return array->size;
 404 }
 405
 406 static HRESULT WINAPI d3drm_light_array_GetElement(IDirect3DRMLightArray *iface,
 407         DWORD index, IDirect3DRMLight **light)
 408 {
 409     struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
 410
 411     TRACE("iface %p, index %u, light %p.\n", iface, index, light);
 412
 413     if (!light)
 414         return D3DRMERR_BADVALUE;
 415
 416     if (index >= array->size)
 417     {
 418         *light = NULL;
 419         return D3DRMERR_BADVALUE;
 420     }
 421
 422     IDirect3DRMLight_AddRef(array->lights[index]);
 423     *light = array->lights[index];
 424
 425     return D3DRM_OK;
 426 }
 427
 428 static const struct IDirect3DRMLightArrayVtbl d3drm_light_array_vtbl =
 429 {
 430     d3drm_light_array_QueryInterface,
 431     d3drm_light_array_AddRef,
 432     d3drm_light_array_Release,
 433     d3drm_light_array_GetSize,
 434     d3drm_light_array_GetElement,
 435 };
 436
 437 static struct d3drm_light_array *d3drm_light_array_create(unsigned int light_count, IDirect3DRMLight **lights)
 438 {
 439     struct d3drm_light_array *array;
 440     unsigned int i;
 441
 442     if (!(array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*array))))
 443         return NULL;
 444
 445     array->IDirect3DRMLightArray_iface.lpVtbl = &d3drm_light_array_vtbl;
 446     array->ref = 1;
 447     array->size = light_count;
 448
 449     if (light_count)
 450     {
 451         if (!(array->lights = HeapAlloc(GetProcessHeap(), 0, light_count * sizeof(*array->lights))))
 452         {
 453             HeapFree(GetProcessHeap(), 0, array);
 454             return NULL;
 455         }
 456
 457         for (i = 0; i < light_count; ++i)
 458         {
 459             array->lights[i] = lights[i];
 460             IDirect3DRMLight_AddRef(array->lights[i]);
 461         }
 462     }
 463
 464     return array;
 465 }
 466
 467 static HRESULT WINAPI d3drm_frame2_QueryInterface(IDirect3DRMFrame2 *iface, REFIID riid, void **out)
 468 {
 469     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 470
 471     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 472
 473     if (IsEqualGUID(riid, &IID_IDirect3DRMFrame2)
 474             || IsEqualGUID(riid, &IID_IDirect3DRMFrame)
 475             || IsEqualGUID(riid, &IID_IUnknown))
 476     {
 477         *out = &frame->IDirect3DRMFrame2_iface;
 478     }
 479     else if (IsEqualGUID(riid, &IID_IDirect3DRMFrame3))
 480     {
 481         *out = &frame->IDirect3DRMFrame3_iface;
 482     }
 483     else
 484     {
 485         *out = NULL;
 486         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 487         return E_NOINTERFACE;
 488     }
 489
 490     IUnknown_AddRef((IUnknown *)*out);
 491     return S_OK;
 492 }
 493
 494 static ULONG WINAPI d3drm_frame2_AddRef(IDirect3DRMFrame2 *iface)
 495 {
 496     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 497     ULONG refcount = InterlockedIncrement(&frame->ref);
 498
 499     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 500
 501     return refcount;
 502 }
 503
 504 static ULONG WINAPI d3drm_frame2_Release(IDirect3DRMFrame2 *iface)
 505 {
 506     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 507     ULONG refcount = InterlockedDecrement(&frame->ref);
 508     ULONG i;
 509
 510     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 511
 512     if (!refcount)
 513     {
 514         for (i = 0; i < frame->nb_children; ++i)
 515         {
 516             IDirect3DRMFrame3_Release(frame->children[i]);
 517         }
 518         HeapFree(GetProcessHeap(), 0, frame->children);
 519         for (i = 0; i < frame->nb_visuals; ++i)
 520         {
 521             IDirect3DRMVisual_Release(frame->visuals[i]);
 522         }
 523         HeapFree(GetProcessHeap(), 0, frame->visuals);
 524         for (i = 0; i < frame->nb_lights; ++i)
 525         {
 526             IDirect3DRMLight_Release(frame->lights[i]);
 527         }
 528         HeapFree(GetProcessHeap(), 0, frame->lights);
 529         HeapFree(GetProcessHeap(), 0, frame);
 530     }
 531
 532     return refcount;
 533 }
 534
 535 static HRESULT WINAPI d3drm_frame2_Clone(IDirect3DRMFrame2 *iface,
 536         IUnknown *outer, REFIID iid, void **out)
 537 {
 538     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
 539
 540     return E_NOTIMPL;
 541 }
 542
 543 static HRESULT WINAPI d3drm_frame2_AddDestroyCallback(IDirect3DRMFrame2 *iface,
 544         D3DRMOBJECTCALLBACK cb, void *ctx)
 545 {
 546     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 547
 548     return E_NOTIMPL;
 549 }
 550
 551 static HRESULT WINAPI d3drm_frame2_DeleteDestroyCallback(IDirect3DRMFrame2 *iface,
 552         D3DRMOBJECTCALLBACK cb, void *ctx)
 553 {
 554     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 555
 556     return E_NOTIMPL;
 557 }
 558
 559 static HRESULT WINAPI d3drm_frame2_SetAppData(IDirect3DRMFrame2 *iface, DWORD data)
 560 {
 561     FIXME("iface %p, data %#x stub!\n", iface, data);
 562
 563     return E_NOTIMPL;
 564 }
 565
 566 static DWORD WINAPI d3drm_frame2_GetAppData(IDirect3DRMFrame2 *iface)
 567 {
 568     FIXME("iface %p stub!\n", iface);
 569
 570     return 0;
 571 }
 572
 573 static HRESULT WINAPI d3drm_frame2_SetName(IDirect3DRMFrame2 *iface, const char *name)
 574 {
 575     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
 576
 577     return E_NOTIMPL;
 578 }
 579
 580 static HRESULT WINAPI d3drm_frame2_GetName(IDirect3DRMFrame2 *iface, DWORD *size, char *name)
 581 {
 582     FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
 583
 584     return E_NOTIMPL;
 585 }
 586
 587 static HRESULT WINAPI d3drm_frame2_GetClassName(IDirect3DRMFrame2 *iface, DWORD *size, char *name)
 588 {
 589     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 590
 591     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 592
 593     return IDirect3DRMFrame3_GetClassName(&frame->IDirect3DRMFrame3_iface, size, name);
 594 }
 595
 596 static HRESULT WINAPI d3drm_frame2_AddChild(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *child)
 597 {
 598     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 599     IDirect3DRMFrame3 *child3;
 600     HRESULT hr;
 601
 602     TRACE("iface %p, child %p.\n", iface, child);
 603
 604     if (!child)
 605         return D3DRMERR_BADOBJECT;
 606     hr = IDirect3DRMFrame_QueryInterface(child, &IID_IDirect3DRMFrame3, (void **)&child3);
 607     if (hr != S_OK)
 608         return D3DRMERR_BADOBJECT;
 609     IDirect3DRMFrame_Release(child);
 610
 611     return IDirect3DRMFrame3_AddChild(&frame->IDirect3DRMFrame3_iface, child3);
 612 }
 613
 614 static HRESULT WINAPI d3drm_frame2_AddLight(IDirect3DRMFrame2 *iface, IDirect3DRMLight *light)
 615 {
 616     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 617
 618     TRACE("iface %p, light %p.\n", iface, light);
 619
 620     return IDirect3DRMFrame3_AddLight(&frame->IDirect3DRMFrame3_iface, light);
 621 }
 622
 623 static HRESULT WINAPI d3drm_frame2_AddMoveCallback(IDirect3DRMFrame2 *iface,
 624         D3DRMFRAMEMOVECALLBACK cb, void *ctx)
 625 {
 626     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 627
 628     return E_NOTIMPL;
 629 }
 630
 631 static HRESULT WINAPI d3drm_frame2_AddTransform(IDirect3DRMFrame2 *iface, D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
 632 {
 633     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 634
 635     TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
 636
 637     return IDirect3DRMFrame3_AddTransform(&frame->IDirect3DRMFrame3_iface, type, matrix);
 638 }
 639
 640 static HRESULT WINAPI d3drm_frame2_AddTranslation(IDirect3DRMFrame2 *iface,
 641         D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z)
 642 {
 643     FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e stub!\n", iface, type, x, y, z);
 644
 645     return E_NOTIMPL;
 646 }
 647
 648 static HRESULT WINAPI d3drm_frame2_AddScale(IDirect3DRMFrame2 *iface,
 649         D3DRMCOMBINETYPE type, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
 650 {
 651     FIXME("iface %p, type %#x, sx %.8e, sy %.8e, sz %.8e stub!\n", iface, type, sx, sy, sz);
 652
 653     return E_NOTIMPL;
 654 }
 655
 656 static HRESULT WINAPI d3drm_frame2_AddRotation(IDirect3DRMFrame2 *iface,
 657         D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
 658 {
 659     FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n", iface, type, x, y, z, theta);
 660
 661     return E_NOTIMPL;
 662 }
 663
 664 static HRESULT WINAPI d3drm_frame2_AddVisual(IDirect3DRMFrame2 *iface, IDirect3DRMVisual *visual)
 665 {
 666     struct d3drm_frame *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 d3drm_frame2_GetChildren(IDirect3DRMFrame2 *iface, IDirect3DRMFrameArray **children)
 674 {
 675     struct d3drm_frame *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 d3drm_frame2_GetColor(IDirect3DRMFrame2 *iface)
 683 {
 684     FIXME("iface %p stub!\n", iface);
 685
 686     return 0;
 687 }
 688
 689 static HRESULT WINAPI d3drm_frame2_GetLights(IDirect3DRMFrame2 *iface, IDirect3DRMLightArray **lights)
 690 {
 691     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 692
 693     TRACE("iface %p, lights %p.\n", iface, lights);
 694
 695     return IDirect3DRMFrame3_GetLights(&frame->IDirect3DRMFrame3_iface, lights);
 696 }
 697
 698 static D3DRMMATERIALMODE WINAPI d3drm_frame2_GetMaterialMode(IDirect3DRMFrame2 *iface)
 699 {
 700     FIXME("iface %p stub!\n", iface);
 701
 702     return D3DRMMATERIAL_FROMPARENT;
 703 }
 704
 705 static HRESULT WINAPI d3drm_frame2_GetParent(IDirect3DRMFrame2 *iface, IDirect3DRMFrame **parent)
 706 {
 707     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 708
 709     TRACE("iface %p, parent %p.\n", iface, parent);
 710
 711     if (!parent)
 712         return D3DRMERR_BADVALUE;
 713
 714     if (frame->parent)
 715     {
 716         *parent = (IDirect3DRMFrame *)&frame->parent->IDirect3DRMFrame2_iface;
 717         IDirect3DRMFrame_AddRef(*parent);
 718     }
 719     else
 720     {
 721         *parent = NULL;
 722     }
 723
 724     return D3DRM_OK;
 725 }
 726
 727 static HRESULT WINAPI d3drm_frame2_GetPosition(IDirect3DRMFrame2 *iface,
 728         IDirect3DRMFrame *reference, D3DVECTOR *position)
 729 {
 730     FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
 731
 732     return E_NOTIMPL;
 733 }
 734
 735 static HRESULT WINAPI d3drm_frame2_GetRotation(IDirect3DRMFrame2 *iface,
 736         IDirect3DRMFrame *reference, D3DVECTOR *axis, D3DVALUE *theta)
 737 {
 738     FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
 739
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT WINAPI d3drm_frame2_GetScene(IDirect3DRMFrame2 *iface, IDirect3DRMFrame **scene)
 744 {
 745     FIXME("iface %p, scene %p stub!\n", iface, scene);
 746
 747     return E_NOTIMPL;
 748 }
 749
 750 static D3DRMSORTMODE WINAPI d3drm_frame2_GetSortMode(IDirect3DRMFrame2 *iface)
 751 {
 752     FIXME("iface %p stub!\n", iface);
 753
 754     return D3DRMSORT_FROMPARENT;
 755 }
 756
 757 static HRESULT WINAPI d3drm_frame2_GetTexture(IDirect3DRMFrame2 *iface, IDirect3DRMTexture **texture)
 758 {
 759     FIXME("iface %p, texture %p stub!\n", iface, texture);
 760
 761     return E_NOTIMPL;
 762 }
 763
 764 static HRESULT WINAPI d3drm_frame2_GetTransform(IDirect3DRMFrame2 *iface, D3DRMMATRIX4D matrix)
 765 {
 766     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 767
 768     TRACE("iface %p, matrix %p.\n", iface, matrix);
 769
 770     memcpy(matrix, frame->transform, sizeof(D3DRMMATRIX4D));
 771
 772     return D3DRM_OK;
 773 }
 774
 775 static HRESULT WINAPI d3drm_frame2_GetVelocity(IDirect3DRMFrame2 *iface,
 776         IDirect3DRMFrame *reference, D3DVECTOR *velocity, BOOL with_rotation)
 777 {
 778     FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
 779             iface, reference, velocity, with_rotation);
 780
 781     return E_NOTIMPL;
 782 }
 783
 784 static HRESULT WINAPI d3drm_frame2_GetOrientation(IDirect3DRMFrame2 *iface,
 785         IDirect3DRMFrame *reference, D3DVECTOR *dir, D3DVECTOR *up)
 786 {
 787     FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
 788
 789     return E_NOTIMPL;
 790 }
 791
 792 static HRESULT WINAPI d3drm_frame2_GetVisuals(IDirect3DRMFrame2 *iface, IDirect3DRMVisualArray **visuals)
 793 {
 794     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 795     struct d3drm_visual_array *array;
 796
 797     TRACE("iface %p, visuals %p.\n", iface, visuals);
 798
 799     if (!visuals)
 800         return D3DRMERR_BADVALUE;
 801
 802     if (!(array = d3drm_visual_array_create(frame->nb_visuals, frame->visuals)))
 803         return E_OUTOFMEMORY;
 804
 805     *visuals = &array->IDirect3DRMVisualArray_iface;
 806
 807     return D3DRM_OK;
 808 }
 809
 810 static HRESULT WINAPI d3drm_frame2_GetTextureTopology(IDirect3DRMFrame2 *iface, BOOL *wrap_u, BOOL *wrap_v)
 811 {
 812     FIXME("iface %p, wrap_u %p, wrap_v %p stub!\n", iface, wrap_u, wrap_v);
 813
 814     return E_NOTIMPL;
 815 }
 816
 817 static HRESULT WINAPI d3drm_frame2_InverseTransform(IDirect3DRMFrame2 *iface, D3DVECTOR *d, D3DVECTOR *s)
 818 {
 819     FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
 820
 821     return E_NOTIMPL;
 822 }
 823
 824 static HRESULT WINAPI d3drm_frame2_Load(IDirect3DRMFrame2 *iface, void *filename,
 825         void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURECALLBACK cb, void *ctx)
 826 {
 827     FIXME("iface %p, filename %p, name %p, flags %#x, cb %p, ctx %p stub!\n",
 828             iface, filename, name, flags, cb, ctx);
 829
 830     return E_NOTIMPL;
 831 }
 832
 833 static HRESULT WINAPI d3drm_frame2_LookAt(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *target,
 834         IDirect3DRMFrame *reference, D3DRMFRAMECONSTRAINT constraint)
 835 {
 836     FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
 837
 838     return E_NOTIMPL;
 839 }
 840
 841 static HRESULT WINAPI d3drm_frame2_Move(IDirect3DRMFrame2 *iface, D3DVALUE delta)
 842 {
 843     FIXME("iface %p, delta %.8e stub!\n", iface, delta);
 844
 845     return E_NOTIMPL;
 846 }
 847
 848 static HRESULT WINAPI d3drm_frame2_DeleteChild(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *child)
 849 {
 850     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 851     IDirect3DRMFrame3 *child3;
 852     HRESULT hr;
 853
 854     TRACE("iface %p, child %p.\n", iface, child);
 855
 856     if (!child)
 857         return D3DRMERR_BADOBJECT;
 858     if (FAILED(hr = IDirect3DRMFrame_QueryInterface(child, &IID_IDirect3DRMFrame3, (void **)&child3)))
 859         return D3DRMERR_BADOBJECT;
 860     IDirect3DRMFrame_Release(child);
 861
 862     return IDirect3DRMFrame3_DeleteChild(&frame->IDirect3DRMFrame3_iface, child3);
 863 }
 864
 865 static HRESULT WINAPI d3drm_frame2_DeleteLight(IDirect3DRMFrame2 *iface, IDirect3DRMLight *light)
 866 {
 867     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 868
 869     TRACE("iface %p, light %p.\n", iface, light);
 870
 871     return IDirect3DRMFrame3_DeleteLight(&frame->IDirect3DRMFrame3_iface, light);
 872 }
 873
 874 static HRESULT WINAPI d3drm_frame2_DeleteMoveCallback(IDirect3DRMFrame2 *iface,
 875         D3DRMFRAMEMOVECALLBACK cb, void *ctx)
 876 {
 877     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 878
 879     return E_NOTIMPL;
 880 }
 881
 882 static HRESULT WINAPI d3drm_frame2_DeleteVisual(IDirect3DRMFrame2 *iface, IDirect3DRMVisual *visual)
 883 {
 884     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 885
 886     TRACE("iface %p, visual %p.\n", iface, visual);
 887
 888     return IDirect3DRMFrame3_DeleteVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
 889 }
 890
 891 static D3DCOLOR WINAPI d3drm_frame2_GetSceneBackground(IDirect3DRMFrame2 *iface)
 892 {
 893     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 894
 895     TRACE("iface %p.\n", iface);
 896
 897     return IDirect3DRMFrame3_GetSceneBackground(&frame->IDirect3DRMFrame3_iface);
 898 }
 899
 900 static HRESULT WINAPI d3drm_frame2_GetSceneBackgroundDepth(IDirect3DRMFrame2 *iface,
 901         IDirectDrawSurface **surface)
 902 {
 903     FIXME("iface %p, surface %p stub!\n", iface, surface);
 904
 905     return E_NOTIMPL;
 906 }
 907
 908 static D3DCOLOR WINAPI d3drm_frame2_GetSceneFogColor(IDirect3DRMFrame2 *iface)
 909 {
 910     FIXME("iface %p stub!\n", iface);
 911
 912     return 0;
 913 }
 914
 915 static BOOL WINAPI d3drm_frame2_GetSceneFogEnable(IDirect3DRMFrame2 *iface)
 916 {
 917     FIXME("iface %p stub!\n", iface);
 918
 919     return FALSE;
 920 }
 921
 922 static D3DRMFOGMODE WINAPI d3drm_frame2_GetSceneFogMode(IDirect3DRMFrame2 *iface)
 923 {
 924     FIXME("iface %p stub!\n", iface);
 925
 926     return D3DRMFOG_LINEAR;
 927 }
 928
 929 static HRESULT WINAPI d3drm_frame2_GetSceneFogParams(IDirect3DRMFrame2 *iface,
 930         D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
 931 {
 932     FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
 933
 934     return E_NOTIMPL;
 935 }
 936
 937 static HRESULT WINAPI d3drm_frame2_SetSceneBackground(IDirect3DRMFrame2 *iface, D3DCOLOR color)
 938 {
 939     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 940
 941     TRACE("iface %p, color 0x%08x.\n", iface, color);
 942
 943     return IDirect3DRMFrame3_SetSceneBackground(&frame->IDirect3DRMFrame3_iface, color);
 944 }
 945
 946 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundRGB(IDirect3DRMFrame2 *iface,
 947         D3DVALUE red, D3DVALUE green, D3DVALUE blue)
 948 {
 949     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 950
 951     TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
 952
 953     return IDirect3DRMFrame3_SetSceneBackgroundRGB(&frame->IDirect3DRMFrame3_iface, red, green, blue);
 954 }
 955
 956 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundDepth(IDirect3DRMFrame2 *iface, IDirectDrawSurface *surface)
 957 {
 958     FIXME("iface %p, surface %p stub!\n", iface, surface);
 959
 960     return E_NOTIMPL;
 961 }
 962
 963 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundImage(IDirect3DRMFrame2 *iface, IDirect3DRMTexture *texture)
 964 {
 965     FIXME("iface %p, texture %p stub!\n", iface, texture);
 966
 967     return E_NOTIMPL;
 968 }
 969
 970 static HRESULT WINAPI d3drm_frame2_SetSceneFogEnable(IDirect3DRMFrame2 *iface, BOOL enable)
 971 {
 972     FIXME("iface %p, enable %#x stub!\n", iface, enable);
 973
 974     return E_NOTIMPL;
 975 }
 976
 977 static HRESULT WINAPI d3drm_frame2_SetSceneFogColor(IDirect3DRMFrame2 *iface, D3DCOLOR color)
 978 {
 979     FIXME("iface %p, color 0x%08x stub!\n", iface, color);
 980
 981     return E_NOTIMPL;
 982 }
 983
 984 static HRESULT WINAPI d3drm_frame2_SetSceneFogMode(IDirect3DRMFrame2 *iface, D3DRMFOGMODE mode)
 985 {
 986     FIXME("iface %p, mode %#x stub!\n", iface, mode);
 987
 988     return E_NOTIMPL;
 989 }
 990
 991 static HRESULT WINAPI d3drm_frame2_SetSceneFogParams(IDirect3DRMFrame2 *iface,
 992         D3DVALUE start, D3DVALUE end, D3DVALUE density)
 993 {
 994     FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
 995
 996     return E_NOTIMPL;
 997 }
 998
 999 static HRESULT WINAPI d3drm_frame2_SetColor(IDirect3DRMFrame2 *iface, D3DCOLOR color)
1000 {
1001     FIXME("iface %p, color 0x%08x stub!\n", iface, color);
1002
1003     return E_NOTIMPL;
1004 }
1005
1006 static HRESULT WINAPI d3drm_frame2_SetColorRGB(IDirect3DRMFrame2 *iface,
1007         D3DVALUE red, D3DVALUE green, D3DVALUE blue)
1008 {
1009     FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
1010
1011     return E_NOTIMPL;
1012 }
1013
1014 static D3DRMZBUFFERMODE WINAPI d3drm_frame2_GetZbufferMode(IDirect3DRMFrame2 *iface)
1015 {
1016     FIXME("iface %p stub!\n", iface);
1017
1018     return D3DRMZBUFFER_FROMPARENT;
1019 }
1020
1021 static HRESULT WINAPI d3drm_frame2_SetMaterialMode(IDirect3DRMFrame2 *iface, D3DRMMATERIALMODE mode)
1022 {
1023     FIXME("iface %p, mode %#x stub!\n", iface, mode);
1024
1025     return E_NOTIMPL;
1026 }
1027
1028 static HRESULT WINAPI d3drm_frame2_SetOrientation(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *reference,
1029         D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
1030 {
1031     FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
1032             iface, reference, dx, dy, dz, ux, uy, uz);
1033
1034     return E_NOTIMPL;
1035 }
1036
1037 static HRESULT WINAPI d3drm_frame2_SetPosition(IDirect3DRMFrame2 *iface,
1038         IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1039 {
1040     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
1041
1042     return E_NOTIMPL;
1043 }
1044
1045 static HRESULT WINAPI d3drm_frame2_SetRotation(IDirect3DRMFrame2 *iface,
1046         IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1047 {
1048     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
1049             iface, reference, x, y, z, theta);
1050
1051     return E_NOTIMPL;
1052 }
1053
1054 static HRESULT WINAPI d3drm_frame2_SetSortMode(IDirect3DRMFrame2 *iface, D3DRMSORTMODE mode)
1055 {
1056     FIXME("iface %p, mode %#x stub!\n", iface, mode);
1057
1058     return E_NOTIMPL;
1059 }
1060
1061 static HRESULT WINAPI d3drm_frame2_SetTexture(IDirect3DRMFrame2 *iface, IDirect3DRMTexture *texture)
1062 {
1063     FIXME("iface %p, texture %p stub!\n", iface, texture);
1064
1065     return E_NOTIMPL;
1066 }
1067
1068 static HRESULT WINAPI d3drm_frame2_SetTextureTopology(IDirect3DRMFrame2 *iface, BOOL wrap_u, BOOL wrap_v)
1069 {
1070     FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
1071
1072     return E_NOTIMPL;
1073 }
1074
1075 static HRESULT WINAPI d3drm_frame2_SetVelocity(IDirect3DRMFrame2 *iface,
1076         IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
1077 {
1078     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x stub!\n",
1079             iface, reference, x, y, z, with_rotation);
1080
1081     return E_NOTIMPL;
1082 }
1083
1084 static HRESULT WINAPI d3drm_frame2_SetZbufferMode(IDirect3DRMFrame2 *iface, D3DRMZBUFFERMODE mode)
1085 {
1086     FIXME("iface %p, mode %#x stub!\n", iface, mode);
1087
1088     return E_NOTIMPL;
1089 }
1090
1091 static HRESULT WINAPI d3drm_frame2_Transform(IDirect3DRMFrame2 *iface, D3DVECTOR *d, D3DVECTOR *s)
1092 {
1093     FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1094
1095     return E_NOTIMPL;
1096 }
1097
1098 static HRESULT WINAPI d3drm_frame2_AddMoveCallback2(IDirect3DRMFrame2 *iface,
1099         D3DRMFRAMEMOVECALLBACK cb, void *ctx, DWORD flags)
1100 {
1101     FIXME("iface %p, cb %p, ctx %p, flags %#x stub!\n", iface, cb, ctx, flags);
1102
1103     return E_NOTIMPL;
1104 }
1105
1106 static HRESULT WINAPI d3drm_frame2_GetBox(IDirect3DRMFrame2 *iface, D3DRMBOX *box)
1107 {
1108     FIXME("iface %p, box %p stub!\n", iface, box);
1109
1110     return E_NOTIMPL;
1111 }
1112
1113 static BOOL WINAPI d3drm_frame2_GetBoxEnable(IDirect3DRMFrame2 *iface)
1114 {
1115     FIXME("iface %p stub!\n", iface);
1116
1117     return E_NOTIMPL;
1118 }
1119
1120 static HRESULT WINAPI d3drm_frame2_GetAxes(IDirect3DRMFrame2 *iface, D3DVECTOR *dir, D3DVECTOR *up)
1121 {
1122     FIXME("iface %p, dir %p, up %p stub!\n", iface, dir, up);
1123
1124     return E_NOTIMPL;
1125 }
1126
1127 static HRESULT WINAPI d3drm_frame2_GetMaterial(IDirect3DRMFrame2 *iface, IDirect3DRMMaterial **material)
1128 {
1129     FIXME("iface %p, material %p stub!\n", iface, material);
1130
1131     return E_NOTIMPL;
1132 }
1133
1134 static BOOL WINAPI d3drm_frame2_GetInheritAxes(IDirect3DRMFrame2 *iface)
1135 {
1136     FIXME("iface %p stub!\n", iface);
1137
1138     return E_NOTIMPL;
1139 }
1140
1141 static HRESULT WINAPI d3drm_frame2_GetHierarchyBox(IDirect3DRMFrame2 *iface, D3DRMBOX *box)
1142 {
1143     FIXME("iface %p, box %p stub!\n", iface, box);
1144
1145     return E_NOTIMPL;
1146 }
1147
1148 static const struct IDirect3DRMFrame2Vtbl d3drm_frame2_vtbl =
1149 {
1150     d3drm_frame2_QueryInterface,
1151     d3drm_frame2_AddRef,
1152     d3drm_frame2_Release,
1153     d3drm_frame2_Clone,
1154     d3drm_frame2_AddDestroyCallback,
1155     d3drm_frame2_DeleteDestroyCallback,
1156     d3drm_frame2_SetAppData,
1157     d3drm_frame2_GetAppData,
1158     d3drm_frame2_SetName,
1159     d3drm_frame2_GetName,
1160     d3drm_frame2_GetClassName,
1161     d3drm_frame2_AddChild,
1162     d3drm_frame2_AddLight,
1163     d3drm_frame2_AddMoveCallback,
1164     d3drm_frame2_AddTransform,
1165     d3drm_frame2_AddTranslation,
1166     d3drm_frame2_AddScale,
1167     d3drm_frame2_AddRotation,
1168     d3drm_frame2_AddVisual,
1169     d3drm_frame2_GetChildren,
1170     d3drm_frame2_GetColor,
1171     d3drm_frame2_GetLights,
1172     d3drm_frame2_GetMaterialMode,
1173     d3drm_frame2_GetParent,
1174     d3drm_frame2_GetPosition,
1175     d3drm_frame2_GetRotation,
1176     d3drm_frame2_GetScene,
1177     d3drm_frame2_GetSortMode,
1178     d3drm_frame2_GetTexture,
1179     d3drm_frame2_GetTransform,
1180     d3drm_frame2_GetVelocity,
1181     d3drm_frame2_GetOrientation,
1182     d3drm_frame2_GetVisuals,
1183     d3drm_frame2_GetTextureTopology,
1184     d3drm_frame2_InverseTransform,
1185     d3drm_frame2_Load,
1186     d3drm_frame2_LookAt,
1187     d3drm_frame2_Move,
1188     d3drm_frame2_DeleteChild,
1189     d3drm_frame2_DeleteLight,
1190     d3drm_frame2_DeleteMoveCallback,
1191     d3drm_frame2_DeleteVisual,
1192     d3drm_frame2_GetSceneBackground,
1193     d3drm_frame2_GetSceneBackgroundDepth,
1194     d3drm_frame2_GetSceneFogColor,
1195     d3drm_frame2_GetSceneFogEnable,
1196     d3drm_frame2_GetSceneFogMode,
1197     d3drm_frame2_GetSceneFogParams,
1198     d3drm_frame2_SetSceneBackground,
1199     d3drm_frame2_SetSceneBackgroundRGB,
1200     d3drm_frame2_SetSceneBackgroundDepth,
1201     d3drm_frame2_SetSceneBackgroundImage,
1202     d3drm_frame2_SetSceneFogEnable,
1203     d3drm_frame2_SetSceneFogColor,
1204     d3drm_frame2_SetSceneFogMode,
1205     d3drm_frame2_SetSceneFogParams,
1206     d3drm_frame2_SetColor,
1207     d3drm_frame2_SetColorRGB,
1208     d3drm_frame2_GetZbufferMode,
1209     d3drm_frame2_SetMaterialMode,
1210     d3drm_frame2_SetOrientation,
1211     d3drm_frame2_SetPosition,
1212     d3drm_frame2_SetRotation,
1213     d3drm_frame2_SetSortMode,
1214     d3drm_frame2_SetTexture,
1215     d3drm_frame2_SetTextureTopology,
1216     d3drm_frame2_SetVelocity,
1217     d3drm_frame2_SetZbufferMode,
1218     d3drm_frame2_Transform,
1219     d3drm_frame2_AddMoveCallback2,
1220     d3drm_frame2_GetBox,
1221     d3drm_frame2_GetBoxEnable,
1222     d3drm_frame2_GetAxes,
1223     d3drm_frame2_GetMaterial,
1224     d3drm_frame2_GetInheritAxes,
1225     d3drm_frame2_GetHierarchyBox,
1226 };
1227
1228 static HRESULT WINAPI d3drm_frame3_QueryInterface(IDirect3DRMFrame3 *iface, REFIID riid, void **out)
1229 {
1230     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1231
1232     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
1233
1234     return d3drm_frame2_QueryInterface(&frame->IDirect3DRMFrame2_iface, riid, out);
1235 }
1236
1237 static ULONG WINAPI d3drm_frame3_AddRef(IDirect3DRMFrame3 *iface)
1238 {
1239     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1240
1241     TRACE("iface %p.\n", iface);
1242
1243     return d3drm_frame2_AddRef(&frame->IDirect3DRMFrame2_iface);
1244 }
1245
1246 static ULONG WINAPI d3drm_frame3_Release(IDirect3DRMFrame3 *iface)
1247 {
1248     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1249
1250     TRACE("iface %p.\n", iface);
1251
1252     return d3drm_frame2_Release(&frame->IDirect3DRMFrame2_iface);
1253 }
1254
1255 static HRESULT WINAPI d3drm_frame3_Clone(IDirect3DRMFrame3 *iface,
1256         IUnknown *outer, REFIID iid, void **out)
1257 {
1258     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
1259
1260     return E_NOTIMPL;
1261 }
1262
1263 static HRESULT WINAPI d3drm_frame3_AddDestroyCallback(IDirect3DRMFrame3 *iface,
1264         D3DRMOBJECTCALLBACK cb, void *ctx)
1265 {
1266     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1267
1268     return E_NOTIMPL;
1269 }
1270
1271 static HRESULT WINAPI d3drm_frame3_DeleteDestroyCallback(IDirect3DRMFrame3 *iface,
1272         D3DRMOBJECTCALLBACK cb, void *ctx)
1273 {
1274     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1275
1276     return E_NOTIMPL;
1277 }
1278
1279 static HRESULT WINAPI d3drm_frame3_SetAppData(IDirect3DRMFrame3 *iface, DWORD data)
1280 {
1281     FIXME("iface %p, data %#x stub!\n", iface, data);
1282
1283     return E_NOTIMPL;
1284 }
1285
1286 static DWORD WINAPI d3drm_frame3_GetAppData(IDirect3DRMFrame3 *iface)
1287 {
1288     FIXME("iface %p stub!\n", iface);
1289
1290     return 0;
1291 }
1292
1293 static HRESULT WINAPI d3drm_frame3_SetName(IDirect3DRMFrame3 *iface, const char *name)
1294 {
1295     FIXME("iface %p, name %s stub!\n", iface, debugstr_a(name));
1296
1297     return E_NOTIMPL;
1298 }
1299
1300 static HRESULT WINAPI d3drm_frame3_GetName(IDirect3DRMFrame3 *iface, DWORD *size, char *name)
1301 {
1302     FIXME("iface %p, size %p, name %p stub!\n", iface, size, name);
1303
1304     return E_NOTIMPL;
1305 }
1306
1307 static HRESULT WINAPI d3drm_frame3_GetClassName(IDirect3DRMFrame3 *iface, DWORD *size, char *name)
1308 {
1309     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
1310
1311     if (!size || *size < strlen("Frame") || !name)
1312         return E_INVALIDARG;
1313
1314     strcpy(name, "Frame");
1315     *size = sizeof("Frame");
1316
1317     return D3DRM_OK;
1318 }
1319
1320 static HRESULT WINAPI d3drm_frame3_AddChild(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *child)
1321 {
1322     struct d3drm_frame *This = impl_from_IDirect3DRMFrame3(iface);
1323     struct d3drm_frame *child_obj = unsafe_impl_from_IDirect3DRMFrame3(child);
1324
1325     TRACE("iface %p, child %p.\n", iface, child);
1326
1327     if (!child_obj)
1328         return D3DRMERR_BADOBJECT;
1329
1330     if (child_obj->parent)
1331     {
1332         IDirect3DRMFrame3* parent = &child_obj->parent->IDirect3DRMFrame3_iface;
1333
1334         if (parent == iface)
1335         {
1336             /* Passed frame is already a child so return success */
1337             return D3DRM_OK;
1338         }
1339         else
1340         {
1341             /* Remove parent and continue */
1342             IDirect3DRMFrame3_DeleteChild(parent, child);
1343         }
1344     }
1345
1346     if ((This->nb_children + 1) > This->children_capacity)
1347     {
1348         ULONG new_capacity;
1349         IDirect3DRMFrame3** children;
1350
1351         if (!This->children_capacity)
1352         {
1353             new_capacity = 16;
1354             children = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMFrame3*));
1355         }
1356         else
1357         {
1358             new_capacity = This->children_capacity * 2;
1359             children = HeapReAlloc(GetProcessHeap(), 0, This->children, new_capacity * sizeof(IDirect3DRMFrame3*));
1360         }
1361
1362         if (!children)
1363             return E_OUTOFMEMORY;
1364
1365         This->children_capacity = new_capacity;
1366         This->children = children;
1367     }
1368
1369     This->children[This->nb_children++] = child;
1370     IDirect3DRMFrame3_AddRef(child);
1371     child_obj->parent = This;
1372
1373     return D3DRM_OK;
1374 }
1375
1376 static HRESULT WINAPI d3drm_frame3_AddLight(IDirect3DRMFrame3 *iface, IDirect3DRMLight *light)
1377 {
1378     struct d3drm_frame *This = impl_from_IDirect3DRMFrame3(iface);
1379     ULONG i;
1380     IDirect3DRMLight** lights;
1381
1382     TRACE("iface %p, light %p.\n", iface, light);
1383
1384     if (!light)
1385         return D3DRMERR_BADOBJECT;
1386
1387     /* Check if already existing and return gracefully without increasing ref count */
1388     for (i = 0; i < This->nb_lights; i++)
1389         if (This->lights[i] == light)
1390             return D3DRM_OK;
1391
1392     if ((This->nb_lights + 1) > This->lights_capacity)
1393     {
1394         ULONG new_capacity;
1395
1396         if (!This->lights_capacity)
1397         {
1398             new_capacity = 16;
1399             lights = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMLight*));
1400         }
1401         else
1402         {
1403             new_capacity = This->lights_capacity * 2;
1404             lights = HeapReAlloc(GetProcessHeap(), 0, This->lights, new_capacity * sizeof(IDirect3DRMLight*));
1405         }
1406
1407         if (!lights)
1408             return E_OUTOFMEMORY;
1409
1410         This->lights_capacity = new_capacity;
1411         This->lights = lights;
1412     }
1413
1414     This->lights[This->nb_lights++] = light;
1415     IDirect3DRMLight_AddRef(light);
1416
1417     return D3DRM_OK;
1418 }
1419
1420 static HRESULT WINAPI d3drm_frame3_AddMoveCallback(IDirect3DRMFrame3 *iface,
1421         D3DRMFRAME3MOVECALLBACK cb, void *ctx, DWORD flags)
1422 {
1423     FIXME("iface %p, cb %p, ctx %p flags %#x stub!\n", iface, cb, ctx, flags);
1424
1425     return E_NOTIMPL;
1426 }
1427
1428 static HRESULT WINAPI d3drm_frame3_AddTransform(IDirect3DRMFrame3 *iface,
1429         D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
1430 {
1431     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1432
1433     TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
1434
1435     switch (type)
1436     {
1437         case D3DRMCOMBINE_REPLACE:
1438             memcpy(frame->transform, matrix, sizeof(D3DRMMATRIX4D));
1439             break;
1440
1441         case D3DRMCOMBINE_BEFORE:
1442             FIXME("D3DRMCOMBINE_BEFORE not supported yet\n");
1443             break;
1444
1445         case D3DRMCOMBINE_AFTER:
1446             FIXME("D3DRMCOMBINE_AFTER not supported yet\n");
1447             break;
1448
1449         default:
1450             WARN("Unknown Combine Type %u\n", type);
1451             return D3DRMERR_BADVALUE;
1452     }
1453
1454     return S_OK;
1455 }
1456
1457 static HRESULT WINAPI d3drm_frame3_AddTranslation(IDirect3DRMFrame3 *iface,
1458         D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1459 {
1460     FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e stub!\n", iface, type, x, y, z);
1461
1462     return E_NOTIMPL;
1463 }
1464
1465 static HRESULT WINAPI d3drm_frame3_AddScale(IDirect3DRMFrame3 *iface,
1466         D3DRMCOMBINETYPE type, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1467 {
1468     FIXME("iface %p, type %#x, sx %.8e, sy %.8e, sz %.8e stub!\n", iface, type, sx, sy, sz);
1469
1470     return E_NOTIMPL;
1471 }
1472
1473 static HRESULT WINAPI d3drm_frame3_AddRotation(IDirect3DRMFrame3 *iface,
1474         D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1475 {
1476     FIXME("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
1477             iface, type, x, y, z, theta);
1478
1479     return E_NOTIMPL;
1480 }
1481
1482 static HRESULT WINAPI d3drm_frame3_AddVisual(IDirect3DRMFrame3 *iface, IUnknown *visual)
1483 {
1484     struct d3drm_frame *This = impl_from_IDirect3DRMFrame3(iface);
1485     ULONG i;
1486     IDirect3DRMVisual** visuals;
1487
1488     TRACE("iface %p, visual %p.\n", iface, visual);
1489
1490     if (!visual)
1491         return D3DRMERR_BADOBJECT;
1492
1493     /* Check if already existing and return gracefully without increasing ref count */
1494     for (i = 0; i < This->nb_visuals; i++)
1495         if (This->visuals[i] == (IDirect3DRMVisual *)visual)
1496             return D3DRM_OK;
1497
1498     if ((This->nb_visuals + 1) > This->visuals_capacity)
1499     {
1500         ULONG new_capacity;
1501
1502         if (!This->visuals_capacity)
1503         {
1504             new_capacity = 16;
1505             visuals = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMVisual*));
1506         }
1507         else
1508         {
1509             new_capacity = This->visuals_capacity * 2;
1510             visuals = HeapReAlloc(GetProcessHeap(), 0, This->visuals, new_capacity * sizeof(IDirect3DRMVisual*));
1511         }
1512
1513         if (!visuals)
1514             return E_OUTOFMEMORY;
1515
1516         This->visuals_capacity = new_capacity;
1517         This->visuals = visuals;
1518     }
1519
1520     This->visuals[This->nb_visuals++] = (IDirect3DRMVisual *)visual;
1521     IDirect3DRMVisual_AddRef(visual);
1522
1523     return D3DRM_OK;
1524 }
1525
1526 static HRESULT WINAPI d3drm_frame3_GetChildren(IDirect3DRMFrame3 *iface, IDirect3DRMFrameArray **children)
1527 {
1528     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1529     struct d3drm_frame_array *array;
1530
1531     TRACE("iface %p, children %p.\n", iface, children);
1532
1533     if (!children)
1534         return D3DRMERR_BADVALUE;
1535
1536     if (!(array = d3drm_frame_array_create(frame->nb_children, frame->children)))
1537         return E_OUTOFMEMORY;
1538
1539     *children = &array->IDirect3DRMFrameArray_iface;
1540
1541     return D3DRM_OK;
1542 }
1543
1544 static D3DCOLOR WINAPI d3drm_frame3_GetColor(IDirect3DRMFrame3 *iface)
1545 {
1546     FIXME("iface %p stub!\n", iface);
1547
1548     return 0;
1549 }
1550
1551 static HRESULT WINAPI d3drm_frame3_GetLights(IDirect3DRMFrame3 *iface, IDirect3DRMLightArray **lights)
1552 {
1553     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1554     struct d3drm_light_array *array;
1555
1556     TRACE("iface %p, lights %p.\n", iface, lights);
1557
1558     if (!lights)
1559         return D3DRMERR_BADVALUE;
1560
1561     if (!(array = d3drm_light_array_create(frame->nb_lights, frame->lights)))
1562         return E_OUTOFMEMORY;
1563
1564     *lights = &array->IDirect3DRMLightArray_iface;
1565
1566     return D3DRM_OK;
1567 }
1568
1569 static D3DRMMATERIALMODE WINAPI d3drm_frame3_GetMaterialMode(IDirect3DRMFrame3 *iface)
1570 {
1571     FIXME("iface %p stub!\n", iface);
1572
1573     return D3DRMMATERIAL_FROMPARENT;
1574 }
1575
1576 static HRESULT WINAPI d3drm_frame3_GetParent(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 **parent)
1577 {
1578     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1579
1580     TRACE("iface %p, parent %p.\n", iface, parent);
1581
1582     if (!parent)
1583         return D3DRMERR_BADVALUE;
1584
1585     if (frame->parent)
1586     {
1587         *parent = &frame->parent->IDirect3DRMFrame3_iface;
1588         IDirect3DRMFrame_AddRef(*parent);
1589     }
1590     else
1591     {
1592         *parent = NULL;
1593     }
1594
1595     return D3DRM_OK;
1596 }
1597
1598 static HRESULT WINAPI d3drm_frame3_GetPosition(IDirect3DRMFrame3 *iface,
1599         IDirect3DRMFrame3 *reference, D3DVECTOR *position)
1600 {
1601     FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1602
1603     return E_NOTIMPL;
1604 }
1605
1606 static HRESULT WINAPI d3drm_frame3_GetRotation(IDirect3DRMFrame3 *iface,
1607         IDirect3DRMFrame3 *reference, D3DVECTOR *axis, D3DVALUE *theta)
1608 {
1609     FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1610
1611     return E_NOTIMPL;
1612 }
1613
1614 static HRESULT WINAPI d3drm_frame3_GetScene(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 **scene)
1615 {
1616     FIXME("iface %p, scene %p stub!\n", iface, scene);
1617
1618     return E_NOTIMPL;
1619 }
1620
1621 static D3DRMSORTMODE WINAPI d3drm_frame3_GetSortMode(IDirect3DRMFrame3 *iface)
1622 {
1623     FIXME("iface %p stub!\n", iface);
1624
1625     return D3DRMSORT_FROMPARENT;
1626 }
1627
1628 static HRESULT WINAPI d3drm_frame3_GetTexture(IDirect3DRMFrame3 *iface, IDirect3DRMTexture3 **texture)
1629 {
1630     FIXME("iface %p, texture %p stub!\n", iface, texture);
1631
1632     return E_NOTIMPL;
1633 }
1634
1635 static HRESULT WINAPI d3drm_frame3_GetTransform(IDirect3DRMFrame3 *iface,
1636         IDirect3DRMFrame3 *reference, D3DRMMATRIX4D matrix)
1637 {
1638     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1639
1640     TRACE("iface %p, reference %p, matrix %p.\n", iface, reference, matrix);
1641
1642     if (reference)
1643         FIXME("Specifying a frame as the root of the scene different from the current root frame is not supported yet\n");
1644
1645     memcpy(matrix, frame->transform, sizeof(D3DRMMATRIX4D));
1646
1647     return D3DRM_OK;
1648 }
1649
1650 static HRESULT WINAPI d3drm_frame3_GetVelocity(IDirect3DRMFrame3 *iface,
1651         IDirect3DRMFrame3 *reference, D3DVECTOR *velocity, BOOL with_rotation)
1652 {
1653     FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1654             iface, reference, velocity, with_rotation);
1655
1656     return E_NOTIMPL;
1657 }
1658
1659 static HRESULT WINAPI d3drm_frame3_GetOrientation(IDirect3DRMFrame3 *iface,
1660         IDirect3DRMFrame3 *reference, D3DVECTOR *dir, D3DVECTOR *up)
1661 {
1662     FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1663
1664     return E_NOTIMPL;
1665 }
1666
1667 static HRESULT WINAPI d3drm_frame3_GetVisuals(IDirect3DRMFrame3 *iface,
1668         DWORD *count, IUnknown **visuals)
1669 {
1670     FIXME("iface %p, count %p, visuals %p stub!\n", iface, count, visuals);
1671
1672     return E_NOTIMPL;
1673 }
1674
1675 static HRESULT WINAPI d3drm_frame3_InverseTransform(IDirect3DRMFrame3 *iface, D3DVECTOR *d, D3DVECTOR *s)
1676 {
1677     FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1678
1679     return E_NOTIMPL;
1680 }
1681
1682 static HRESULT WINAPI d3drm_frame3_Load(IDirect3DRMFrame3 *iface, void *filename,
1683         void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURE3CALLBACK cb, void *ctx)
1684 {
1685     FIXME("iface %p, filename %p, name %p, flags %#x, cb %p, ctx %p stub!\n",
1686             iface, filename, name, flags, cb, ctx);
1687
1688     return E_NOTIMPL;
1689 }
1690
1691 static HRESULT WINAPI d3drm_frame3_LookAt(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *target,
1692         IDirect3DRMFrame3 *reference, D3DRMFRAMECONSTRAINT constraint)
1693 {
1694     FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1695
1696     return E_NOTIMPL;
1697 }
1698
1699 static HRESULT WINAPI d3drm_frame3_Move(IDirect3DRMFrame3 *iface, D3DVALUE delta)
1700 {
1701     FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1702
1703     return E_NOTIMPL;
1704 }
1705
1706 static HRESULT WINAPI d3drm_frame3_DeleteChild(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *child)
1707 {
1708     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1709     struct d3drm_frame *child_impl = unsafe_impl_from_IDirect3DRMFrame3(child);
1710     ULONG i;
1711
1712     TRACE("iface %p, child %p.\n", iface, child);
1713
1714     if (!child_impl)
1715         return D3DRMERR_BADOBJECT;
1716
1717     /* Check if child exists */
1718     for (i = 0; i < frame->nb_children; ++i)
1719     {
1720         if (frame->children[i] == child)
1721             break;
1722     }
1723
1724     if (i == frame->nb_children)
1725         return D3DRMERR_BADVALUE;
1726
1727     memmove(frame->children + i, frame->children + i + 1, sizeof(*frame->children) * (frame->nb_children - 1 - i));
1728     IDirect3DRMFrame3_Release(child);
1729     child_impl->parent = NULL;
1730     --frame->nb_children;
1731
1732     return D3DRM_OK;
1733 }
1734
1735 static HRESULT WINAPI d3drm_frame3_DeleteLight(IDirect3DRMFrame3 *iface, IDirect3DRMLight *light)
1736 {
1737     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1738     ULONG i;
1739
1740     TRACE("iface %p, light %p.\n", iface, light);
1741
1742     if (!light)
1743         return D3DRMERR_BADOBJECT;
1744
1745     /* Check if visual exists */
1746     for (i = 0; i < frame->nb_lights; ++i)
1747     {
1748         if (frame->lights[i] == light)
1749             break;
1750     }
1751
1752     if (i == frame->nb_lights)
1753         return D3DRMERR_BADVALUE;
1754
1755     memmove(frame->lights + i, frame->lights + i + 1, sizeof(*frame->lights) * (frame->nb_lights - 1 - i));
1756     IDirect3DRMLight_Release(light);
1757     --frame->nb_lights;
1758
1759     return D3DRM_OK;
1760 }
1761
1762 static HRESULT WINAPI d3drm_frame3_DeleteMoveCallback(IDirect3DRMFrame3 *iface,
1763         D3DRMFRAME3MOVECALLBACK cb, void *ctx)
1764 {
1765     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1766
1767     return E_NOTIMPL;
1768 }
1769
1770 static HRESULT WINAPI d3drm_frame3_DeleteVisual(IDirect3DRMFrame3 *iface, IUnknown *visual)
1771 {
1772     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1773     ULONG i;
1774
1775     TRACE("iface %p, visual %p.\n", iface, visual);
1776
1777     if (!visual)
1778         return D3DRMERR_BADOBJECT;
1779
1780     /* Check if visual exists */
1781     for (i = 0; i < frame->nb_visuals; ++i)
1782     {
1783         if (frame->visuals[i] == (IDirect3DRMVisual *)visual)
1784             break;
1785     }
1786
1787     if (i == frame->nb_visuals)
1788         return D3DRMERR_BADVALUE;
1789
1790     memmove(frame->visuals + i, frame->visuals + i + 1, sizeof(*frame->visuals) * (frame->nb_visuals - 1 - i));
1791     IDirect3DRMVisual_Release(visual);
1792     --frame->nb_visuals;
1793
1794     return D3DRM_OK;
1795 }
1796
1797 static D3DCOLOR WINAPI d3drm_frame3_GetSceneBackground(IDirect3DRMFrame3 *iface)
1798 {
1799     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1800
1801     TRACE("iface %p.\n", iface);
1802
1803     return frame->scenebackground;
1804 }
1805
1806 static HRESULT WINAPI d3drm_frame3_GetSceneBackgroundDepth(IDirect3DRMFrame3 *iface,
1807         IDirectDrawSurface **surface)
1808 {
1809     FIXME("iface %p, surface %p stub!\n", iface, surface);
1810
1811     return E_NOTIMPL;
1812 }
1813
1814 static D3DCOLOR WINAPI d3drm_frame3_GetSceneFogColor(IDirect3DRMFrame3 *iface)
1815 {
1816     FIXME("iface %p stub!\n", iface);
1817
1818     return 0;
1819 }
1820
1821 static BOOL WINAPI d3drm_frame3_GetSceneFogEnable(IDirect3DRMFrame3 *iface)
1822 {
1823     FIXME("iface %p stub!\n", iface);
1824
1825     return FALSE;
1826 }
1827
1828 static D3DRMFOGMODE WINAPI d3drm_frame3_GetSceneFogMode(IDirect3DRMFrame3 *iface)
1829 {
1830     FIXME("iface %p stub!\n", iface);
1831
1832     return D3DRMFOG_LINEAR;
1833 }
1834
1835 static HRESULT WINAPI d3drm_frame3_GetSceneFogParams(IDirect3DRMFrame3 *iface,
1836         D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
1837 {
1838     FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
1839
1840     return E_NOTIMPL;
1841 }
1842
1843 static HRESULT WINAPI d3drm_frame3_SetSceneBackground(IDirect3DRMFrame3 *iface, D3DCOLOR color)
1844 {
1845     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1846
1847     TRACE("iface %p, color 0x%08x.\n", iface, color);
1848
1849     frame->scenebackground = color;
1850
1851     return D3DRM_OK;
1852 }
1853
1854 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundRGB(IDirect3DRMFrame3 *iface,
1855         D3DVALUE red, D3DVALUE green, D3DVALUE blue)
1856 {
1857     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1858
1859     TRACE("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
1860
1861     frame->scenebackground = RGBA_MAKE((BYTE)(red * 255.0f),
1862             (BYTE)(green * 255.0f), (BYTE)(blue * 255.0f), 0xff);
1863
1864     return D3DRM_OK;
1865 }
1866
1867 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundDepth(IDirect3DRMFrame3 *iface,
1868         IDirectDrawSurface *surface)
1869 {
1870     FIXME("iface %p, surface %p stub!\n", iface, surface);
1871
1872     return E_NOTIMPL;
1873 }
1874
1875 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundImage(IDirect3DRMFrame3 *iface,
1876         IDirect3DRMTexture3 *texture)
1877 {
1878     FIXME("iface %p, texture %p stub!\n", iface, texture);
1879
1880     return E_NOTIMPL;
1881 }
1882
1883 static HRESULT WINAPI d3drm_frame3_SetSceneFogEnable(IDirect3DRMFrame3 *iface, BOOL enable)
1884 {
1885     FIXME("iface %p, enable %#x stub!\n", iface, enable);
1886
1887     return E_NOTIMPL;
1888 }
1889
1890 static HRESULT WINAPI d3drm_frame3_SetSceneFogColor(IDirect3DRMFrame3 *iface, D3DCOLOR color)
1891 {
1892     FIXME("iface %p, color 0x%08x stub!\n", iface, color);
1893
1894     return E_NOTIMPL;
1895 }
1896
1897 static HRESULT WINAPI d3drm_frame3_SetSceneFogMode(IDirect3DRMFrame3 *iface, D3DRMFOGMODE mode)
1898 {
1899     FIXME("iface %p, mode %#x stub!\n", iface, mode);
1900
1901     return E_NOTIMPL;
1902 }
1903
1904 static HRESULT WINAPI d3drm_frame3_SetSceneFogParams(IDirect3DRMFrame3 *iface,
1905         D3DVALUE start, D3DVALUE end, D3DVALUE density)
1906 {
1907     FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
1908
1909     return E_NOTIMPL;
1910 }
1911
1912 static HRESULT WINAPI d3drm_frame3_SetColor(IDirect3DRMFrame3 *iface, D3DCOLOR color)
1913 {
1914     FIXME("iface %p, color 0x%08x stub!\n", iface, color);
1915
1916     return E_NOTIMPL;
1917 }
1918
1919 static HRESULT WINAPI d3drm_frame3_SetColorRGB(IDirect3DRMFrame3 *iface,
1920         D3DVALUE red, D3DVALUE green, D3DVALUE blue)
1921 {
1922     FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
1923
1924     return E_NOTIMPL;
1925 }
1926
1927 static D3DRMZBUFFERMODE WINAPI d3drm_frame3_GetZbufferMode(IDirect3DRMFrame3 *iface)
1928 {
1929     FIXME("iface %p stub!\n", iface);
1930
1931     return D3DRMZBUFFER_FROMPARENT;
1932 }
1933
1934 static HRESULT WINAPI d3drm_frame3_SetMaterialMode(IDirect3DRMFrame3 *iface, D3DRMMATERIALMODE mode)
1935 {
1936     FIXME("iface %p, mode %#x stub!\n", iface, mode);
1937
1938     return E_NOTIMPL;
1939 }
1940
1941 static HRESULT WINAPI d3drm_frame3_SetOrientation(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *reference,
1942         D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
1943 {
1944     FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
1945             iface, reference, dx, dy, dz, ux, uy, uz);
1946
1947     return E_NOTIMPL;
1948 }
1949
1950 static HRESULT WINAPI d3drm_frame3_SetPosition(IDirect3DRMFrame3 *iface,
1951         IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1952 {
1953     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
1954
1955     return E_NOTIMPL;
1956 }
1957
1958 static HRESULT WINAPI d3drm_frame3_SetRotation(IDirect3DRMFrame3 *iface,
1959         IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1960 {
1961     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
1962             iface, reference, x, y, z, theta);
1963
1964     return E_NOTIMPL;
1965 }
1966
1967 static HRESULT WINAPI d3drm_frame3_SetSortMode(IDirect3DRMFrame3 *iface, D3DRMSORTMODE mode)
1968 {
1969     FIXME("iface %p, mode %#x stub!\n", iface, mode);
1970
1971     return E_NOTIMPL;
1972 }
1973
1974 static HRESULT WINAPI d3drm_frame3_SetTexture(IDirect3DRMFrame3 *iface, IDirect3DRMTexture3 *texture)
1975 {
1976     FIXME("iface %p, texture %p stub!\n", iface, texture);
1977
1978     return E_NOTIMPL;
1979 }
1980
1981 static HRESULT WINAPI d3drm_frame3_SetVelocity(IDirect3DRMFrame3 *iface,
1982         IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
1983 {
1984     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x.\n",
1985             iface, reference, x, y, z, with_rotation);
1986
1987     return E_NOTIMPL;
1988 }
1989
1990 static HRESULT WINAPI d3drm_frame3_SetZbufferMode(IDirect3DRMFrame3 *iface, D3DRMZBUFFERMODE mode)
1991 {
1992     FIXME("iface %p, mode %#x stub!\n", iface, mode);
1993
1994     return E_NOTIMPL;
1995 }
1996
1997 static HRESULT WINAPI d3drm_frame3_Transform(IDirect3DRMFrame3 *iface, D3DVECTOR *d, D3DVECTOR *s)
1998 {
1999     FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
2000
2001     return E_NOTIMPL;
2002 }
2003
2004 static HRESULT WINAPI d3drm_frame3_GetBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2005 {
2006     FIXME("iface %p, box %p stub!\n", iface, box);
2007
2008     return E_NOTIMPL;
2009 }
2010
2011 static BOOL WINAPI d3drm_frame3_GetBoxEnable(IDirect3DRMFrame3 *iface)
2012 {
2013     FIXME("iface %p stub!\n", iface);
2014
2015     return E_NOTIMPL;
2016 }
2017
2018 static HRESULT WINAPI d3drm_frame3_GetAxes(IDirect3DRMFrame3 *iface, D3DVECTOR *dir, D3DVECTOR *up)
2019 {
2020     FIXME("iface %p, dir %p, up %p stub!\n", iface, dir, up);
2021
2022     return E_NOTIMPL;
2023 }
2024
2025 static HRESULT WINAPI d3drm_frame3_GetMaterial(IDirect3DRMFrame3 *iface, IDirect3DRMMaterial2 **material)
2026 {
2027     FIXME("iface %p, material %p stub!\n", iface, material);
2028
2029     return E_NOTIMPL;
2030 }
2031
2032 static BOOL WINAPI d3drm_frame3_GetInheritAxes(IDirect3DRMFrame3 *iface)
2033 {
2034     FIXME("iface %p stub!\n", iface);
2035
2036     return E_NOTIMPL;
2037 }
2038
2039 static HRESULT WINAPI d3drm_frame3_GetHierarchyBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2040 {
2041     FIXME("iface %p, box %p stub!\n", iface, box);
2042
2043     return E_NOTIMPL;
2044 }
2045
2046 static HRESULT WINAPI d3drm_frame3_SetBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2047 {
2048     FIXME("iface %p, box %p stub!\n", iface, box);
2049
2050     return E_NOTIMPL;
2051 }
2052
2053 static HRESULT WINAPI d3drm_frame3_SetBoxEnable(IDirect3DRMFrame3 *iface, BOOL enable)
2054 {
2055     FIXME("iface %p, enable %#x stub!\n", iface, enable);
2056
2057     return E_NOTIMPL;
2058 }
2059
2060 static HRESULT WINAPI d3drm_frame3_SetAxes(IDirect3DRMFrame3 *iface,
2061         D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2062 {
2063     FIXME("iface %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2064             iface, dx, dy, dz, ux, uy, uz);
2065
2066     return E_NOTIMPL;
2067 }
2068
2069 static HRESULT WINAPI d3drm_frame3_SetInheritAxes(IDirect3DRMFrame3 *iface, BOOL inherit)
2070 {
2071     FIXME("iface %p, inherit %#x stub!\n", iface, inherit);
2072
2073     return E_NOTIMPL;
2074 }
2075
2076 static HRESULT WINAPI d3drm_frame3_SetMaterial(IDirect3DRMFrame3 *iface, IDirect3DRMMaterial2 *material)
2077 {
2078     FIXME("iface %p, material %p stub!\n", iface, material);
2079
2080     return E_NOTIMPL;
2081 }
2082
2083 static HRESULT WINAPI d3drm_frame3_SetQuaternion(IDirect3DRMFrame3 *iface,
2084         IDirect3DRMFrame3 *reference, D3DRMQUATERNION *q)
2085 {
2086     FIXME("iface %p, reference %p, q %p stub!\n", iface, reference, q);
2087
2088     return E_NOTIMPL;
2089 }
2090
2091 static HRESULT WINAPI d3drm_frame3_RayPick(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *reference,
2092         D3DRMRAY *ray, DWORD flags, IDirect3DRMPicked2Array **visuals)
2093 {
2094     FIXME("iface %p, reference %p, ray %p, flags %#x, visuals %p stub!\n",
2095             iface, reference, ray, flags, visuals);
2096
2097     return E_NOTIMPL;
2098 }
2099
2100 static HRESULT WINAPI d3drm_frame3_Save(IDirect3DRMFrame3 *iface,
2101         const char *filename, D3DRMXOFFORMAT format, D3DRMSAVEOPTIONS flags)
2102 {
2103     FIXME("iface %p, filename %s, format %#x, flags %#x stub!\n",
2104             iface, debugstr_a(filename), format, flags);
2105
2106     return E_NOTIMPL;
2107 }
2108
2109 static HRESULT WINAPI d3drm_frame3_TransformVectors(IDirect3DRMFrame3 *iface,
2110         IDirect3DRMFrame3 *reference, DWORD num, D3DVECTOR *dst, D3DVECTOR *src)
2111 {
2112     FIXME("iface %p, reference %p, num %u, dst %p, src %p stub!\n", iface, reference, num, dst, src);
2113
2114     return E_NOTIMPL;
2115 }
2116
2117 static HRESULT WINAPI d3drm_frame3_InverseTransformVectors(IDirect3DRMFrame3 *iface,
2118         IDirect3DRMFrame3 *reference, DWORD num, D3DVECTOR *dst, D3DVECTOR *src)
2119 {
2120     FIXME("iface %p, reference %p, num %u, dst %p, src %p stub!\n", iface, reference, num, dst, src);
2121
2122     return E_NOTIMPL;
2123 }
2124
2125 static HRESULT WINAPI d3drm_frame3_SetTraversalOptions(IDirect3DRMFrame3 *iface, DWORD flags)
2126 {
2127     FIXME("iface %p, flags %#x stub!\n", iface, flags);
2128
2129     return E_NOTIMPL;
2130 }
2131
2132 static HRESULT WINAPI d3drm_frame3_GetTraversalOptions(IDirect3DRMFrame3 *iface, DWORD *flags)
2133 {
2134     FIXME("iface %p, flags %p stub!\n", iface, flags);
2135
2136     return E_NOTIMPL;
2137 }
2138
2139 static HRESULT WINAPI d3drm_frame3_SetSceneFogMethod(IDirect3DRMFrame3 *iface, DWORD flags)
2140 {
2141     FIXME("iface %p, flags %#x stub!\n", iface, flags);
2142
2143     return E_NOTIMPL;
2144 }
2145
2146 static HRESULT WINAPI d3drm_frame3_GetSceneFogMethod(IDirect3DRMFrame3 *iface, DWORD *fog_mode)
2147 {
2148     FIXME("iface %p, fog_mode %p stub!\n", iface, fog_mode);
2149
2150     return E_NOTIMPL;
2151 }
2152
2153 static HRESULT WINAPI d3drm_frame3_SetMaterialOverride(IDirect3DRMFrame3 *iface,
2154         D3DRMMATERIALOVERRIDE *override)
2155 {
2156     FIXME("iface %p, override %p stub!\n", iface, override);
2157
2158     return E_NOTIMPL;
2159 }
2160
2161 static HRESULT WINAPI d3drm_frame3_GetMaterialOverride(IDirect3DRMFrame3 *iface,
2162         D3DRMMATERIALOVERRIDE *override)
2163 {
2164     FIXME("iface %p, override %p stub!\n", iface, override);
2165
2166     return E_NOTIMPL;
2167 }
2168
2169 static const struct IDirect3DRMFrame3Vtbl d3drm_frame3_vtbl =
2170 {
2171     d3drm_frame3_QueryInterface,
2172     d3drm_frame3_AddRef,
2173     d3drm_frame3_Release,
2174     d3drm_frame3_Clone,
2175     d3drm_frame3_AddDestroyCallback,
2176     d3drm_frame3_DeleteDestroyCallback,
2177     d3drm_frame3_SetAppData,
2178     d3drm_frame3_GetAppData,
2179     d3drm_frame3_SetName,
2180     d3drm_frame3_GetName,
2181     d3drm_frame3_GetClassName,
2182     d3drm_frame3_AddChild,
2183     d3drm_frame3_AddLight,
2184     d3drm_frame3_AddMoveCallback,
2185     d3drm_frame3_AddTransform,
2186     d3drm_frame3_AddTranslation,
2187     d3drm_frame3_AddScale,
2188     d3drm_frame3_AddRotation,
2189     d3drm_frame3_AddVisual,
2190     d3drm_frame3_GetChildren,
2191     d3drm_frame3_GetColor,
2192     d3drm_frame3_GetLights,
2193     d3drm_frame3_GetMaterialMode,
2194     d3drm_frame3_GetParent,
2195     d3drm_frame3_GetPosition,
2196     d3drm_frame3_GetRotation,
2197     d3drm_frame3_GetScene,
2198     d3drm_frame3_GetSortMode,
2199     d3drm_frame3_GetTexture,
2200     d3drm_frame3_GetTransform,
2201     d3drm_frame3_GetVelocity,
2202     d3drm_frame3_GetOrientation,
2203     d3drm_frame3_GetVisuals,
2204     d3drm_frame3_InverseTransform,
2205     d3drm_frame3_Load,
2206     d3drm_frame3_LookAt,
2207     d3drm_frame3_Move,
2208     d3drm_frame3_DeleteChild,
2209     d3drm_frame3_DeleteLight,
2210     d3drm_frame3_DeleteMoveCallback,
2211     d3drm_frame3_DeleteVisual,
2212     d3drm_frame3_GetSceneBackground,
2213     d3drm_frame3_GetSceneBackgroundDepth,
2214     d3drm_frame3_GetSceneFogColor,
2215     d3drm_frame3_GetSceneFogEnable,
2216     d3drm_frame3_GetSceneFogMode,
2217     d3drm_frame3_GetSceneFogParams,
2218     d3drm_frame3_SetSceneBackground,
2219     d3drm_frame3_SetSceneBackgroundRGB,
2220     d3drm_frame3_SetSceneBackgroundDepth,
2221     d3drm_frame3_SetSceneBackgroundImage,
2222     d3drm_frame3_SetSceneFogEnable,
2223     d3drm_frame3_SetSceneFogColor,
2224     d3drm_frame3_SetSceneFogMode,
2225     d3drm_frame3_SetSceneFogParams,
2226     d3drm_frame3_SetColor,
2227     d3drm_frame3_SetColorRGB,
2228     d3drm_frame3_GetZbufferMode,
2229     d3drm_frame3_SetMaterialMode,
2230     d3drm_frame3_SetOrientation,
2231     d3drm_frame3_SetPosition,
2232     d3drm_frame3_SetRotation,
2233     d3drm_frame3_SetSortMode,
2234     d3drm_frame3_SetTexture,
2235     d3drm_frame3_SetVelocity,
2236     d3drm_frame3_SetZbufferMode,
2237     d3drm_frame3_Transform,
2238     d3drm_frame3_GetBox,
2239     d3drm_frame3_GetBoxEnable,
2240     d3drm_frame3_GetAxes,
2241     d3drm_frame3_GetMaterial,
2242     d3drm_frame3_GetInheritAxes,
2243     d3drm_frame3_GetHierarchyBox,
2244     d3drm_frame3_SetBox,
2245     d3drm_frame3_SetBoxEnable,
2246     d3drm_frame3_SetAxes,
2247     d3drm_frame3_SetInheritAxes,
2248     d3drm_frame3_SetMaterial,
2249     d3drm_frame3_SetQuaternion,
2250     d3drm_frame3_RayPick,
2251     d3drm_frame3_Save,
2252     d3drm_frame3_TransformVectors,
2253     d3drm_frame3_InverseTransformVectors,
2254     d3drm_frame3_SetTraversalOptions,
2255     d3drm_frame3_GetTraversalOptions,
2256     d3drm_frame3_SetSceneFogMethod,
2257     d3drm_frame3_GetSceneFogMethod,
2258     d3drm_frame3_SetMaterialOverride,
2259     d3drm_frame3_GetMaterialOverride,
2260 };
2261
2262 static inline struct d3drm_frame *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
2263 {
2264     if (!iface)
2265         return NULL;
2266     assert(iface->lpVtbl == &d3drm_frame3_vtbl);
2267
2268     return impl_from_IDirect3DRMFrame3(iface);
2269 }
2270
2271 HRESULT Direct3DRMFrame_create(REFIID riid, IUnknown *parent, IUnknown **out)
2272 {
2273     struct d3drm_frame *object;
2274     HRESULT hr;
2275
2276     TRACE("riid %s, parent %p, out %p.\n", debugstr_guid(riid), parent, out);
2277
2278     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2279         return E_OUTOFMEMORY;
2280
2281     object->IDirect3DRMFrame2_iface.lpVtbl = &d3drm_frame2_vtbl;
2282     object->IDirect3DRMFrame3_iface.lpVtbl = &d3drm_frame3_vtbl;
2283     object->ref = 1;
2284     object->scenebackground = RGBA_MAKE(0, 0, 0, 0xff);
2285
2286     memcpy(object->transform, identity, sizeof(D3DRMMATRIX4D));
2287
2288     if (parent)
2289     {
2290         IDirect3DRMFrame3 *p;
2291
2292         hr = IDirect3DRMFrame_QueryInterface(parent, &IID_IDirect3DRMFrame3, (void**)&p);
2293         if (hr != S_OK)
2294         {
2295             HeapFree(GetProcessHeap(), 0, object);
2296             return hr;
2297         }
2298         IDirect3DRMFrame_Release(parent);
2299         IDirect3DRMFrame3_AddChild(p, &object->IDirect3DRMFrame3_iface);
2300     }
2301
2302     hr = IDirect3DRMFrame3_QueryInterface(&object->IDirect3DRMFrame3_iface, riid, (void **)out);
2303     IDirect3DRMFrame3_Release(&object->IDirect3DRMFrame3_iface);
2304     return S_OK;
2305 }