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

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