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