git.oblomov.eu Git - wine/blob - dlls/d3drm/frame.c

   1 /*
   2  * Implementation of IDirect3DRMFrame Interface
   3  *
   4  * Copyright 2011, 2012 André Hentschel
   5  * Copyright 2012 Christian Costa
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <assert.h>
  23 #include "wine/debug.h"
  24
  25 #define COBJMACROS
  26
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29
  30 #include "d3drm_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(d3drm);
  33
  34 static D3DRMMATRIX4D identity = {
  35     { 1.0f, 0.0f, 0.0f, 0.0f },
  36     { 0.0f, 1.0f, 0.0f, 0.0f },
  37     { 0.0f, 0.0f, 1.0f, 0.0f },
  38     { 0.0f, 0.0f, 0.0f, 1.0f }
  39 };
  40
  41 typedef struct IDirect3DRMFrameImpl IDirect3DRMFrameImpl;
  42
  43 struct IDirect3DRMFrameImpl {
  44     IDirect3DRMFrame2 IDirect3DRMFrame2_iface;
  45     IDirect3DRMFrame3 IDirect3DRMFrame3_iface;
  46     LONG ref;
  47     IDirect3DRMFrameImpl* parent;
  48     ULONG nb_children;
  49     ULONG children_capacity;
  50     IDirect3DRMFrame3** children;
  51     ULONG nb_visuals;
  52     ULONG visuals_capacity;
  53     IDirect3DRMVisual** visuals;
  54     ULONG nb_lights;
  55     ULONG lights_capacity;
  56     IDirect3DRMLight** lights;
  57     D3DRMMATRIX4D transform;
  58 };
  59
  60 typedef struct {
  61     IDirect3DRMFrameArray IDirect3DRMFrameArray_iface;
  62     LONG ref;
  63     ULONG size;
  64     LPDIRECT3DRMFRAME* frames;
  65 } IDirect3DRMFrameArrayImpl;
  66
  67 typedef struct {
  68     IDirect3DRMVisualArray IDirect3DRMVisualArray_iface;
  69     LONG ref;
  70     ULONG size;
  71     LPDIRECT3DRMVISUAL* visuals;
  72 } IDirect3DRMVisualArrayImpl;
  73
  74 typedef struct {
  75     IDirect3DRMLightArray IDirect3DRMLightArray_iface;
  76     LONG ref;
  77     ULONG size;
  78     LPDIRECT3DRMLIGHT* lights;
  79 } IDirect3DRMLightArrayImpl;
  80
  81 HRESULT Direct3DRMFrameArray_create(IDirect3DRMFrameArray** obj);
  82 HRESULT Direct3DRMVisualArray_create(IDirect3DRMVisualArray** ret_iface);
  83 HRESULT Direct3DRMLightArray_create(IDirect3DRMLightArray** ret_iface);
  84
  85 static inline IDirect3DRMFrameImpl *impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface)
  86 {
  87     return CONTAINING_RECORD(iface, IDirect3DRMFrameImpl, IDirect3DRMFrame2_iface);
  88 }
  89
  90 static inline IDirect3DRMFrameImpl *impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
  91 {
  92     return CONTAINING_RECORD(iface, IDirect3DRMFrameImpl, IDirect3DRMFrame3_iface);
  93 }
  94
  95 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface);
  96 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface);
  97
  98 static inline IDirect3DRMLightArrayImpl *impl_from_IDirect3DRMLightArray(IDirect3DRMLightArray *iface)
  99 {
 100     return CONTAINING_RECORD(iface, IDirect3DRMLightArrayImpl, IDirect3DRMLightArray_iface);
 101 }
 102
 103 /*** IUnknown methods ***/
 104 static HRESULT WINAPI IDirect3DRMFrame2Impl_QueryInterface(IDirect3DRMFrame2* iface,
 105                                                            REFIID riid, void** object)
 106 {
 107     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 108
 109     TRACE("(%p/%p)->(%s, %p)\n", iface, This, debugstr_guid(riid), object);
 110
 111     *object = NULL;
 112
 113     if(IsEqualGUID(riid, &IID_IUnknown) ||
 114        IsEqualGUID(riid, &IID_IDirect3DRMFrame) ||
 115        IsEqualGUID(riid, &IID_IDirect3DRMFrame2))
 116     {
 117         *object = &This->IDirect3DRMFrame2_iface;
 118     }
 119     else if(IsEqualGUID(riid, &IID_IDirect3DRMFrame3))
 120     {
 121         *object = &This->IDirect3DRMFrame3_iface;
 122     }
 123     else
 124     {
 125         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 126         return E_NOINTERFACE;
 127     }
 128
 129     IDirect3DRMFrame2_AddRef(iface);
 130     return S_OK;
 131 }
 132
 133 static ULONG WINAPI IDirect3DRMFrame2Impl_AddRef(IDirect3DRMFrame2* iface)
 134 {
 135     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 136     ULONG ref = InterlockedIncrement(&This->ref);
 137
 138     TRACE("(%p)->(): new ref = %d\n", This, ref);
 139
 140     return ref;
 141 }
 142
 143 static ULONG WINAPI IDirect3DRMFrame2Impl_Release(IDirect3DRMFrame2* iface)
 144 {
 145     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 146     ULONG ref = InterlockedDecrement(&This->ref);
 147     ULONG i;
 148
 149     TRACE("(%p)->(): new ref = %d\n", This, ref);
 150
 151     if (!ref)
 152     {
 153         for (i = 0; i < This->nb_children; i++)
 154             IDirect3DRMFrame3_Release(This->children[i]);
 155         HeapFree(GetProcessHeap(), 0, This->children);
 156         for (i = 0; i < This->nb_visuals; i++)
 157             IDirect3DRMVisual_Release(This->visuals[i]);
 158         HeapFree(GetProcessHeap(), 0, This->visuals);
 159         for (i = 0; i < This->nb_lights; i++)
 160             IDirect3DRMLight_Release(This->lights[i]);
 161         HeapFree(GetProcessHeap(), 0, This->lights);
 162         HeapFree(GetProcessHeap(), 0, This);
 163     }
 164
 165     return ref;
 166 }
 167
 168 /*** IDirect3DRMObject methods ***/
 169 static HRESULT WINAPI IDirect3DRMFrame2Impl_Clone(IDirect3DRMFrame2* iface,
 170                                                   LPUNKNOWN unkwn, REFIID riid,
 171                                                   LPVOID* object)
 172 {
 173     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 174
 175     FIXME("(%p/%p)->(%p, %s, %p): stub\n", iface, This, unkwn, debugstr_guid(riid), object);
 176
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddDestroyCallback(IDirect3DRMFrame2* iface,
 181                                                                D3DRMOBJECTCALLBACK cb,
 182                                                                LPVOID argument)
 183 {
 184     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 185
 186     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
 187
 188     return E_NOTIMPL;
 189 }
 190
 191 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteDestroyCallback(IDirect3DRMFrame2* iface,
 192                                                                   D3DRMOBJECTCALLBACK cb,
 193                                                                   LPVOID argument)
 194 {
 195     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 196
 197     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
 198
 199     return E_NOTIMPL;
 200 }
 201
 202 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetAppData(IDirect3DRMFrame2* iface,
 203                                                        DWORD data)
 204 {
 205     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 206
 207     FIXME("(%p/%p)->(%u): stub\n", iface, This, data);
 208
 209     return E_NOTIMPL;
 210 }
 211
 212 static DWORD WINAPI IDirect3DRMFrame2Impl_GetAppData(IDirect3DRMFrame2* iface)
 213 {
 214     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 215
 216     FIXME("(%p/%p)->(): stub\n", iface, This);
 217
 218     return 0;
 219 }
 220
 221 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetName(IDirect3DRMFrame2* iface, LPCSTR name)
 222 {
 223     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 224
 225     FIXME("(%p/%p)->(%s): stub\n", iface, This, name);
 226
 227     return E_NOTIMPL;
 228 }
 229
 230 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetName(IDirect3DRMFrame2* iface,
 231                                                     LPDWORD size, LPSTR name)
 232 {
 233     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 234
 235     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
 236
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetClassName(IDirect3DRMFrame2* iface,
 241                                                          LPDWORD size, LPSTR name)
 242 {
 243     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 244
 245     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
 246
 247     return E_NOTIMPL;
 248 }
 249
 250 /*** IDirect3DRMFrame methods ***/
 251 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddChild(IDirect3DRMFrame2* iface,
 252                                                      LPDIRECT3DRMFRAME child)
 253 {
 254     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 255     IDirect3DRMFrameImpl *frame = unsafe_impl_from_IDirect3DRMFrame2((LPDIRECT3DRMFRAME2)child);
 256
 257     TRACE("(%p/%p)->(%p)\n", iface, This, child);
 258
 259     if (!frame)
 260         return D3DRMERR_BADOBJECT;
 261
 262     return IDirect3DRMFrame3_AddChild(&This->IDirect3DRMFrame3_iface, &frame->IDirect3DRMFrame3_iface);
 263 }
 264
 265 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddLight(IDirect3DRMFrame2* iface,
 266                                                        LPDIRECT3DRMLIGHT light)
 267 {
 268     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 269
 270     TRACE("(%p/%p)->(%p)\n", iface, This, light);
 271
 272     return IDirect3DRMFrame3_AddLight(&This->IDirect3DRMFrame3_iface, light);
 273 }
 274
 275 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddMoveCallback(IDirect3DRMFrame2* iface,
 276                                                             D3DRMFRAMEMOVECALLBACK cb, VOID *arg)
 277 {
 278     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 279
 280     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
 281
 282     return E_NOTIMPL;
 283 }
 284
 285 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddTransform(IDirect3DRMFrame2* iface,
 286                                                          D3DRMCOMBINETYPE type,
 287                                                          D3DRMMATRIX4D matrix)
 288 {
 289     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 290
 291     TRACE("(%p/%p)->(%u,%p)\n", iface, This, type, matrix);
 292
 293     return IDirect3DRMFrame3_AddTransform(&This->IDirect3DRMFrame3_iface, type, matrix);
 294 }
 295
 296 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddTranslation(IDirect3DRMFrame2* iface,
 297                                                            D3DRMCOMBINETYPE type,
 298                                                            D3DVALUE x, D3DVALUE y, D3DVALUE z)
 299 {
 300     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 301
 302     FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, x, y, z);
 303
 304     return E_NOTIMPL;
 305 }
 306
 307 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddScale(IDirect3DRMFrame2* iface,
 308                                                      D3DRMCOMBINETYPE type,
 309                                                      D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
 310 {
 311     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 312
 313     FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, sx, sy, sz);
 314
 315     return E_NOTIMPL;
 316 }
 317
 318 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddRotation(IDirect3DRMFrame2* iface,
 319                                                         D3DRMCOMBINETYPE type,
 320                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
 321                                                         D3DVALUE theta)
 322 {
 323     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 324
 325     FIXME("(%p/%p)->(%u,%f,%f,%f,%f): stub\n", iface, This, type, x, y, z, theta);
 326
 327     return E_NOTIMPL;
 328 }
 329
 330 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddVisual(IDirect3DRMFrame2* iface,
 331                                                       LPDIRECT3DRMVISUAL vis)
 332 {
 333     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 334
 335     TRACE("(%p/%p)->(%p)\n", iface, This, vis);
 336
 337     return IDirect3DRMFrame3_AddVisual(&This->IDirect3DRMFrame3_iface, (LPUNKNOWN)vis);
 338 }
 339
 340 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetChildren(IDirect3DRMFrame2* iface,
 341                                                         LPDIRECT3DRMFRAMEARRAY *children)
 342 {
 343     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 344
 345     TRACE("(%p/%p)->(%p)\n", iface, This, children);
 346
 347     return IDirect3DRMFrame3_GetChildren(&This->IDirect3DRMFrame3_iface, children);
 348 }
 349
 350 static D3DCOLOR WINAPI IDirect3DRMFrame2Impl_GetColor(IDirect3DRMFrame2* iface)
 351 {
 352     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 353
 354     FIXME("(%p/%p)->(): stub\n", iface, This);
 355
 356     return 0;
 357 }
 358
 359 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetLights(IDirect3DRMFrame2* iface,
 360                                                       LPDIRECT3DRMLIGHTARRAY *lights)
 361 {
 362     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 363
 364     TRACE("(%p/%p)->(%p)\n", iface, This, lights);
 365
 366     return IDirect3DRMFrame3_GetLights(&This->IDirect3DRMFrame3_iface, lights);
 367 }
 368
 369 static D3DRMMATERIALMODE WINAPI IDirect3DRMFrame2Impl_GetMaterialMode(IDirect3DRMFrame2* iface)
 370 {
 371     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 372
 373     FIXME("(%p/%p)->(): stub\n", iface, This);
 374
 375     return D3DRMMATERIAL_FROMPARENT;
 376 }
 377
 378 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetParent(IDirect3DRMFrame2* iface,
 379                                                       LPDIRECT3DRMFRAME * frame)
 380 {
 381     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 382
 383     TRACE("(%p/%p)->(%p)\n", iface, This, frame);
 384
 385     if (!frame)
 386         return D3DRMERR_BADVALUE;
 387
 388     if (This->parent)
 389     {
 390         *frame = (LPDIRECT3DRMFRAME)&This->parent->IDirect3DRMFrame2_iface;
 391         IDirect3DRMFrame_AddRef(*frame);
 392     }
 393     else
 394     {
 395         *frame = NULL;
 396     }
 397
 398     return D3DRM_OK;
 399 }
 400
 401 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetPosition(IDirect3DRMFrame2* iface,
 402                                                         LPDIRECT3DRMFRAME reference,
 403                                                         LPD3DVECTOR return_position)
 404 {
 405     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 406
 407     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, reference, return_position);
 408
 409     return E_NOTIMPL;
 410 }
 411
 412 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetRotation(IDirect3DRMFrame2* iface,
 413                                                         LPDIRECT3DRMFRAME reference,
 414                                                         LPD3DVECTOR axis, LPD3DVALUE return_theta)
 415 {
 416     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 417
 418     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, axis, return_theta);
 419
 420     return E_NOTIMPL;
 421 }
 422
 423 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetScene(IDirect3DRMFrame2* iface,
 424                                                      LPDIRECT3DRMFRAME * frame)
 425 {
 426     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 427
 428     FIXME("(%p/%p)->(%p): stub\n", iface, This, frame);
 429
 430     return E_NOTIMPL;
 431 }
 432
 433 static D3DRMSORTMODE WINAPI IDirect3DRMFrame2Impl_GetSortMode(IDirect3DRMFrame2* iface)
 434 {
 435     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 436
 437     FIXME("(%p/%p)->(): stub\n", iface, This);
 438
 439     return D3DRMSORT_FROMPARENT;
 440 }
 441
 442 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetTexture(IDirect3DRMFrame2* iface,
 443                                                        LPDIRECT3DRMTEXTURE * tex)
 444 {
 445     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 446
 447     FIXME("(%p/%p)->(%p): stub\n", iface, This, tex);
 448
 449     return E_NOTIMPL;
 450 }
 451
 452 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetTransform(IDirect3DRMFrame2* iface,
 453                                                          D3DRMMATRIX4D return_matrix)
 454 {
 455     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 456
 457     TRACE("(%p/%p)->(%p)\n", iface, This, return_matrix);
 458
 459     memcpy(&return_matrix[0][0], &This->transform[0][0], sizeof(D3DRMMATRIX4D));
 460
 461     return D3DRM_OK;
 462 }
 463
 464 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetVelocity(IDirect3DRMFrame2* iface,
 465                                                         LPDIRECT3DRMFRAME reference,
 466                                                         LPD3DVECTOR return_velocity,
 467                                                         BOOL with_rotation)
 468 {
 469     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 470
 471     FIXME("(%p/%p)->(%p,%p,%d): stub\n", iface, This, reference, return_velocity, with_rotation);
 472
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetOrientation(IDirect3DRMFrame2* iface,
 477                                                            LPDIRECT3DRMFRAME reference,
 478                                                            LPD3DVECTOR dir, LPD3DVECTOR up)
 479 {
 480     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 481
 482     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, dir, up);
 483
 484     return E_NOTIMPL;
 485 }
 486
 487 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetVisuals(IDirect3DRMFrame2* iface,
 488                                                        LPDIRECT3DRMVISUALARRAY *visuals)
 489 {
 490     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 491     IDirect3DRMVisualArrayImpl* obj;
 492     HRESULT hr;
 493
 494     TRACE("(%p/%p)->(%p)\n", iface, This, visuals);
 495
 496     if (!visuals)
 497         return D3DRMERR_BADVALUE;
 498
 499     hr = Direct3DRMVisualArray_create(visuals);
 500
 501     if (hr != D3DRM_OK)
 502         return hr;
 503
 504     obj = (IDirect3DRMVisualArrayImpl*)*visuals;
 505
 506     obj->size = This->nb_visuals;
 507     if (This->nb_visuals)
 508     {
 509         ULONG i;
 510         obj->visuals = HeapAlloc(GetProcessHeap(), 0, This->nb_visuals * sizeof(LPDIRECT3DRMVISUAL));
 511         if (!obj->visuals)
 512             return E_OUTOFMEMORY;
 513         for (i = 0; i < This->nb_visuals; i++)
 514         {
 515             obj->visuals[i] = This->visuals[i];
 516             IDirect3DRMVisual_AddRef(This->visuals[i]);
 517         }
 518     }
 519
 520     return D3DRM_OK;
 521 }
 522
 523 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetTextureTopology(IDirect3DRMFrame2* iface,
 524                                                                BOOL *wrap_u, BOOL *wrap_v)
 525 {
 526     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 527
 528     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, wrap_u, wrap_v);
 529
 530     return E_NOTIMPL;
 531 }
 532
 533 static HRESULT WINAPI IDirect3DRMFrame2Impl_InverseTransform(IDirect3DRMFrame2* iface,
 534                                                              D3DVECTOR *d, D3DVECTOR *s)
 535 {
 536     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 537
 538     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
 539
 540     return E_NOTIMPL;
 541 }
 542
 543 static HRESULT WINAPI IDirect3DRMFrame2Impl_Load(IDirect3DRMFrame2* iface, LPVOID filename,
 544                                                  LPVOID name, D3DRMLOADOPTIONS loadflags,
 545                                                  D3DRMLOADTEXTURECALLBACK cb, LPVOID lpArg)
 546 {
 547     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 548
 549     FIXME("(%p/%p)->(%p,%p,%u,%p,%p): stub\n", iface, This, filename, name, loadflags, cb, lpArg);
 550
 551     return E_NOTIMPL;
 552 }
 553
 554 static HRESULT WINAPI IDirect3DRMFrame2Impl_LookAt(IDirect3DRMFrame2* iface,
 555                                                    LPDIRECT3DRMFRAME target,
 556                                                    LPDIRECT3DRMFRAME reference,
 557                                                    D3DRMFRAMECONSTRAINT constraint)
 558 {
 559     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 560
 561     FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, target, reference, constraint);
 562
 563     return E_NOTIMPL;
 564 }
 565
 566 static HRESULT WINAPI IDirect3DRMFrame2Impl_Move(IDirect3DRMFrame2* iface, D3DVALUE delta)
 567 {
 568     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 569
 570     FIXME("(%p/%p)->(%f): stub\n", iface, This, delta);
 571
 572     return E_NOTIMPL;
 573 }
 574
 575 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteChild(IDirect3DRMFrame2* iface,
 576                                                         LPDIRECT3DRMFRAME frame)
 577 {
 578     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 579     IDirect3DRMFrameImpl *child = unsafe_impl_from_IDirect3DRMFrame2((LPDIRECT3DRMFRAME2)frame);
 580
 581     TRACE("(%p/%p)->(%p)\n", iface, This, frame);
 582
 583     if (!child)
 584         return D3DRMERR_BADOBJECT;
 585
 586     return IDirect3DRMFrame3_DeleteChild(&This->IDirect3DRMFrame3_iface, &child->IDirect3DRMFrame3_iface);
 587 }
 588
 589 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteLight(IDirect3DRMFrame2* iface,
 590                                                           LPDIRECT3DRMLIGHT light)
 591 {
 592     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 593
 594     TRACE("(%p/%p)->(%p)\n", iface, This, light);
 595
 596     return IDirect3DRMFrame3_DeleteLight(&This->IDirect3DRMFrame3_iface, light);
 597 }
 598
 599 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteMoveCallback(IDirect3DRMFrame2* iface,
 600                                                                D3DRMFRAMEMOVECALLBACK cb, VOID *arg)
 601 {
 602     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 603
 604     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
 605
 606     return E_NOTIMPL;
 607 }
 608
 609 static HRESULT WINAPI IDirect3DRMFrame2Impl_DeleteVisual(IDirect3DRMFrame2* iface,
 610                                                          LPDIRECT3DRMVISUAL vis)
 611 {
 612     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 613
 614     TRACE("(%p/%p)->(%p)\n", iface, This, vis);
 615
 616     return IDirect3DRMFrame3_DeleteVisual(&This->IDirect3DRMFrame3_iface, (LPUNKNOWN)vis);
 617 }
 618
 619 static D3DCOLOR WINAPI IDirect3DRMFrame2Impl_GetSceneBackground(IDirect3DRMFrame2* iface)
 620 {
 621     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 622
 623     FIXME("(%p/%p)->(): stub\n", iface, This);
 624
 625     return 0;
 626 }
 627
 628 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetSceneBackgroundDepth(IDirect3DRMFrame2* iface,
 629                                                                     LPDIRECTDRAWSURFACE * surface)
 630 {
 631     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 632
 633     FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
 634
 635     return E_NOTIMPL;
 636 }
 637
 638 static D3DCOLOR WINAPI IDirect3DRMFrame2Impl_GetSceneFogColor(IDirect3DRMFrame2* iface)
 639 {
 640     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 641
 642     FIXME("(%p/%p)->(): stub\n", iface, This);
 643
 644     return 0;
 645 }
 646
 647 static BOOL WINAPI IDirect3DRMFrame2Impl_GetSceneFogEnable(IDirect3DRMFrame2* iface)
 648 {
 649     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 650
 651     FIXME("(%p/%p)->(): stub\n", iface, This);
 652
 653     return FALSE;
 654 }
 655
 656 static D3DRMFOGMODE WINAPI IDirect3DRMFrame2Impl_GetSceneFogMode(IDirect3DRMFrame2* iface)
 657 {
 658     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 659
 660     FIXME("(%p/%p)->(): stub\n", iface, This);
 661
 662     return D3DRMFOG_LINEAR;
 663 }
 664
 665 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetSceneFogParams(IDirect3DRMFrame2* iface,
 666                                                               D3DVALUE *return_start,
 667                                                               D3DVALUE *return_end,
 668                                                               D3DVALUE *return_density)
 669 {
 670     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 671
 672     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, return_start, return_end, return_density);
 673
 674     return E_NOTIMPL;
 675 }
 676
 677 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackground(IDirect3DRMFrame2* iface,
 678                                                                D3DCOLOR color)
 679 {
 680     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 681
 682     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
 683
 684     return E_NOTIMPL;
 685 }
 686
 687 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackgroundRGB(IDirect3DRMFrame2* iface,
 688                                                                   D3DVALUE red, D3DVALUE green,
 689                                                                   D3DVALUE blue)
 690 {
 691     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 692
 693     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
 694
 695     return E_NOTIMPL;
 696 }
 697
 698 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackgroundDepth(IDirect3DRMFrame2* iface,
 699                                                                     LPDIRECTDRAWSURFACE surface)
 700 {
 701     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 702
 703     FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
 704
 705     return E_NOTIMPL;
 706 }
 707
 708 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneBackgroundImage(IDirect3DRMFrame2* iface,
 709                                                                     LPDIRECT3DRMTEXTURE texture)
 710 {
 711     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 712
 713     FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
 714
 715     return E_NOTIMPL;
 716 }
 717
 718 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogEnable(IDirect3DRMFrame2* iface, BOOL enable)
 719 {
 720     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 721
 722     FIXME("(%p/%p)->(%d): stub\n", iface, This, enable);
 723
 724     return E_NOTIMPL;
 725 }
 726
 727 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogColor(IDirect3DRMFrame2* iface,
 728                                                              D3DCOLOR color)
 729 {
 730     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 731
 732     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
 733
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogMode(IDirect3DRMFrame2* iface,
 738                                                             D3DRMFOGMODE mode)
 739 {
 740     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 741
 742     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
 743
 744     return E_NOTIMPL;
 745 }
 746
 747 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSceneFogParams(IDirect3DRMFrame2* iface,
 748                                                               D3DVALUE start, D3DVALUE end,
 749                                                               D3DVALUE density)
 750 {
 751     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 752
 753     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, start, end, density);
 754
 755     return E_NOTIMPL;
 756 }
 757
 758 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetColor(IDirect3DRMFrame2* iface, D3DCOLOR color)
 759 {
 760     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 761
 762     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
 763
 764     return E_NOTIMPL;
 765 }
 766
 767 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetColorRGB(IDirect3DRMFrame2* iface, D3DVALUE red,
 768                                                         D3DVALUE green, D3DVALUE blue)
 769 {
 770     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 771
 772     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
 773
 774     return E_NOTIMPL;
 775 }
 776
 777 static D3DRMZBUFFERMODE WINAPI IDirect3DRMFrame2Impl_GetZbufferMode(IDirect3DRMFrame2* iface)
 778 {
 779     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 780
 781     FIXME("(%p/%p)->(): stub\n", iface, This);
 782
 783     return D3DRMZBUFFER_FROMPARENT;
 784 }
 785
 786 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetMaterialMode(IDirect3DRMFrame2* iface,
 787                                                             D3DRMMATERIALMODE mode)
 788 {
 789     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 790
 791     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
 792
 793     return E_NOTIMPL;
 794 }
 795
 796 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetOrientation(IDirect3DRMFrame2* iface,
 797                                                            LPDIRECT3DRMFRAME reference,
 798                                                            D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
 799                                                            D3DVALUE ux, D3DVALUE uy, D3DVALUE uz )
 800 {
 801     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 802
 803     FIXME("(%p/%p)->(%p,%f,%f,%f,%f,%f,%f): stub\n", iface, This, reference,
 804           dx, dy, dz, ux, uy, uz);
 805
 806     return E_NOTIMPL;
 807 }
 808
 809 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetPosition(IDirect3DRMFrame2* iface,
 810                                                         LPDIRECT3DRMFRAME reference,
 811                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z)
 812 {
 813     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 814
 815     FIXME("(%p/%p)->(%p,%f,%f,%f): stub\n", iface, This, reference, x, y, z);
 816
 817     return E_NOTIMPL;
 818 }
 819
 820 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetRotation(IDirect3DRMFrame2* iface,
 821                                                         LPDIRECT3DRMFRAME reference,
 822                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
 823                                                         D3DVALUE theta)
 824 {
 825     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 826
 827     FIXME("(%p/%p)->(%p,%f,%f,%f,%f): stub\n", iface, This, reference, x, y, z, theta);
 828
 829     return E_NOTIMPL;
 830 }
 831
 832 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetSortMode(IDirect3DRMFrame2* iface,
 833                                                         D3DRMSORTMODE mode)
 834 {
 835     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 836
 837     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
 838
 839     return E_NOTIMPL;
 840 }
 841
 842 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetTexture(IDirect3DRMFrame2* iface,
 843                                                        LPDIRECT3DRMTEXTURE texture)
 844 {
 845     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 846
 847     FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
 848
 849     return E_NOTIMPL;
 850 }
 851
 852 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetTextureTopology(IDirect3DRMFrame2* iface,
 853                                                                BOOL wrap_u, BOOL wrap_v)
 854 {
 855     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 856
 857     FIXME("(%p/%p)->(%d,%d): stub\n", iface, This, wrap_u, wrap_v);
 858
 859     return E_NOTIMPL;
 860 }
 861
 862 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetVelocity(IDirect3DRMFrame2* iface,
 863                                                         LPDIRECT3DRMFRAME reference,
 864                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
 865                                                         BOOL with_rotation)
 866 {
 867     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 868
 869     FIXME("(%p/%p)->(%p,%f,%f,%f,%d): stub\n", iface, This, reference, x, y, z, with_rotation);
 870
 871     return E_NOTIMPL;
 872 }
 873
 874 static HRESULT WINAPI IDirect3DRMFrame2Impl_SetZbufferMode(IDirect3DRMFrame2* iface,
 875                                                            D3DRMZBUFFERMODE mode)
 876 {
 877     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 878
 879     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
 880
 881     return E_NOTIMPL;
 882 }
 883
 884 static HRESULT WINAPI IDirect3DRMFrame2Impl_Transform(IDirect3DRMFrame2* iface, D3DVECTOR *d,
 885                                                       D3DVECTOR *s)
 886 {
 887     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 888
 889     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
 890
 891     return E_NOTIMPL;
 892 }
 893
 894 /*** IDirect3DRMFrame2 methods ***/
 895 static HRESULT WINAPI IDirect3DRMFrame2Impl_AddMoveCallback2(IDirect3DRMFrame2* iface,
 896                                                              D3DRMFRAMEMOVECALLBACK cb, VOID *arg,
 897                                                              DWORD flags)
 898 {
 899     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 900
 901     FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, cb, arg, flags);
 902
 903     return E_NOTIMPL;
 904 }
 905
 906 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetBox(IDirect3DRMFrame2* iface, LPD3DRMBOX box)
 907 {
 908     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 909
 910     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
 911
 912     return E_NOTIMPL;
 913 }
 914
 915 static BOOL WINAPI IDirect3DRMFrame2Impl_GetBoxEnable(IDirect3DRMFrame2* iface)
 916 {
 917     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 918
 919     FIXME("(%p/%p)->(): stub\n", iface, This);
 920
 921     return E_NOTIMPL;
 922 }
 923
 924 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetAxes(IDirect3DRMFrame2* iface,
 925                                                     LPD3DVECTOR dir, LPD3DVECTOR up)
 926 {
 927     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 928
 929     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, dir, up);
 930
 931     return E_NOTIMPL;
 932 }
 933
 934 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetMaterial(IDirect3DRMFrame2* iface,
 935                                                         LPDIRECT3DRMMATERIAL *material)
 936 {
 937     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 938
 939     FIXME("(%p/%p)->(%p): stub\n", iface, This, material);
 940
 941     return E_NOTIMPL;
 942 }
 943
 944 static BOOL WINAPI IDirect3DRMFrame2Impl_GetInheritAxes(IDirect3DRMFrame2* iface)
 945 {
 946     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 947
 948     FIXME("(%p/%p)->(): stub\n", iface, This);
 949
 950     return E_NOTIMPL;
 951 }
 952
 953 static HRESULT WINAPI IDirect3DRMFrame2Impl_GetHierarchyBox(IDirect3DRMFrame2* iface,
 954                                                             LPD3DRMBOX box)
 955 {
 956     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame2(iface);
 957
 958     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
 959
 960     return E_NOTIMPL;
 961 }
 962
 963 static const struct IDirect3DRMFrame2Vtbl Direct3DRMFrame2_Vtbl =
 964 {
 965     /*** IUnknown methods ***/
 966     IDirect3DRMFrame2Impl_QueryInterface,
 967     IDirect3DRMFrame2Impl_AddRef,
 968     IDirect3DRMFrame2Impl_Release,
 969     /*** IDirect3DRMObject methods ***/
 970     IDirect3DRMFrame2Impl_Clone,
 971     IDirect3DRMFrame2Impl_AddDestroyCallback,
 972     IDirect3DRMFrame2Impl_DeleteDestroyCallback,
 973     IDirect3DRMFrame2Impl_SetAppData,
 974     IDirect3DRMFrame2Impl_GetAppData,
 975     IDirect3DRMFrame2Impl_SetName,
 976     IDirect3DRMFrame2Impl_GetName,
 977     IDirect3DRMFrame2Impl_GetClassName,
 978     /*** IDirect3DRMFrame methods ***/
 979     IDirect3DRMFrame2Impl_AddChild,
 980     IDirect3DRMFrame2Impl_AddLight,
 981     IDirect3DRMFrame2Impl_AddMoveCallback,
 982     IDirect3DRMFrame2Impl_AddTransform,
 983     IDirect3DRMFrame2Impl_AddTranslation,
 984     IDirect3DRMFrame2Impl_AddScale,
 985     IDirect3DRMFrame2Impl_AddRotation,
 986     IDirect3DRMFrame2Impl_AddVisual,
 987     IDirect3DRMFrame2Impl_GetChildren,
 988     IDirect3DRMFrame2Impl_GetColor,
 989     IDirect3DRMFrame2Impl_GetLights,
 990     IDirect3DRMFrame2Impl_GetMaterialMode,
 991     IDirect3DRMFrame2Impl_GetParent,
 992     IDirect3DRMFrame2Impl_GetPosition,
 993     IDirect3DRMFrame2Impl_GetRotation,
 994     IDirect3DRMFrame2Impl_GetScene,
 995     IDirect3DRMFrame2Impl_GetSortMode,
 996     IDirect3DRMFrame2Impl_GetTexture,
 997     IDirect3DRMFrame2Impl_GetTransform,
 998     IDirect3DRMFrame2Impl_GetVelocity,
 999     IDirect3DRMFrame2Impl_GetOrientation,
1000     IDirect3DRMFrame2Impl_GetVisuals,
1001     IDirect3DRMFrame2Impl_GetTextureTopology,
1002     IDirect3DRMFrame2Impl_InverseTransform,
1003     IDirect3DRMFrame2Impl_Load,
1004     IDirect3DRMFrame2Impl_LookAt,
1005     IDirect3DRMFrame2Impl_Move,
1006     IDirect3DRMFrame2Impl_DeleteChild,
1007     IDirect3DRMFrame2Impl_DeleteLight,
1008     IDirect3DRMFrame2Impl_DeleteMoveCallback,
1009     IDirect3DRMFrame2Impl_DeleteVisual,
1010     IDirect3DRMFrame2Impl_GetSceneBackground,
1011     IDirect3DRMFrame2Impl_GetSceneBackgroundDepth,
1012     IDirect3DRMFrame2Impl_GetSceneFogColor,
1013     IDirect3DRMFrame2Impl_GetSceneFogEnable,
1014     IDirect3DRMFrame2Impl_GetSceneFogMode,
1015     IDirect3DRMFrame2Impl_GetSceneFogParams,
1016     IDirect3DRMFrame2Impl_SetSceneBackground,
1017     IDirect3DRMFrame2Impl_SetSceneBackgroundRGB,
1018     IDirect3DRMFrame2Impl_SetSceneBackgroundDepth,
1019     IDirect3DRMFrame2Impl_SetSceneBackgroundImage,
1020     IDirect3DRMFrame2Impl_SetSceneFogEnable,
1021     IDirect3DRMFrame2Impl_SetSceneFogColor,
1022     IDirect3DRMFrame2Impl_SetSceneFogMode,
1023     IDirect3DRMFrame2Impl_SetSceneFogParams,
1024     IDirect3DRMFrame2Impl_SetColor,
1025     IDirect3DRMFrame2Impl_SetColorRGB,
1026     IDirect3DRMFrame2Impl_GetZbufferMode,
1027     IDirect3DRMFrame2Impl_SetMaterialMode,
1028     IDirect3DRMFrame2Impl_SetOrientation,
1029     IDirect3DRMFrame2Impl_SetPosition,
1030     IDirect3DRMFrame2Impl_SetRotation,
1031     IDirect3DRMFrame2Impl_SetSortMode,
1032     IDirect3DRMFrame2Impl_SetTexture,
1033     IDirect3DRMFrame2Impl_SetTextureTopology,
1034     IDirect3DRMFrame2Impl_SetVelocity,
1035     IDirect3DRMFrame2Impl_SetZbufferMode,
1036     IDirect3DRMFrame2Impl_Transform,
1037     /*** IDirect3DRMFrame2 methods ***/
1038     IDirect3DRMFrame2Impl_AddMoveCallback2,
1039     IDirect3DRMFrame2Impl_GetBox,
1040     IDirect3DRMFrame2Impl_GetBoxEnable,
1041     IDirect3DRMFrame2Impl_GetAxes,
1042     IDirect3DRMFrame2Impl_GetMaterial,
1043     IDirect3DRMFrame2Impl_GetInheritAxes,
1044     IDirect3DRMFrame2Impl_GetHierarchyBox
1045 };
1046
1047 /*** IUnknown methods ***/
1048 static HRESULT WINAPI IDirect3DRMFrame3Impl_QueryInterface(IDirect3DRMFrame3* iface,
1049                                                            REFIID riid, void** object)
1050 {
1051     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1052     return IDirect3DRMFrame_QueryInterface(&This->IDirect3DRMFrame2_iface, riid, object);
1053 }
1054
1055 static ULONG WINAPI IDirect3DRMFrame3Impl_AddRef(IDirect3DRMFrame3* iface)
1056 {
1057     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1058     return IDirect3DRMFrame2_AddRef(&This->IDirect3DRMFrame2_iface);
1059 }
1060
1061 static ULONG WINAPI IDirect3DRMFrame3Impl_Release(IDirect3DRMFrame3* iface)
1062 {
1063     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1064     return IDirect3DRMFrame2_Release(&This->IDirect3DRMFrame2_iface);
1065 }
1066
1067 /*** IDirect3DRMObject methods ***/
1068 static HRESULT WINAPI IDirect3DRMFrame3Impl_Clone(IDirect3DRMFrame3* iface,
1069                                                   LPUNKNOWN unkwn, REFIID riid,
1070                                                   LPVOID* object)
1071 {
1072     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1073
1074     FIXME("(%p/%p)->(%p, %s, %p): stub\n", iface, This, unkwn, debugstr_guid(riid), object);
1075
1076     return E_NOTIMPL;
1077 }
1078
1079 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddDestroyCallback(IDirect3DRMFrame3* iface,
1080                                                                D3DRMOBJECTCALLBACK cb,
1081                                                                LPVOID argument)
1082 {
1083     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1084
1085     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
1086
1087     return E_NOTIMPL;
1088 }
1089
1090 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteDestroyCallback(IDirect3DRMFrame3* iface,
1091                                                                   D3DRMOBJECTCALLBACK cb,
1092                                                                   LPVOID argument)
1093 {
1094     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1095
1096     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, cb, argument);
1097
1098     return E_NOTIMPL;
1099 }
1100
1101 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetAppData(IDirect3DRMFrame3* iface,
1102                                                        DWORD data)
1103 {
1104     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1105
1106     FIXME("(%p/%p)->(%u): stub\n", iface, This, data);
1107
1108     return E_NOTIMPL;
1109 }
1110
1111 static DWORD WINAPI IDirect3DRMFrame3Impl_GetAppData(IDirect3DRMFrame3* iface)
1112 {
1113     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1114
1115     FIXME("(%p/%p)->(): stub\n", iface, This);
1116
1117     return 0;
1118 }
1119
1120 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetName(IDirect3DRMFrame3* iface, LPCSTR name)
1121 {
1122     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1123
1124     FIXME("(%p/%p)->(%s): stub\n", iface, This, name);
1125
1126     return E_NOTIMPL;
1127 }
1128
1129 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetName(IDirect3DRMFrame3* iface,
1130                                                     LPDWORD size, LPSTR name)
1131 {
1132     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1133
1134     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
1135
1136     return E_NOTIMPL;
1137 }
1138
1139 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetClassName(IDirect3DRMFrame3* iface,
1140                                                          LPDWORD size, LPSTR name)
1141 {
1142     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1143
1144     FIXME("(%p/%p)->(%p, %p): stub\n", iface, This, size, name);
1145
1146     return E_NOTIMPL;
1147 }
1148
1149 /*** IDirect3DRMFrame methods ***/
1150 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddChild(IDirect3DRMFrame3* iface,
1151                                                      LPDIRECT3DRMFRAME3 child)
1152 {
1153     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1154     IDirect3DRMFrameImpl *child_obj = unsafe_impl_from_IDirect3DRMFrame3(child);
1155
1156     TRACE("(%p/%p)->(%p)\n", iface, This, child);
1157
1158     if (!child_obj)
1159         return D3DRMERR_BADOBJECT;
1160
1161     if (child_obj->parent)
1162     {
1163         IDirect3DRMFrame3* parent = &child_obj->parent->IDirect3DRMFrame3_iface;
1164
1165         if (parent == iface)
1166         {
1167             /* Passed frame is already a child so return success */
1168             return D3DRM_OK;
1169         }
1170         else
1171         {
1172             /* Remove parent and continue */
1173             IDirect3DRMFrame3_DeleteChild(parent, child);
1174         }
1175     }
1176
1177     if ((This->nb_children + 1) > This->children_capacity)
1178     {
1179         ULONG new_capacity;
1180         IDirect3DRMFrame3** children;
1181
1182         if (!This->children_capacity)
1183         {
1184             new_capacity = 16;
1185             children = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMFrame3*));
1186         }
1187         else
1188         {
1189             new_capacity = This->children_capacity * 2;
1190             children = HeapReAlloc(GetProcessHeap(), 0, This->children, new_capacity * sizeof(IDirect3DRMFrame3*));
1191         }
1192
1193         if (!children)
1194             return E_OUTOFMEMORY;
1195
1196         This->children_capacity = new_capacity;
1197         This->children = children;
1198     }
1199
1200     This->children[This->nb_children++] = child;
1201     IDirect3DRMFrame3_AddRef(child);
1202     child_obj->parent = This;
1203
1204     return D3DRM_OK;
1205 }
1206
1207 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddLight(IDirect3DRMFrame3* iface,
1208                                                        LPDIRECT3DRMLIGHT light)
1209 {
1210     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1211     ULONG i;
1212     IDirect3DRMLight** lights;
1213
1214     TRACE("(%p/%p)->(%p)\n", iface, This, light);
1215
1216     if (!light)
1217         return D3DRMERR_BADOBJECT;
1218
1219     /* Check if already existing and return gracefully without increasing ref count */
1220     for (i = 0; i < This->nb_lights; i++)
1221         if (This->lights[i] == light)
1222             return D3DRM_OK;
1223
1224     if ((This->nb_lights + 1) > This->lights_capacity)
1225     {
1226         ULONG new_capacity;
1227
1228         if (!This->lights_capacity)
1229         {
1230             new_capacity = 16;
1231             lights = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMLight*));
1232         }
1233         else
1234         {
1235             new_capacity = This->lights_capacity * 2;
1236             lights = HeapReAlloc(GetProcessHeap(), 0, This->lights, new_capacity * sizeof(IDirect3DRMLight*));
1237         }
1238
1239         if (!lights)
1240             return E_OUTOFMEMORY;
1241
1242         This->lights_capacity = new_capacity;
1243         This->lights = lights;
1244     }
1245
1246     This->lights[This->nb_lights++] = light;
1247     IDirect3DRMLight_AddRef(light);
1248
1249     return D3DRM_OK;
1250 }
1251
1252 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddMoveCallback(IDirect3DRMFrame3* iface,
1253                                                             D3DRMFRAME3MOVECALLBACK cb, VOID *arg,
1254                                                             DWORD flags)
1255 {
1256     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1257
1258     FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, cb, arg, flags);
1259
1260     return E_NOTIMPL;
1261 }
1262
1263 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddTransform(IDirect3DRMFrame3* iface,
1264                                                          D3DRMCOMBINETYPE type,
1265                                                          D3DRMMATRIX4D matrix)
1266 {
1267     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1268
1269     TRACE("(%p/%p)->(%u,%p)\n", iface, This, type, matrix);
1270
1271     switch (type)
1272     {
1273         case D3DRMCOMBINE_REPLACE:
1274             memcpy(&This->transform[0][0], &matrix[0][0], sizeof(D3DRMMATRIX4D));
1275             break;
1276
1277         case D3DRMCOMBINE_BEFORE:
1278             FIXME("D3DRMCOMBINE_BEFORE not supported yed\n");
1279             break;
1280
1281         case D3DRMCOMBINE_AFTER:
1282             FIXME("D3DRMCOMBINE_AFTER not supported yed\n");
1283             break;
1284
1285         default:
1286             WARN("Unknown Combine Type %u\n", type);
1287             return D3DRMERR_BADVALUE;
1288     }
1289
1290     return S_OK;
1291 }
1292
1293 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddTranslation(IDirect3DRMFrame3* iface,
1294                                                            D3DRMCOMBINETYPE type,
1295                                                            D3DVALUE x, D3DVALUE y, D3DVALUE z)
1296 {
1297     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1298
1299     FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, x, y, z);
1300
1301     return E_NOTIMPL;
1302 }
1303
1304 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddScale(IDirect3DRMFrame3* iface,
1305                                                      D3DRMCOMBINETYPE type,
1306                                                      D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1307 {
1308     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1309
1310     FIXME("(%p/%p)->(%u,%f,%f,%f): stub\n", iface, This, type, sx, sy, sz);
1311
1312     return E_NOTIMPL;
1313 }
1314
1315 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddRotation(IDirect3DRMFrame3* iface,
1316                                                         D3DRMCOMBINETYPE type,
1317                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
1318                                                         D3DVALUE theta)
1319 {
1320     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1321
1322     FIXME("(%p/%p)->(%u,%f,%f,%f,%f): stub\n", iface, This, type, x, y, z, theta);
1323
1324     return E_NOTIMPL;
1325 }
1326
1327 static HRESULT WINAPI IDirect3DRMFrame3Impl_AddVisual(IDirect3DRMFrame3* iface, LPUNKNOWN vis)
1328 {
1329     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1330     ULONG i;
1331     IDirect3DRMVisual** visuals;
1332
1333     TRACE("(%p/%p)->(%p)\n", iface, This, vis);
1334
1335     if (!vis)
1336         return D3DRMERR_BADOBJECT;
1337
1338     /* Check if already existing and return gracefully without increasing ref count */
1339     for (i = 0; i < This->nb_visuals; i++)
1340         if (This->visuals[i] == (IDirect3DRMVisual*)vis)
1341             return D3DRM_OK;
1342
1343     if ((This->nb_visuals + 1) > This->visuals_capacity)
1344     {
1345         ULONG new_capacity;
1346
1347         if (!This->visuals_capacity)
1348         {
1349             new_capacity = 16;
1350             visuals = HeapAlloc(GetProcessHeap(), 0, new_capacity * sizeof(IDirect3DRMVisual*));
1351         }
1352         else
1353         {
1354             new_capacity = This->visuals_capacity * 2;
1355             visuals = HeapReAlloc(GetProcessHeap(), 0, This->visuals, new_capacity * sizeof(IDirect3DRMVisual*));
1356         }
1357
1358         if (!visuals)
1359             return E_OUTOFMEMORY;
1360
1361         This->visuals_capacity = new_capacity;
1362         This->visuals = visuals;
1363     }
1364
1365     This->visuals[This->nb_visuals++] = (IDirect3DRMVisual*)vis;
1366     IDirect3DRMVisual_AddRef(vis);
1367
1368     return D3DRM_OK;
1369 }
1370
1371 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetChildren(IDirect3DRMFrame3* iface,
1372                                                         LPDIRECT3DRMFRAMEARRAY *children)
1373 {
1374     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1375     IDirect3DRMFrameArrayImpl* obj;
1376     HRESULT hr;
1377
1378     TRACE("(%p/%p)->(%p)\n", iface, This, children);
1379
1380     if (!children)
1381         return D3DRMERR_BADVALUE;
1382
1383     hr = Direct3DRMFrameArray_create(children);
1384
1385     if (hr != D3DRM_OK)
1386         return hr;
1387
1388     obj = (IDirect3DRMFrameArrayImpl*)*children;
1389
1390     obj->size = This->nb_children;
1391     if (This->nb_children)
1392     {
1393         ULONG i;
1394         obj->frames = HeapAlloc(GetProcessHeap(), 0, This->nb_children * sizeof(LPDIRECT3DRMFRAME));
1395         if (!obj->frames)
1396             return E_OUTOFMEMORY;
1397         for (i = 0; i < This->nb_children; i++)
1398             IDirect3DRMFrame3_QueryInterface(This->children[i], &IID_IDirect3DRMFrame, (void**)&obj->frames[i]);
1399     }
1400
1401     return D3DRM_OK;
1402 }
1403
1404 static D3DCOLOR WINAPI IDirect3DRMFrame3Impl_GetColor(IDirect3DRMFrame3* iface)
1405 {
1406     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1407
1408     FIXME("(%p/%p)->(): stub\n", iface, This);
1409
1410     return 0;
1411 }
1412
1413 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetLights(IDirect3DRMFrame3* iface,
1414                                                       LPDIRECT3DRMLIGHTARRAY *lights)
1415 {
1416     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1417     IDirect3DRMLightArrayImpl* obj;
1418     HRESULT hr;
1419
1420     TRACE("(%p/%p)->(%p)\n", iface, This, lights);
1421
1422     if (!lights)
1423         return D3DRMERR_BADVALUE;
1424
1425     hr = Direct3DRMLightArray_create(lights);
1426
1427     if (hr != D3DRM_OK)
1428         return hr;
1429
1430     obj = (IDirect3DRMLightArrayImpl*)*lights;
1431
1432     obj->size = This->nb_lights;
1433     if (This->nb_lights)
1434     {
1435         ULONG i;
1436         obj->lights = HeapAlloc(GetProcessHeap(), 0, This->nb_lights * sizeof(LPDIRECT3DRMLIGHT));
1437         if (!obj->lights)
1438             return E_OUTOFMEMORY;
1439         for (i = 0; i < This->nb_lights; i++)
1440             IDirect3DRMLight_QueryInterface(This->lights[i], &IID_IDirect3DRMLight, (void**)&obj->lights[i]);
1441     }
1442
1443     return D3DRM_OK;
1444 }
1445
1446 static D3DRMMATERIALMODE WINAPI IDirect3DRMFrame3Impl_GetMaterialMode(IDirect3DRMFrame3* iface)
1447 {
1448     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1449
1450     FIXME("(%p/%p)->(): stub\n", iface, This);
1451
1452     return D3DRMMATERIAL_FROMPARENT;
1453 }
1454
1455 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetParent(IDirect3DRMFrame3* iface,
1456                                                       LPDIRECT3DRMFRAME3 * frame)
1457 {
1458     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1459
1460     TRACE("(%p/%p)->(%p)\n", iface, This, frame);
1461
1462     if (!frame)
1463         return D3DRMERR_BADVALUE;
1464
1465     if (This->parent)
1466     {
1467         *frame = &This->parent->IDirect3DRMFrame3_iface;
1468         IDirect3DRMFrame_AddRef(*frame);
1469     }
1470     else
1471     {
1472         *frame = NULL;
1473     }
1474
1475     return D3DRM_OK;
1476 }
1477
1478 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetPosition(IDirect3DRMFrame3* iface,
1479                                                         LPDIRECT3DRMFRAME3 reference,
1480                                                         LPD3DVECTOR return_position)
1481 {
1482     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1483
1484     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, reference, return_position);
1485
1486     return E_NOTIMPL;
1487 }
1488
1489 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetRotation(IDirect3DRMFrame3* iface,
1490                                                         LPDIRECT3DRMFRAME3 reference,
1491                                                         LPD3DVECTOR axis, LPD3DVALUE return_theta)
1492 {
1493     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1494
1495     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, axis, return_theta);
1496
1497     return E_NOTIMPL;
1498 }
1499
1500 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetScene(IDirect3DRMFrame3* iface,
1501                                                      LPDIRECT3DRMFRAME3 * frame)
1502 {
1503     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1504
1505     FIXME("(%p/%p)->(%p): stub\n", iface, This, frame);
1506
1507     return E_NOTIMPL;
1508 }
1509
1510 static D3DRMSORTMODE WINAPI IDirect3DRMFrame3Impl_GetSortMode(IDirect3DRMFrame3* iface)
1511 {
1512     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1513
1514     FIXME("(%p/%p)->(): stub\n", iface, This);
1515
1516     return D3DRMSORT_FROMPARENT;
1517 }
1518
1519 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetTexture(IDirect3DRMFrame3* iface,
1520                                                        LPDIRECT3DRMTEXTURE3 * tex)
1521 {
1522     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1523
1524     FIXME("(%p/%p)->(%p): stub\n", iface, This, tex);
1525
1526     return E_NOTIMPL;
1527 }
1528
1529 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetTransform(IDirect3DRMFrame3* iface,
1530                                                          LPDIRECT3DRMFRAME3 reference,
1531                                                          D3DRMMATRIX4D return_matrix)
1532 {
1533     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1534
1535     TRACE("(%p/%p)->(%p,%p)\n", iface, This, reference, return_matrix);
1536
1537     if (reference)
1538         FIXME("Specifying a frame as the root of the scene different from the current root frame is not supported yet\n");
1539
1540     memcpy(&return_matrix[0][0], &This->transform[0][0], sizeof(D3DRMMATRIX4D));
1541
1542     return D3DRM_OK;
1543 }
1544
1545 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetVelocity(IDirect3DRMFrame3* iface,
1546                                                         LPDIRECT3DRMFRAME3 reference,
1547                                                         LPD3DVECTOR return_velocity,
1548                                                         BOOL with_rotation)
1549 {
1550     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1551
1552     FIXME("(%p/%p)->(%p,%p,%d): stub\n", iface, This, reference, return_velocity, with_rotation);
1553
1554     return E_NOTIMPL;
1555 }
1556
1557 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetOrientation(IDirect3DRMFrame3* iface,
1558                                                            LPDIRECT3DRMFRAME3 reference,
1559                                                            LPD3DVECTOR dir, LPD3DVECTOR up)
1560 {
1561     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1562
1563     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, reference, dir, up);
1564
1565     return E_NOTIMPL;
1566 }
1567
1568 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetVisuals(IDirect3DRMFrame3* iface, LPDWORD num,
1569                                                        LPUNKNOWN *visuals)
1570 {
1571     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1572
1573     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, num, visuals);
1574
1575     return E_NOTIMPL;
1576 }
1577
1578 static HRESULT WINAPI IDirect3DRMFrame3Impl_InverseTransform(IDirect3DRMFrame3* iface,
1579                                                              D3DVECTOR *d, D3DVECTOR *s)
1580 {
1581     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1582
1583     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
1584
1585     return E_NOTIMPL;
1586 }
1587
1588 static HRESULT WINAPI IDirect3DRMFrame3Impl_Load(IDirect3DRMFrame3* iface, LPVOID filename,
1589                                                  LPVOID name, D3DRMLOADOPTIONS loadflags,
1590                                                  D3DRMLOADTEXTURE3CALLBACK cb, LPVOID lpArg)
1591 {
1592     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1593
1594     FIXME("(%p/%p)->(%p,%p,%u,%p,%p): stub\n", iface, This, filename, name, loadflags, cb, lpArg);
1595
1596     return E_NOTIMPL;
1597 }
1598
1599 static HRESULT WINAPI IDirect3DRMFrame3Impl_LookAt(IDirect3DRMFrame3* iface,
1600                                                    LPDIRECT3DRMFRAME3 target,
1601                                                    LPDIRECT3DRMFRAME3 reference,
1602                                                    D3DRMFRAMECONSTRAINT constraint)
1603 {
1604     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1605
1606     FIXME("(%p/%p)->(%p,%p,%u): stub\n", iface, This, target, reference, constraint);
1607
1608     return E_NOTIMPL;
1609 }
1610
1611 static HRESULT WINAPI IDirect3DRMFrame3Impl_Move(IDirect3DRMFrame3* iface, D3DVALUE delta)
1612 {
1613     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1614
1615     FIXME("(%p/%p)->(%f): stub\n", iface, This, delta);
1616
1617     return E_NOTIMPL;
1618 }
1619
1620 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteChild(IDirect3DRMFrame3* iface,
1621                                                         LPDIRECT3DRMFRAME3 frame)
1622 {
1623     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1624     IDirect3DRMFrameImpl *frame_obj = unsafe_impl_from_IDirect3DRMFrame3(frame);
1625     ULONG i;
1626
1627     TRACE("(%p/%p)->(%p)\n", iface, This, frame);
1628
1629     if (!frame_obj)
1630         return D3DRMERR_BADOBJECT;
1631
1632     /* Check if child exists */
1633     for (i = 0; i < This->nb_children; i++)
1634         if (This->children[i] == frame)
1635             break;
1636
1637     if (i == This->nb_children)
1638         return D3DRMERR_BADVALUE;
1639
1640     memmove(This->children + i, This->children + i + 1, sizeof(IDirect3DRMFrame3*) * (This->nb_children - 1 - i));
1641     IDirect3DRMFrame3_Release(frame);
1642     frame_obj->parent = NULL;
1643     This->nb_children--;
1644
1645     return D3DRM_OK;
1646 }
1647
1648 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteLight(IDirect3DRMFrame3* iface,
1649                                                           LPDIRECT3DRMLIGHT light)
1650 {
1651     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1652     ULONG i;
1653
1654     TRACE("(%p/%p)->(%p)\n", iface, This, light);
1655
1656     if (!light)
1657         return D3DRMERR_BADOBJECT;
1658
1659     /* Check if visual exists */
1660     for (i = 0; i < This->nb_lights; i++)
1661         if (This->lights[i] == light)
1662             break;
1663
1664     if (i == This->nb_lights)
1665         return D3DRMERR_BADVALUE;
1666
1667     memmove(This->lights + i, This->lights + i + 1, sizeof(IDirect3DRMLight*) * (This->nb_lights - 1 - i));
1668     IDirect3DRMLight_Release(light);
1669     This->nb_lights--;
1670
1671     return D3DRM_OK;
1672 }
1673
1674 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteMoveCallback(IDirect3DRMFrame3* iface,
1675                                                                D3DRMFRAME3MOVECALLBACK cb,
1676                                                                VOID *arg)
1677 {
1678     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1679
1680     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, cb, arg);
1681
1682     return E_NOTIMPL;
1683 }
1684
1685 static HRESULT WINAPI IDirect3DRMFrame3Impl_DeleteVisual(IDirect3DRMFrame3* iface, LPUNKNOWN vis)
1686 {
1687     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1688     ULONG i;
1689
1690     TRACE("(%p/%p)->(%p)\n", iface, This, vis);
1691
1692     if (!vis)
1693         return D3DRMERR_BADOBJECT;
1694
1695     /* Check if visual exists */
1696     for (i = 0; i < This->nb_visuals; i++)
1697         if (This->visuals[i] == (IDirect3DRMVisual*)vis)
1698             break;
1699
1700     if (i == This->nb_visuals)
1701         return D3DRMERR_BADVALUE;
1702
1703     memmove(This->visuals + i, This->visuals + i + 1, sizeof(IDirect3DRMVisual*) * (This->nb_visuals - 1 - i));
1704     IDirect3DRMVisual_Release(vis);
1705     This->nb_visuals--;
1706
1707     return D3DRM_OK;
1708 }
1709
1710 static D3DCOLOR WINAPI IDirect3DRMFrame3Impl_GetSceneBackground(IDirect3DRMFrame3* iface)
1711 {
1712     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1713
1714     FIXME("(%p/%p)->(): stub\n", iface, This);
1715
1716     return 0;
1717 }
1718
1719 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetSceneBackgroundDepth(IDirect3DRMFrame3* iface,
1720                                                                     LPDIRECTDRAWSURFACE * surface)
1721 {
1722     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1723
1724     FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
1725
1726     return E_NOTIMPL;
1727 }
1728
1729 static D3DCOLOR WINAPI IDirect3DRMFrame3Impl_GetSceneFogColor(IDirect3DRMFrame3* iface)
1730 {
1731     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1732
1733     FIXME("(%p/%p)->(): stub\n", iface, This);
1734
1735     return 0;
1736 }
1737
1738 static BOOL WINAPI IDirect3DRMFrame3Impl_GetSceneFogEnable(IDirect3DRMFrame3* iface)
1739 {
1740     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1741
1742     FIXME("(%p/%p)->(): stub\n", iface, This);
1743
1744     return FALSE;
1745 }
1746
1747 static D3DRMFOGMODE WINAPI IDirect3DRMFrame3Impl_GetSceneFogMode(IDirect3DRMFrame3* iface)
1748 {
1749     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1750
1751     FIXME("(%p/%p)->(): stub\n", iface, This);
1752
1753     return D3DRMFOG_LINEAR;
1754 }
1755
1756 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetSceneFogParams(IDirect3DRMFrame3* iface,
1757                                                               D3DVALUE *return_start,
1758                                                               D3DVALUE *return_end,
1759                                                               D3DVALUE *return_density)
1760 {
1761     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1762
1763     FIXME("(%p/%p)->(%p,%p,%p): stub\n", iface, This, return_start, return_end, return_density);
1764
1765     return E_NOTIMPL;
1766 }
1767
1768 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackground(IDirect3DRMFrame3* iface,
1769                                                                D3DCOLOR color)
1770 {
1771     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1772
1773     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
1774
1775     return E_NOTIMPL;
1776 }
1777
1778 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackgroundRGB(IDirect3DRMFrame3* iface,
1779                                                                   D3DVALUE red, D3DVALUE green,
1780                                                                   D3DVALUE blue)
1781 {
1782     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1783
1784     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
1785
1786     return E_NOTIMPL;
1787 }
1788
1789 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackgroundDepth(IDirect3DRMFrame3* iface,
1790                                                                     LPDIRECTDRAWSURFACE surface)
1791 {
1792     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1793
1794     FIXME("(%p/%p)->(%p): stub\n", iface, This, surface);
1795
1796     return E_NOTIMPL;
1797 }
1798
1799 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneBackgroundImage(IDirect3DRMFrame3* iface,
1800                                                                     LPDIRECT3DRMTEXTURE3 texture)
1801 {
1802     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1803
1804     FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
1805
1806     return E_NOTIMPL;
1807 }
1808
1809 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogEnable(IDirect3DRMFrame3* iface, BOOL enable)
1810 {
1811     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1812
1813     FIXME("(%p/%p)->(%d): stub\n", iface, This, enable);
1814
1815     return E_NOTIMPL;
1816 }
1817
1818 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogColor(IDirect3DRMFrame3* iface,
1819                                                              D3DCOLOR color)
1820 {
1821     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1822
1823     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
1824
1825     return E_NOTIMPL;
1826 }
1827
1828 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogMode(IDirect3DRMFrame3* iface,
1829                                                             D3DRMFOGMODE mode)
1830 {
1831     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1832
1833     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1834
1835     return E_NOTIMPL;
1836 }
1837
1838 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogParams(IDirect3DRMFrame3* iface,
1839                                                               D3DVALUE start, D3DVALUE end,
1840                                                               D3DVALUE density)
1841 {
1842     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1843
1844     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, start, end, density);
1845
1846     return E_NOTIMPL;
1847 }
1848
1849 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetColor(IDirect3DRMFrame3* iface, D3DCOLOR color)
1850 {
1851     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1852
1853     FIXME("(%p/%p)->(%u): stub\n", iface, This, color);
1854
1855     return E_NOTIMPL;
1856 }
1857
1858 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetColorRGB(IDirect3DRMFrame3* iface, D3DVALUE red,
1859                                                         D3DVALUE green, D3DVALUE blue)
1860 {
1861     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1862
1863     FIXME("(%p/%p)->(%f,%f,%f): stub\n", iface, This, red, green, blue);
1864
1865     return E_NOTIMPL;
1866 }
1867
1868 static D3DRMZBUFFERMODE WINAPI IDirect3DRMFrame3Impl_GetZbufferMode(IDirect3DRMFrame3* iface)
1869 {
1870     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1871
1872     FIXME("(%p/%p)->(): stub\n", iface, This);
1873
1874     return D3DRMZBUFFER_FROMPARENT;
1875 }
1876
1877 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetMaterialMode(IDirect3DRMFrame3* iface,
1878                                                             D3DRMMATERIALMODE mode)
1879 {
1880     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1881
1882     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1883
1884     return E_NOTIMPL;
1885 }
1886
1887 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetOrientation(IDirect3DRMFrame3* iface,
1888                                                            LPDIRECT3DRMFRAME3 reference,
1889                                                            D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
1890                                                            D3DVALUE ux, D3DVALUE uy, D3DVALUE uz )
1891 {
1892     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1893
1894     FIXME("(%p/%p)->(%p,%f,%f,%f,%f,%f,%f): stub\n", iface, This, reference,
1895           dx, dy, dz, ux, uy, uz);
1896
1897     return E_NOTIMPL;
1898 }
1899
1900 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetPosition(IDirect3DRMFrame3* iface,
1901                                                         LPDIRECT3DRMFRAME3 reference,
1902                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z)
1903 {
1904     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1905
1906     FIXME("(%p/%p)->(%p,%f,%f,%f): stub\n", iface, This, reference, x, y, z);
1907
1908     return E_NOTIMPL;
1909 }
1910
1911 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetRotation(IDirect3DRMFrame3* iface,
1912                                                         LPDIRECT3DRMFRAME3 reference,
1913                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
1914                                                         D3DVALUE theta)
1915 {
1916     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1917
1918     FIXME("(%p/%p)->(%p,%f,%f,%f,%f): stub\n", iface, This, reference, x, y, z, theta);
1919
1920     return E_NOTIMPL;
1921 }
1922
1923 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSortMode(IDirect3DRMFrame3* iface,
1924                                                         D3DRMSORTMODE mode)
1925 {
1926     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1927
1928     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1929
1930     return E_NOTIMPL;
1931 }
1932
1933 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetTexture(IDirect3DRMFrame3* iface,
1934                                                        LPDIRECT3DRMTEXTURE3 texture)
1935 {
1936     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1937
1938     FIXME("(%p/%p)->(%p): stub\n", iface, This, texture);
1939
1940     return E_NOTIMPL;
1941 }
1942
1943 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetVelocity(IDirect3DRMFrame3* iface,
1944                                                         LPDIRECT3DRMFRAME3 reference,
1945                                                         D3DVALUE x, D3DVALUE y, D3DVALUE z,
1946                                                         BOOL with_rotation)
1947 {
1948     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1949
1950     FIXME("(%p/%p)->(%p,%f,%f,%f,%d): stub\n", iface, This, reference, x, y, z, with_rotation);
1951
1952     return E_NOTIMPL;
1953 }
1954
1955 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetZbufferMode(IDirect3DRMFrame3* iface,
1956                                                            D3DRMZBUFFERMODE mode)
1957 {
1958     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1959
1960     FIXME("(%p/%p)->(%u): stub\n", iface, This, mode);
1961
1962     return E_NOTIMPL;
1963 }
1964
1965 static HRESULT WINAPI IDirect3DRMFrame3Impl_Transform(IDirect3DRMFrame3* iface, D3DVECTOR *d,
1966                                                       D3DVECTOR *s)
1967 {
1968     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1969
1970     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, d, s);
1971
1972     return E_NOTIMPL;
1973 }
1974
1975 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetBox(IDirect3DRMFrame3* iface, LPD3DRMBOX box)
1976 {
1977     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1978
1979     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
1980
1981     return E_NOTIMPL;
1982 }
1983
1984 static BOOL WINAPI IDirect3DRMFrame3Impl_GetBoxEnable(IDirect3DRMFrame3* iface)
1985 {
1986     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1987
1988     FIXME("(%p/%p)->(): stub\n", iface, This);
1989
1990     return E_NOTIMPL;
1991 }
1992
1993 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetAxes(IDirect3DRMFrame3* iface,
1994                                                     LPD3DVECTOR dir, LPD3DVECTOR up)
1995 {
1996     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
1997
1998     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, dir, up);
1999
2000     return E_NOTIMPL;
2001 }
2002
2003 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetMaterial(IDirect3DRMFrame3* iface,
2004                                                         LPDIRECT3DRMMATERIAL2 *material)
2005 {
2006     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2007
2008     FIXME("(%p/%p)->(%p): stub\n", iface, This, material);
2009
2010     return E_NOTIMPL;
2011 }
2012
2013 static BOOL WINAPI IDirect3DRMFrame3Impl_GetInheritAxes(IDirect3DRMFrame3* iface)
2014 {
2015     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2016
2017     FIXME("(%p/%p)->(): stub\n", iface, This);
2018
2019     return E_NOTIMPL;
2020 }
2021
2022 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetHierarchyBox(IDirect3DRMFrame3* iface,
2023                                                             LPD3DRMBOX box)
2024 {
2025     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2026
2027     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
2028
2029     return E_NOTIMPL;
2030 }
2031
2032 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetBox(IDirect3DRMFrame3* iface, LPD3DRMBOX box)
2033 {
2034     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2035
2036     FIXME("(%p/%p)->(%p): stub\n", iface, This, box);
2037
2038     return E_NOTIMPL;
2039 }
2040
2041 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetBoxEnable(IDirect3DRMFrame3* iface, BOOL enable)
2042 {
2043     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2044
2045     FIXME("(%p/%p)->(%u): stub\n", iface, This, enable);
2046
2047     return E_NOTIMPL;
2048 }
2049
2050 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetAxes(IDirect3DRMFrame3* iface,
2051                                                     D3DVALUE dx, D3DVALUE dy, D3DVALUE dz,
2052                                                     D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2053 {
2054     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2055
2056     FIXME("(%p/%p)->(%f,%f,%f,%f,%f,%f): stub\n", iface, This, dx, dy, dz, ux, uy, uz);
2057
2058     return E_NOTIMPL;
2059 }
2060
2061 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetInheritAxes(IDirect3DRMFrame3* iface,
2062                                                            BOOL inherit_from_parent)
2063 {
2064     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2065
2066     FIXME("(%p/%p)->(%u): stub\n", iface, This, inherit_from_parent);
2067
2068     return E_NOTIMPL;
2069 }
2070
2071 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetMaterial(IDirect3DRMFrame3* iface,
2072                                                         LPDIRECT3DRMMATERIAL2 material)
2073 {
2074     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2075
2076     FIXME("(%p/%p)->(%p): stub\n", iface, This, material);
2077
2078     return E_NOTIMPL;
2079 }
2080
2081 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetQuaternion(IDirect3DRMFrame3* iface,
2082                                                           LPDIRECT3DRMFRAME3 reference,
2083                                                           D3DRMQUATERNION *q)
2084 {
2085     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2086
2087     FIXME("(%p/%p)->(%p,%p): stub\n", iface, This, reference, q);
2088
2089     return E_NOTIMPL;
2090 }
2091
2092 static HRESULT WINAPI IDirect3DRMFrame3Impl_RayPick(IDirect3DRMFrame3* iface,
2093                                                     LPDIRECT3DRMFRAME3 reference, LPD3DRMRAY ray,
2094                                                     DWORD flags,
2095                                                     LPDIRECT3DRMPICKED2ARRAY *return_visuals)
2096 {
2097     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2098
2099     FIXME("(%p/%p)->(%p,%p,%u,%p): stub\n", iface, This, reference, ray, flags, return_visuals);
2100
2101     return E_NOTIMPL;
2102 }
2103
2104 static HRESULT WINAPI IDirect3DRMFrame3Impl_Save(IDirect3DRMFrame3* iface, LPCSTR filename,
2105                                                  D3DRMXOFFORMAT d3dFormat,
2106                                                  D3DRMSAVEOPTIONS d3dSaveFlags)
2107 {
2108     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2109
2110     FIXME("(%p/%p)->(%p,%u,%u): stub\n", iface, This, filename, d3dFormat, d3dSaveFlags);
2111
2112     return E_NOTIMPL;
2113 }
2114
2115 static HRESULT WINAPI IDirect3DRMFrame3Impl_TransformVectors(IDirect3DRMFrame3* iface,
2116                                                              LPDIRECT3DRMFRAME3 reference,
2117                                                              DWORD num, LPD3DVECTOR dst,
2118                                                              LPD3DVECTOR src)
2119 {
2120     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2121
2122     FIXME("(%p/%p)->(%p,%u,%p,%p): stub\n", iface, This, reference, num, dst, src);
2123
2124     return E_NOTIMPL;
2125 }
2126
2127 static HRESULT WINAPI IDirect3DRMFrame3Impl_InverseTransformVectors(IDirect3DRMFrame3* iface,
2128                                                                     LPDIRECT3DRMFRAME3 reference,
2129                                                                     DWORD num, LPD3DVECTOR dst,
2130                                                                     LPD3DVECTOR src)
2131 {
2132     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2133
2134     FIXME("(%p/%p)->(%p,%u,%p,%p): stub\n", iface, This, reference, num, dst, src);
2135
2136     return E_NOTIMPL;
2137 }
2138
2139 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetTraversalOptions(IDirect3DRMFrame3* iface,
2140                                                                 DWORD flags)
2141 {
2142     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2143
2144     FIXME("(%p/%p)->(%u): stub\n", iface, This, flags);
2145
2146     return E_NOTIMPL;
2147 }
2148
2149 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetTraversalOptions(IDirect3DRMFrame3* iface,
2150                                                                 LPDWORD flags)
2151 {
2152     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2153
2154     FIXME("(%p/%p)->(%p): stub\n", iface, This, flags);
2155
2156     return E_NOTIMPL;
2157 }
2158
2159 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetSceneFogMethod(IDirect3DRMFrame3* iface,
2160                                                               DWORD flags)
2161 {
2162     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2163
2164     FIXME("(%p/%p)->(%u): stub\n", iface, This, flags);
2165
2166     return E_NOTIMPL;
2167 }
2168
2169 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetSceneFogMethod(IDirect3DRMFrame3* iface,
2170                                                               LPDWORD flags)
2171 {
2172     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2173
2174     FIXME("(%p/%p)->(%p): stub\n", iface, This, flags);
2175
2176     return E_NOTIMPL;
2177 }
2178
2179 static HRESULT WINAPI IDirect3DRMFrame3Impl_SetMaterialOverride(IDirect3DRMFrame3* iface,
2180                                                                 LPD3DRMMATERIALOVERRIDE override)
2181 {
2182     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2183
2184     FIXME("(%p/%p)->(%p): stub\n", iface, This, override);
2185
2186     return E_NOTIMPL;
2187 }
2188
2189 static HRESULT WINAPI IDirect3DRMFrame3Impl_GetMaterialOverride(IDirect3DRMFrame3* iface,
2190                                                                 LPD3DRMMATERIALOVERRIDE override)
2191 {
2192     IDirect3DRMFrameImpl *This = impl_from_IDirect3DRMFrame3(iface);
2193
2194     FIXME("(%p/%p)->(%p): stub\n", iface, This, override);
2195
2196     return E_NOTIMPL;
2197 }
2198
2199 static const struct IDirect3DRMFrame3Vtbl Direct3DRMFrame3_Vtbl =
2200 {
2201     /*** IUnknown methods ***/
2202     IDirect3DRMFrame3Impl_QueryInterface,
2203     IDirect3DRMFrame3Impl_AddRef,
2204     IDirect3DRMFrame3Impl_Release,
2205     /*** IDirect3DRMObject methods ***/
2206     IDirect3DRMFrame3Impl_Clone,
2207     IDirect3DRMFrame3Impl_AddDestroyCallback,
2208     IDirect3DRMFrame3Impl_DeleteDestroyCallback,
2209     IDirect3DRMFrame3Impl_SetAppData,
2210     IDirect3DRMFrame3Impl_GetAppData,
2211     IDirect3DRMFrame3Impl_SetName,
2212     IDirect3DRMFrame3Impl_GetName,
2213     IDirect3DRMFrame3Impl_GetClassName,
2214     /*** IDirect3DRMFrame3 methods ***/
2215     IDirect3DRMFrame3Impl_AddChild,
2216     IDirect3DRMFrame3Impl_AddLight,
2217     IDirect3DRMFrame3Impl_AddMoveCallback,
2218     IDirect3DRMFrame3Impl_AddTransform,
2219     IDirect3DRMFrame3Impl_AddTranslation,
2220     IDirect3DRMFrame3Impl_AddScale,
2221     IDirect3DRMFrame3Impl_AddRotation,
2222     IDirect3DRMFrame3Impl_AddVisual,
2223     IDirect3DRMFrame3Impl_GetChildren,
2224     IDirect3DRMFrame3Impl_GetColor,
2225     IDirect3DRMFrame3Impl_GetLights,
2226     IDirect3DRMFrame3Impl_GetMaterialMode,
2227     IDirect3DRMFrame3Impl_GetParent,
2228     IDirect3DRMFrame3Impl_GetPosition,
2229     IDirect3DRMFrame3Impl_GetRotation,
2230     IDirect3DRMFrame3Impl_GetScene,
2231     IDirect3DRMFrame3Impl_GetSortMode,
2232     IDirect3DRMFrame3Impl_GetTexture,
2233     IDirect3DRMFrame3Impl_GetTransform,
2234     IDirect3DRMFrame3Impl_GetVelocity,
2235     IDirect3DRMFrame3Impl_GetOrientation,
2236     IDirect3DRMFrame3Impl_GetVisuals,
2237     IDirect3DRMFrame3Impl_InverseTransform,
2238     IDirect3DRMFrame3Impl_Load,
2239     IDirect3DRMFrame3Impl_LookAt,
2240     IDirect3DRMFrame3Impl_Move,
2241     IDirect3DRMFrame3Impl_DeleteChild,
2242     IDirect3DRMFrame3Impl_DeleteLight,
2243     IDirect3DRMFrame3Impl_DeleteMoveCallback,
2244     IDirect3DRMFrame3Impl_DeleteVisual,
2245     IDirect3DRMFrame3Impl_GetSceneBackground,
2246     IDirect3DRMFrame3Impl_GetSceneBackgroundDepth,
2247     IDirect3DRMFrame3Impl_GetSceneFogColor,
2248     IDirect3DRMFrame3Impl_GetSceneFogEnable,
2249     IDirect3DRMFrame3Impl_GetSceneFogMode,
2250     IDirect3DRMFrame3Impl_GetSceneFogParams,
2251     IDirect3DRMFrame3Impl_SetSceneBackground,
2252     IDirect3DRMFrame3Impl_SetSceneBackgroundRGB,
2253     IDirect3DRMFrame3Impl_SetSceneBackgroundDepth,
2254     IDirect3DRMFrame3Impl_SetSceneBackgroundImage,
2255     IDirect3DRMFrame3Impl_SetSceneFogEnable,
2256     IDirect3DRMFrame3Impl_SetSceneFogColor,
2257     IDirect3DRMFrame3Impl_SetSceneFogMode,
2258     IDirect3DRMFrame3Impl_SetSceneFogParams,
2259     IDirect3DRMFrame3Impl_SetColor,
2260     IDirect3DRMFrame3Impl_SetColorRGB,
2261     IDirect3DRMFrame3Impl_GetZbufferMode,
2262     IDirect3DRMFrame3Impl_SetMaterialMode,
2263     IDirect3DRMFrame3Impl_SetOrientation,
2264     IDirect3DRMFrame3Impl_SetPosition,
2265     IDirect3DRMFrame3Impl_SetRotation,
2266     IDirect3DRMFrame3Impl_SetSortMode,
2267     IDirect3DRMFrame3Impl_SetTexture,
2268     IDirect3DRMFrame3Impl_SetVelocity,
2269     IDirect3DRMFrame3Impl_SetZbufferMode,
2270     IDirect3DRMFrame3Impl_Transform,
2271     IDirect3DRMFrame3Impl_GetBox,
2272     IDirect3DRMFrame3Impl_GetBoxEnable,
2273     IDirect3DRMFrame3Impl_GetAxes,
2274     IDirect3DRMFrame3Impl_GetMaterial,
2275     IDirect3DRMFrame3Impl_GetInheritAxes,
2276     IDirect3DRMFrame3Impl_GetHierarchyBox,
2277     IDirect3DRMFrame3Impl_SetBox,
2278     IDirect3DRMFrame3Impl_SetBoxEnable,
2279     IDirect3DRMFrame3Impl_SetAxes,
2280     IDirect3DRMFrame3Impl_SetInheritAxes,
2281     IDirect3DRMFrame3Impl_SetMaterial,
2282     IDirect3DRMFrame3Impl_SetQuaternion,
2283     IDirect3DRMFrame3Impl_RayPick,
2284     IDirect3DRMFrame3Impl_Save,
2285     IDirect3DRMFrame3Impl_TransformVectors,
2286     IDirect3DRMFrame3Impl_InverseTransformVectors,
2287     IDirect3DRMFrame3Impl_SetTraversalOptions,
2288     IDirect3DRMFrame3Impl_GetTraversalOptions,
2289     IDirect3DRMFrame3Impl_SetSceneFogMethod,
2290     IDirect3DRMFrame3Impl_GetSceneFogMethod,
2291     IDirect3DRMFrame3Impl_SetMaterialOverride,
2292     IDirect3DRMFrame3Impl_GetMaterialOverride
2293 };
2294
2295 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface)
2296 {
2297     if (!iface)
2298         return NULL;
2299     assert(iface->lpVtbl == &Direct3DRMFrame2_Vtbl);
2300
2301     return impl_from_IDirect3DRMFrame2(iface);
2302 }
2303
2304 static inline IDirect3DRMFrameImpl *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
2305 {
2306     if (!iface)
2307         return NULL;
2308     assert(iface->lpVtbl == &Direct3DRMFrame3_Vtbl);
2309
2310     return impl_from_IDirect3DRMFrame3(iface);
2311 }
2312
2313 HRESULT Direct3DRMFrame_create(REFIID riid, IUnknown* parent, IUnknown** ret_iface)
2314 {
2315     IDirect3DRMFrameImpl* object;
2316
2317     TRACE("(%s, %p, %p)\n", wine_dbgstr_guid(riid), parent, ret_iface);
2318
2319     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMFrameImpl));
2320     if (!object)
2321     {
2322         ERR("Out of memory\n");
2323         return E_OUTOFMEMORY;
2324     }
2325
2326     object->IDirect3DRMFrame2_iface.lpVtbl = &Direct3DRMFrame2_Vtbl;
2327     object->IDirect3DRMFrame3_iface.lpVtbl = &Direct3DRMFrame3_Vtbl;
2328     object->ref = 1;
2329
2330     memcpy(&object->transform[0][0], &identity[0][0], sizeof(D3DRMMATRIX4D));
2331
2332     if (IsEqualGUID(riid, &IID_IDirect3DRMFrame3))
2333     {
2334         if (parent)
2335             IDirect3DRMFrame3_AddChild((IDirect3DRMFrame3*)parent, &object->IDirect3DRMFrame3_iface);
2336         *ret_iface = (IUnknown*)&object->IDirect3DRMFrame3_iface;
2337     }
2338     else
2339     {
2340         if (parent)
2341             IDirect3DRMFrame2_AddChild((IDirect3DRMFrame2*)parent, (IDirect3DRMFrame*)&object->IDirect3DRMFrame2_iface);
2342         *ret_iface = (IUnknown*)&object->IDirect3DRMFrame2_iface;
2343     }
2344
2345     return S_OK;
2346 }
2347
2348 /*** IUnknown methods ***/
2349 static HRESULT WINAPI IDirect3DRMFrameArrayImpl_QueryInterface(IDirect3DRMFrameArray* iface,
2350                                                                REFIID riid, void** object)
2351 {
2352     IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
2353
2354     TRACE("(%p/%p)->(%s, %p)\n", iface, This, debugstr_guid(riid), object);
2355
2356     *object = NULL;
2357
2358     if (IsEqualGUID(riid, &IID_IUnknown) ||
2359         IsEqualGUID(riid, &IID_IDirect3DRMFrameArray))
2360     {
2361         *object = &This->IDirect3DRMFrameArray_iface;
2362     }
2363     else
2364     {
2365         FIXME("interface %s not implemented\n", debugstr_guid(riid));
2366         return E_NOINTERFACE;
2367     }
2368
2369     IDirect3DRMFrameArray_AddRef(iface);
2370     return S_OK;
2371 }
2372
2373 static ULONG WINAPI IDirect3DRMFrameArrayImpl_AddRef(IDirect3DRMFrameArray* iface)
2374 {
2375     IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
2376     ULONG ref = InterlockedIncrement(&This->ref);
2377
2378     TRACE("(%p)->(): new ref = %u\n", This, ref);
2379
2380     return ref;
2381 }
2382
2383 static ULONG WINAPI IDirect3DRMFrameArrayImpl_Release(IDirect3DRMFrameArray* iface)
2384 {
2385     IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
2386     ULONG ref = InterlockedDecrement(&This->ref);
2387     ULONG i;
2388
2389     TRACE("(%p)->(): new ref = %u\n", This, ref);
2390
2391     if (!ref)
2392     {
2393         for (i = 0; i < This->size; i++)
2394             IDirect3DRMFrame_Release(This->frames[i]);
2395         HeapFree(GetProcessHeap(), 0, This->frames);
2396         HeapFree(GetProcessHeap(), 0, This);
2397     }
2398
2399     return ref;
2400 }
2401
2402 /*** IDirect3DRMArray methods ***/
2403 static DWORD WINAPI IDirect3DRMFrameArrayImpl_GetSize(IDirect3DRMFrameArray* iface)
2404 {
2405     IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
2406
2407     TRACE("(%p)->() = %d\n", This,  This->size);
2408
2409     return This->size;
2410 }
2411
2412 /*** IDirect3DRMFrameArray methods ***/
2413 static HRESULT WINAPI IDirect3DRMFrameArrayImpl_GetElement(IDirect3DRMFrameArray* iface, DWORD index, LPDIRECT3DRMFRAME* frame)
2414 {
2415     IDirect3DRMFrameArrayImpl *This = (IDirect3DRMFrameArrayImpl*)iface;
2416
2417     TRACE("(%p)->(%u, %p)\n", This, index, frame);
2418
2419     if (!frame)
2420         return D3DRMERR_BADVALUE;
2421
2422     *frame = NULL;
2423
2424     if (index >= This->size)
2425         return D3DRMERR_BADVALUE;
2426
2427     IDirect3DRMFrame_AddRef(This->frames[index]);
2428     *frame = This->frames[index];
2429
2430     return D3DRM_OK;
2431 }
2432
2433 static const struct IDirect3DRMFrameArrayVtbl Direct3DRMFrameArray_Vtbl =
2434 {
2435     /*** IUnknown methods ***/
2436     IDirect3DRMFrameArrayImpl_QueryInterface,
2437     IDirect3DRMFrameArrayImpl_AddRef,
2438     IDirect3DRMFrameArrayImpl_Release,
2439     /*** IDirect3DRMArray methods ***/
2440     IDirect3DRMFrameArrayImpl_GetSize,
2441     /*** IDirect3DRMFrameArray methods ***/
2442     IDirect3DRMFrameArrayImpl_GetElement
2443 };
2444
2445 HRESULT Direct3DRMFrameArray_create(IDirect3DRMFrameArray** obj)
2446 {
2447     IDirect3DRMFrameArrayImpl* object;
2448
2449     TRACE("(%p)\n", obj);
2450
2451     *obj = NULL;
2452
2453     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMFrameArrayImpl));
2454     if (!object)
2455     {
2456         ERR("Out of memory\n");
2457         return E_OUTOFMEMORY;
2458     }
2459
2460     object->IDirect3DRMFrameArray_iface.lpVtbl = &Direct3DRMFrameArray_Vtbl;
2461     object->ref = 1;
2462
2463     *obj = &object->IDirect3DRMFrameArray_iface;
2464
2465     return S_OK;
2466 }
2467
2468 /*** IUnknown methods ***/
2469 static HRESULT WINAPI IDirect3DRMVisualArrayImpl_QueryInterface(IDirect3DRMVisualArray* iface,
2470                                                                 REFIID riid, void** ret_iface)
2471 {
2472     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ret_iface);
2473
2474     if (IsEqualGUID(riid, &IID_IUnknown) ||
2475         IsEqualGUID(riid, &IID_IDirect3DRMFrameArray))
2476     {
2477         *ret_iface = iface;
2478         IDirect3DRMVisualArray_AddRef(iface);
2479         return S_OK;
2480     }
2481
2482     *ret_iface = NULL;
2483
2484     WARN("Interface %s not implemented\n", debugstr_guid(riid));
2485
2486     return E_NOINTERFACE;
2487 }
2488
2489 static ULONG WINAPI IDirect3DRMVisualArrayImpl_AddRef(IDirect3DRMVisualArray* iface)
2490 {
2491     IDirect3DRMVisualArrayImpl *This = (IDirect3DRMVisualArrayImpl*)iface;
2492     ULONG ref = InterlockedIncrement(&This->ref);
2493
2494     TRACE("(%p)->(): new ref = %u\n", iface, ref);
2495
2496     return ref;
2497 }
2498
2499 static ULONG WINAPI IDirect3DRMVisualArrayImpl_Release(IDirect3DRMVisualArray* iface)
2500 {
2501     IDirect3DRMVisualArrayImpl *This = (IDirect3DRMVisualArrayImpl*)iface;
2502     ULONG ref = InterlockedDecrement(&This->ref);
2503     ULONG i;
2504
2505     TRACE("(%p)->(): new ref = %u\n", iface, ref);
2506
2507     if (!ref)
2508     {
2509         for (i = 0; i < This->size; i++)
2510             IDirect3DRMVisual_Release(This->visuals[i]);
2511         HeapFree(GetProcessHeap(), 0, This->visuals);
2512         HeapFree(GetProcessHeap(), 0, This);
2513     }
2514
2515     return ref;
2516 }
2517
2518 /*** IDirect3DRMArray methods ***/
2519 static DWORD WINAPI IDirect3DRMVisualArrayImpl_GetSize(IDirect3DRMVisualArray* iface)
2520 {
2521     IDirect3DRMVisualArrayImpl *This = (IDirect3DRMVisualArrayImpl*)iface;
2522
2523     TRACE("(%p)->() = %d\n", iface,  This->size);
2524
2525     return This->size;
2526 }
2527
2528 /*** IDirect3DRMVisualArray methods ***/
2529 static HRESULT WINAPI IDirect3DRMVisualArrayImpl_GetElement(IDirect3DRMVisualArray* iface, DWORD index, LPDIRECT3DRMVISUAL* visual)
2530 {
2531     IDirect3DRMVisualArrayImpl *This = (IDirect3DRMVisualArrayImpl*)iface;
2532
2533     TRACE("(%p)->(%u, %p)\n", iface, index, visual);
2534
2535     if (!visual)
2536         return D3DRMERR_BADVALUE;
2537
2538     *visual = NULL;
2539
2540     if (index >= This->size)
2541         return D3DRMERR_BADVALUE;
2542
2543     IDirect3DRMVisual_AddRef(This->visuals[index]);
2544     *visual = This->visuals[index];
2545
2546     return D3DRM_OK;
2547 }
2548
2549 static const struct IDirect3DRMVisualArrayVtbl Direct3DRMVisualArray_Vtbl =
2550 {
2551     /*** IUnknown methods ***/
2552     IDirect3DRMVisualArrayImpl_QueryInterface,
2553     IDirect3DRMVisualArrayImpl_AddRef,
2554     IDirect3DRMVisualArrayImpl_Release,
2555     /*** IDirect3DRMArray methods ***/
2556     IDirect3DRMVisualArrayImpl_GetSize,
2557     /*** IDirect3DRMVisualArray methods ***/
2558     IDirect3DRMVisualArrayImpl_GetElement
2559 };
2560
2561 HRESULT Direct3DRMVisualArray_create(IDirect3DRMVisualArray** ret_iface)
2562 {
2563     IDirect3DRMVisualArrayImpl* object;
2564
2565     TRACE("(%p)\n", ret_iface);
2566
2567     *ret_iface = NULL;
2568
2569     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMVisualArrayImpl));
2570     if (!object)
2571     {
2572         ERR("Out of memory\n");
2573         return E_OUTOFMEMORY;
2574     }
2575
2576     object->IDirect3DRMVisualArray_iface.lpVtbl = &Direct3DRMVisualArray_Vtbl;
2577     object->ref = 1;
2578
2579     *ret_iface = &object->IDirect3DRMVisualArray_iface;
2580
2581     return S_OK;
2582 }
2583
2584 /*** IUnknown methods ***/
2585 static HRESULT WINAPI IDirect3DRMLightArrayImpl_QueryInterface(IDirect3DRMLightArray* iface,
2586                                                                REFIID riid, void** object)
2587 {
2588     IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
2589
2590     TRACE("(%p/%p)->(%s, %p)\n", iface, This, debugstr_guid(riid), object);
2591
2592     *object = NULL;
2593
2594     if (IsEqualGUID(riid, &IID_IUnknown) ||
2595         IsEqualGUID(riid, &IID_IDirect3DRMLightArray))
2596     {
2597         *object = &This->IDirect3DRMLightArray_iface;
2598     }
2599     else
2600     {
2601         FIXME("interface %s not implemented\n", debugstr_guid(riid));
2602         return E_NOINTERFACE;
2603     }
2604
2605     IDirect3DRMLightArray_AddRef(iface);
2606     return S_OK;
2607 }
2608
2609 static ULONG WINAPI IDirect3DRMLightArrayImpl_AddRef(IDirect3DRMLightArray* iface)
2610 {
2611     IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
2612     ULONG ref = InterlockedIncrement(&This->ref);
2613
2614     TRACE("(%p)->(): new ref = %u\n", This, ref);
2615
2616     return ref;
2617 }
2618
2619 static ULONG WINAPI IDirect3DRMLightArrayImpl_Release(IDirect3DRMLightArray* iface)
2620 {
2621     IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
2622     ULONG ref = InterlockedDecrement(&This->ref);
2623     ULONG i;
2624
2625     TRACE("(%p)->(): new ref = %u\n", This, ref);
2626
2627     if (!ref)
2628     {
2629         for (i = 0; i < This->size; i++)
2630             IDirect3DRMLight_Release(This->lights[i]);
2631         HeapFree(GetProcessHeap(), 0, This->lights);
2632         HeapFree(GetProcessHeap(), 0, This);
2633     }
2634
2635     return ref;
2636 }
2637
2638 /*** IDirect3DRMArray methods ***/
2639 static DWORD WINAPI IDirect3DRMLightArrayImpl_GetSize(IDirect3DRMLightArray* iface)
2640 {
2641     IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
2642
2643     TRACE("(%p)->() = %d\n", This,  This->size);
2644
2645     return This->size;
2646 }
2647
2648 /*** IDirect3DRMLightArray methods ***/
2649 static HRESULT WINAPI IDirect3DRMLightArrayImpl_GetElement(IDirect3DRMLightArray* iface, DWORD index, LPDIRECT3DRMLIGHT* light)
2650 {
2651     IDirect3DRMLightArrayImpl *This = impl_from_IDirect3DRMLightArray(iface);
2652
2653     TRACE("(%p)->(%u, %p)\n", This, index, light);
2654
2655     if (!light)
2656         return D3DRMERR_BADVALUE;
2657
2658     *light = NULL;
2659
2660     if (index >= This->size)
2661         return D3DRMERR_BADVALUE;
2662
2663     IDirect3DRMLight_AddRef(This->lights[index]);
2664     *light = This->lights[index];
2665
2666     return D3DRM_OK;
2667 }
2668
2669 static const struct IDirect3DRMLightArrayVtbl Direct3DRMLightArray_Vtbl =
2670 {
2671     /*** IUnknown methods ***/
2672     IDirect3DRMLightArrayImpl_QueryInterface,
2673     IDirect3DRMLightArrayImpl_AddRef,
2674     IDirect3DRMLightArrayImpl_Release,
2675     /*** IDirect3DRMArray methods ***/
2676     IDirect3DRMLightArrayImpl_GetSize,
2677     /*** IDirect3DRMLightArray methods ***/
2678     IDirect3DRMLightArrayImpl_GetElement
2679 };
2680
2681 HRESULT Direct3DRMLightArray_create(IDirect3DRMLightArray** obj)
2682 {
2683     IDirect3DRMLightArrayImpl* object;
2684
2685     TRACE("(%p)\n", obj);
2686
2687     *obj = NULL;
2688
2689     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirect3DRMLightArrayImpl));
2690     if (!object)
2691     {
2692         ERR("Out of memory\n");
2693         return E_OUTOFMEMORY;
2694     }
2695
2696     object->IDirect3DRMLightArray_iface.lpVtbl = &Direct3DRMLightArray_Vtbl;
2697     object->ref = 1;
2698
2699     *obj = &object->IDirect3DRMLightArray_iface;
2700
2701     return S_OK;
2702 }