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