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

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