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