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 "d3drm_private.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(d3drm);
  25
  26 static const struct d3drm_matrix identity =
  27 {
  28     1.0f, 0.0f, 0.0f, 0.0f,
  29     0.0f, 1.0f, 0.0f, 0.0f,
  30     0.0f, 0.0f, 1.0f, 0.0f,
  31     0.0f, 0.0f, 0.0f, 1.0f,
  32 };
  33
  34 struct d3drm_frame_array
  35 {
  36     IDirect3DRMFrameArray IDirect3DRMFrameArray_iface;
  37     LONG ref;
  38     ULONG size;
  39     IDirect3DRMFrame **frames;
  40 };
  41
  42 struct d3drm_visual_array
  43 {
  44     IDirect3DRMVisualArray IDirect3DRMVisualArray_iface;
  45     LONG ref;
  46     ULONG size;
  47     IDirect3DRMVisual **visuals;
  48 };
  49
  50 struct d3drm_light_array
  51 {
  52     IDirect3DRMLightArray IDirect3DRMLightArray_iface;
  53     LONG ref;
  54     ULONG size;
  55     IDirect3DRMLight **lights;
  56 };
  57
  58 static inline struct d3drm_frame *impl_from_IDirect3DRMFrame(IDirect3DRMFrame *iface)
  59 {
  60     return CONTAINING_RECORD(iface, struct d3drm_frame, IDirect3DRMFrame_iface);
  61 }
  62
  63 static inline struct d3drm_frame *impl_from_IDirect3DRMFrame2(IDirect3DRMFrame2 *iface)
  64 {
  65     return CONTAINING_RECORD(iface, struct d3drm_frame, IDirect3DRMFrame2_iface);
  66 }
  67
  68 static inline struct d3drm_frame *impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
  69 {
  70     return CONTAINING_RECORD(iface, struct d3drm_frame, IDirect3DRMFrame3_iface);
  71 }
  72
  73 static inline struct d3drm_frame_array *impl_from_IDirect3DRMFrameArray(IDirect3DRMFrameArray *iface)
  74 {
  75     return CONTAINING_RECORD(iface, struct d3drm_frame_array, IDirect3DRMFrameArray_iface);
  76 }
  77
  78 static inline struct d3drm_visual_array *impl_from_IDirect3DRMVisualArray(IDirect3DRMVisualArray *iface)
  79 {
  80     return CONTAINING_RECORD(iface, struct d3drm_visual_array, IDirect3DRMVisualArray_iface);
  81 }
  82
  83 static inline struct d3drm_light_array *impl_from_IDirect3DRMLightArray(IDirect3DRMLightArray *iface)
  84 {
  85     return CONTAINING_RECORD(iface, struct d3drm_light_array, IDirect3DRMLightArray_iface);
  86 }
  87
  88 static inline struct d3drm_animation *impl_from_IDirect3DRMAnimation(IDirect3DRMAnimation *iface)
  89 {
  90     return CONTAINING_RECORD(iface, struct d3drm_animation, IDirect3DRMAnimation_iface);
  91 }
  92
  93 static inline struct d3drm_animation *impl_from_IDirect3DRMAnimation2(IDirect3DRMAnimation2 *iface)
  94 {
  95     return CONTAINING_RECORD(iface, struct d3drm_animation, IDirect3DRMAnimation2_iface);
  96 }
  97
  98 static void d3drm_matrix_multiply_affine(struct d3drm_matrix *dst,
  99         const struct d3drm_matrix *src1, const struct d3drm_matrix *src2)
 100 {
 101     struct d3drm_matrix tmp;
 102
 103     tmp._11 = src1->_11 * src2->_11 + src1->_12 * src2->_21 + src1->_13 * src2->_31;
 104     tmp._12 = src1->_11 * src2->_12 + src1->_12 * src2->_22 + src1->_13 * src2->_32;
 105     tmp._13 = src1->_11 * src2->_13 + src1->_12 * src2->_23 + src1->_13 * src2->_33;
 106     tmp._14 = 0.0f;
 107
 108     tmp._21 = src1->_21 * src2->_11 + src1->_22 * src2->_21 + src1->_23 * src2->_31;
 109     tmp._22 = src1->_21 * src2->_12 + src1->_22 * src2->_22 + src1->_23 * src2->_32;
 110     tmp._23 = src1->_21 * src2->_13 + src1->_22 * src2->_23 + src1->_23 * src2->_33;
 111     tmp._24 = 0.0f;
 112
 113     tmp._31 = src1->_31 * src2->_11 + src1->_32 * src2->_21 + src1->_33 * src2->_31;
 114     tmp._32 = src1->_31 * src2->_12 + src1->_32 * src2->_22 + src1->_33 * src2->_32;
 115     tmp._33 = src1->_31 * src2->_13 + src1->_32 * src2->_23 + src1->_33 * src2->_33;
 116     tmp._34 = 0.0f;
 117
 118     tmp._41 = src1->_41 * src2->_11 + src1->_42 * src2->_21 + src1->_43 * src2->_31 + src2->_41;
 119     tmp._42 = src1->_41 * src2->_12 + src1->_42 * src2->_22 + src1->_43 * src2->_32 + src2->_42;
 120     tmp._43 = src1->_41 * src2->_13 + src1->_42 * src2->_23 + src1->_43 * src2->_33 + src2->_43;
 121     tmp._44 = 1.0f;
 122
 123     *dst = tmp;
 124 }
 125
 126 static void d3drm_matrix_set_rotation(struct d3drm_matrix *matrix, D3DVECTOR *axis, float theta)
 127 {
 128     float sin_theta, cos_theta, vers_theta;
 129
 130     D3DRMVectorNormalize(axis);
 131     sin_theta = sinf(theta);
 132     cos_theta = cosf(theta);
 133     vers_theta = 1.0f - cos_theta;
 134
 135     matrix->_11 = vers_theta * axis->u1.x * axis->u1.x + cos_theta;
 136     matrix->_21 = vers_theta * axis->u1.x * axis->u2.y - sin_theta * axis->u3.z;
 137     matrix->_31 = vers_theta * axis->u1.x * axis->u3.z + sin_theta * axis->u2.y;
 138     matrix->_41 = 0.0f;
 139
 140     matrix->_12 = vers_theta * axis->u2.y * axis->u1.x + sin_theta * axis->u3.z;
 141     matrix->_22 = vers_theta * axis->u2.y * axis->u2.y + cos_theta;
 142     matrix->_32 = vers_theta * axis->u2.y * axis->u3.z - sin_theta * axis->u1.x;
 143     matrix->_42 = 0.0f;
 144
 145     matrix->_13 = vers_theta * axis->u3.z * axis->u1.x - sin_theta * axis->u2.y;
 146     matrix->_23 = vers_theta * axis->u3.z * axis->u2.y + sin_theta * axis->u1.x;
 147     matrix->_33 = vers_theta * axis->u3.z * axis->u3.z + cos_theta;
 148     matrix->_43 = 0.0f;
 149
 150     matrix->_14 = 0.0f;
 151     matrix->_24 = 0.0f;
 152     matrix->_34 = 0.0f;
 153     matrix->_44 = 1.0f;
 154 }
 155
 156 static void d3drm_vector_transform_affine(D3DVECTOR *dst, const D3DVECTOR *v, const struct d3drm_matrix *m)
 157 {
 158     D3DVECTOR tmp;
 159
 160     tmp.u1.x = v->u1.x * m->_11 + v->u2.y * m->_21 + v->u3.z * m->_31 + m->_41;
 161     tmp.u2.y = v->u1.x * m->_12 + v->u2.y * m->_22 + v->u3.z * m->_32 + m->_42;
 162     tmp.u3.z = v->u1.x * m->_13 + v->u2.y * m->_23 + v->u3.z * m->_33 + m->_43;
 163
 164     *dst = tmp;
 165 }
 166
 167 static HRESULT WINAPI d3drm_frame_array_QueryInterface(IDirect3DRMFrameArray *iface, REFIID riid, void **out)
 168 {
 169     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 170
 171     if (IsEqualGUID(riid, &IID_IDirect3DRMFrameArray)
 172             || IsEqualGUID(riid, &IID_IUnknown))
 173     {
 174         IDirect3DRMFrameArray_AddRef(iface);
 175         *out = iface;
 176         return S_OK;
 177     }
 178
 179     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 180
 181     *out = NULL;
 182     return E_NOINTERFACE;
 183 }
 184
 185 static ULONG WINAPI d3drm_frame_array_AddRef(IDirect3DRMFrameArray *iface)
 186 {
 187     struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
 188     ULONG refcount = InterlockedIncrement(&array->ref);
 189
 190     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 191
 192     return refcount;
 193 }
 194
 195 static ULONG WINAPI d3drm_frame_array_Release(IDirect3DRMFrameArray *iface)
 196 {
 197     struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
 198     ULONG refcount = InterlockedDecrement(&array->ref);
 199     ULONG i;
 200
 201     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 202
 203     if (!refcount)
 204     {
 205         for (i = 0; i < array->size; ++i)
 206         {
 207             IDirect3DRMFrame_Release(array->frames[i]);
 208         }
 209         free(array->frames);
 210         free(array);
 211     }
 212
 213     return refcount;
 214 }
 215
 216 static DWORD WINAPI d3drm_frame_array_GetSize(IDirect3DRMFrameArray *iface)
 217 {
 218     struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
 219
 220     TRACE("iface %p.\n", iface);
 221
 222     return array->size;
 223 }
 224
 225 static HRESULT WINAPI d3drm_frame_array_GetElement(IDirect3DRMFrameArray *iface,
 226         DWORD index, IDirect3DRMFrame **frame)
 227 {
 228     struct d3drm_frame_array *array = impl_from_IDirect3DRMFrameArray(iface);
 229
 230     TRACE("iface %p, index %lu, frame %p.\n", iface, index, frame);
 231
 232     if (!frame)
 233         return D3DRMERR_BADVALUE;
 234
 235     if (index >= array->size)
 236     {
 237         *frame = NULL;
 238         return D3DRMERR_BADVALUE;
 239     }
 240
 241     IDirect3DRMFrame_AddRef(array->frames[index]);
 242     *frame = array->frames[index];
 243
 244     return D3DRM_OK;
 245 }
 246
 247 static const struct IDirect3DRMFrameArrayVtbl d3drm_frame_array_vtbl =
 248 {
 249     d3drm_frame_array_QueryInterface,
 250     d3drm_frame_array_AddRef,
 251     d3drm_frame_array_Release,
 252     d3drm_frame_array_GetSize,
 253     d3drm_frame_array_GetElement,
 254 };
 255
 256 static struct d3drm_frame_array *d3drm_frame_array_create(unsigned int frame_count, IDirect3DRMFrame3 **frames)
 257 {
 258     struct d3drm_frame_array *array;
 259     unsigned int i;
 260
 261     if (!(array = calloc(1, sizeof(*array))))
 262         return NULL;
 263
 264     array->IDirect3DRMFrameArray_iface.lpVtbl = &d3drm_frame_array_vtbl;
 265     array->ref = 1;
 266     array->size = frame_count;
 267
 268     if (frame_count)
 269     {
 270         if (!(array->frames = calloc(frame_count, sizeof(*array->frames))))
 271         {
 272             free(array);
 273             return NULL;
 274         }
 275
 276         for (i = 0; i < frame_count; ++i)
 277         {
 278             IDirect3DRMFrame3_QueryInterface(frames[i], &IID_IDirect3DRMFrame, (void **)&array->frames[i]);
 279         }
 280     }
 281
 282     return array;
 283 }
 284
 285 static HRESULT WINAPI d3drm_visual_array_QueryInterface(IDirect3DRMVisualArray *iface, REFIID riid, void **out)
 286 {
 287     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 288
 289     if (IsEqualGUID(riid, &IID_IDirect3DRMVisualArray)
 290             || IsEqualGUID(riid, &IID_IUnknown))
 291     {
 292         IDirect3DRMVisualArray_AddRef(iface);
 293         *out = iface;
 294         return S_OK;
 295     }
 296
 297     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 298
 299     *out = NULL;
 300     return E_NOINTERFACE;
 301 }
 302
 303 static ULONG WINAPI d3drm_visual_array_AddRef(IDirect3DRMVisualArray *iface)
 304 {
 305     struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
 306     ULONG refcount = InterlockedIncrement(&array->ref);
 307
 308     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 309
 310     return refcount;
 311 }
 312
 313 static ULONG WINAPI d3drm_visual_array_Release(IDirect3DRMVisualArray *iface)
 314 {
 315     struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
 316     ULONG refcount = InterlockedDecrement(&array->ref);
 317     ULONG i;
 318
 319     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 320
 321     if (!refcount)
 322     {
 323         for (i = 0; i < array->size; ++i)
 324         {
 325             IDirect3DRMVisual_Release(array->visuals[i]);
 326         }
 327         free(array->visuals);
 328         free(array);
 329     }
 330
 331     return refcount;
 332 }
 333
 334 static DWORD WINAPI d3drm_visual_array_GetSize(IDirect3DRMVisualArray *iface)
 335 {
 336     struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
 337
 338     TRACE("iface %p.\n", iface);
 339
 340     return array->size;
 341 }
 342
 343 static HRESULT WINAPI d3drm_visual_array_GetElement(IDirect3DRMVisualArray *iface,
 344         DWORD index, IDirect3DRMVisual **visual)
 345 {
 346     struct d3drm_visual_array *array = impl_from_IDirect3DRMVisualArray(iface);
 347
 348     TRACE("iface %p, index %lu, visual %p.\n", iface, index, visual);
 349
 350     if (!visual)
 351         return D3DRMERR_BADVALUE;
 352
 353     if (index >= array->size)
 354     {
 355         *visual = NULL;
 356         return D3DRMERR_BADVALUE;
 357     }
 358
 359     IDirect3DRMVisual_AddRef(array->visuals[index]);
 360     *visual = array->visuals[index];
 361
 362     return D3DRM_OK;
 363 }
 364
 365 static const struct IDirect3DRMVisualArrayVtbl d3drm_visual_array_vtbl =
 366 {
 367     d3drm_visual_array_QueryInterface,
 368     d3drm_visual_array_AddRef,
 369     d3drm_visual_array_Release,
 370     d3drm_visual_array_GetSize,
 371     d3drm_visual_array_GetElement,
 372 };
 373
 374 static struct d3drm_visual_array *d3drm_visual_array_create(unsigned int visual_count, IDirect3DRMVisual **visuals)
 375 {
 376     struct d3drm_visual_array *array;
 377     unsigned int i;
 378
 379     if (!(array = calloc(1, sizeof(*array))))
 380         return NULL;
 381
 382     array->IDirect3DRMVisualArray_iface.lpVtbl = &d3drm_visual_array_vtbl;
 383     array->ref = 1;
 384     array->size = visual_count;
 385
 386     if (visual_count)
 387     {
 388         if (!(array->visuals = calloc(visual_count, sizeof(*array->visuals))))
 389         {
 390             free(array);
 391             return NULL;
 392         }
 393
 394         for (i = 0; i < visual_count; ++i)
 395         {
 396             array->visuals[i] = visuals[i];
 397             IDirect3DRMVisual_AddRef(array->visuals[i]);
 398         }
 399     }
 400
 401     return array;
 402 }
 403
 404 static HRESULT WINAPI d3drm_light_array_QueryInterface(IDirect3DRMLightArray *iface, REFIID riid, void **out)
 405 {
 406     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 407
 408     if (IsEqualGUID(riid, &IID_IDirect3DRMLightArray)
 409             || IsEqualGUID(riid, &IID_IUnknown))
 410     {
 411         IDirect3DRMLightArray_AddRef(iface);
 412         *out = iface;
 413         return S_OK;
 414     }
 415
 416     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 417
 418     *out = NULL;
 419     return E_NOINTERFACE;
 420 }
 421
 422 static ULONG WINAPI d3drm_light_array_AddRef(IDirect3DRMLightArray *iface)
 423 {
 424     struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
 425     ULONG refcount = InterlockedIncrement(&array->ref);
 426
 427     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 428
 429     return refcount;
 430 }
 431
 432 static ULONG WINAPI d3drm_light_array_Release(IDirect3DRMLightArray *iface)
 433 {
 434     struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
 435     ULONG refcount = InterlockedDecrement(&array->ref);
 436     ULONG i;
 437
 438     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 439
 440     if (!refcount)
 441     {
 442         for (i = 0; i < array->size; ++i)
 443         {
 444             IDirect3DRMLight_Release(array->lights[i]);
 445         }
 446         free(array->lights);
 447         free(array);
 448     }
 449
 450     return refcount;
 451 }
 452
 453 static DWORD WINAPI d3drm_light_array_GetSize(IDirect3DRMLightArray *iface)
 454 {
 455     struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
 456
 457     TRACE("iface %p.\n", iface);
 458
 459     return array->size;
 460 }
 461
 462 static HRESULT WINAPI d3drm_light_array_GetElement(IDirect3DRMLightArray *iface,
 463         DWORD index, IDirect3DRMLight **light)
 464 {
 465     struct d3drm_light_array *array = impl_from_IDirect3DRMLightArray(iface);
 466
 467     TRACE("iface %p, index %lu, light %p.\n", iface, index, light);
 468
 469     if (!light)
 470         return D3DRMERR_BADVALUE;
 471
 472     if (index >= array->size)
 473     {
 474         *light = NULL;
 475         return D3DRMERR_BADVALUE;
 476     }
 477
 478     IDirect3DRMLight_AddRef(array->lights[index]);
 479     *light = array->lights[index];
 480
 481     return D3DRM_OK;
 482 }
 483
 484 static const struct IDirect3DRMLightArrayVtbl d3drm_light_array_vtbl =
 485 {
 486     d3drm_light_array_QueryInterface,
 487     d3drm_light_array_AddRef,
 488     d3drm_light_array_Release,
 489     d3drm_light_array_GetSize,
 490     d3drm_light_array_GetElement,
 491 };
 492
 493 static struct d3drm_light_array *d3drm_light_array_create(unsigned int light_count, IDirect3DRMLight **lights)
 494 {
 495     struct d3drm_light_array *array;
 496     unsigned int i;
 497
 498     if (!(array = calloc(1, sizeof(*array))))
 499         return NULL;
 500
 501     array->IDirect3DRMLightArray_iface.lpVtbl = &d3drm_light_array_vtbl;
 502     array->ref = 1;
 503     array->size = light_count;
 504
 505     if (light_count)
 506     {
 507         if (!(array->lights = calloc(light_count, sizeof(*array->lights))))
 508         {
 509             free(array);
 510             return NULL;
 511         }
 512
 513         for (i = 0; i < light_count; ++i)
 514         {
 515             array->lights[i] = lights[i];
 516             IDirect3DRMLight_AddRef(array->lights[i]);
 517         }
 518     }
 519
 520     return array;
 521 }
 522
 523 static HRESULT WINAPI d3drm_frame3_QueryInterface(IDirect3DRMFrame3 *iface, REFIID riid, void **out)
 524 {
 525     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
 526
 527     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 528
 529     if (IsEqualGUID(riid, &IID_IDirect3DRMFrame)
 530             || IsEqualGUID(riid, &IID_IDirect3DRMObject)
 531             || IsEqualGUID(riid, &IID_IDirect3DRMVisual)
 532             || IsEqualGUID(riid, &IID_IUnknown))
 533     {
 534         *out = &frame->IDirect3DRMFrame_iface;
 535     }
 536     else if (IsEqualGUID(riid, &IID_IDirect3DRMFrame2))
 537     {
 538         *out = &frame->IDirect3DRMFrame2_iface;
 539     }
 540     else if (IsEqualGUID(riid, &IID_IDirect3DRMFrame3))
 541     {
 542         *out = &frame->IDirect3DRMFrame3_iface;
 543     }
 544     else
 545     {
 546         *out = NULL;
 547         WARN("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(riid));
 548         return CLASS_E_CLASSNOTAVAILABLE;
 549     }
 550
 551     IUnknown_AddRef((IUnknown *)*out);
 552     return S_OK;
 553 }
 554
 555 static HRESULT WINAPI d3drm_frame2_QueryInterface(IDirect3DRMFrame2 *iface, REFIID riid, void **out)
 556 {
 557     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 558
 559     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 560
 561     return d3drm_frame3_QueryInterface(&frame->IDirect3DRMFrame3_iface, riid, out);
 562 }
 563
 564 static HRESULT WINAPI d3drm_frame1_QueryInterface(IDirect3DRMFrame *iface, REFIID riid, void **out)
 565 {
 566     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
 567
 568     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 569
 570     return d3drm_frame3_QueryInterface(&frame->IDirect3DRMFrame3_iface, riid, out);
 571 }
 572
 573 static ULONG WINAPI d3drm_frame3_AddRef(IDirect3DRMFrame3 *iface)
 574 {
 575     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
 576     ULONG refcount = InterlockedIncrement(&frame->ref);
 577
 578     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 579
 580     return refcount;
 581 }
 582
 583 static ULONG WINAPI d3drm_frame2_AddRef(IDirect3DRMFrame2 *iface)
 584 {
 585     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 586
 587     TRACE("iface %p.\n", iface);
 588
 589     return d3drm_frame3_AddRef(&frame->IDirect3DRMFrame3_iface);
 590 }
 591
 592 static ULONG WINAPI d3drm_frame1_AddRef(IDirect3DRMFrame *iface)
 593 {
 594     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
 595
 596     TRACE("iface %p.\n", iface);
 597
 598     return d3drm_frame3_AddRef(&frame->IDirect3DRMFrame3_iface);
 599 }
 600
 601 static ULONG WINAPI d3drm_frame3_Release(IDirect3DRMFrame3 *iface)
 602 {
 603     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
 604     ULONG refcount = InterlockedDecrement(&frame->ref);
 605     ULONG i;
 606
 607     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 608
 609     if (!refcount)
 610     {
 611         d3drm_object_cleanup((IDirect3DRMObject *)&frame->IDirect3DRMFrame_iface, &frame->obj);
 612         for (i = 0; i < frame->nb_children; ++i)
 613         {
 614             IDirect3DRMFrame3_Release(frame->children[i]);
 615         }
 616         free(frame->children);
 617         for (i = 0; i < frame->nb_visuals; ++i)
 618         {
 619             IDirect3DRMVisual_Release(frame->visuals[i]);
 620         }
 621         free(frame->visuals);
 622         for (i = 0; i < frame->nb_lights; ++i)
 623         {
 624             IDirect3DRMLight_Release(frame->lights[i]);
 625         }
 626         free(frame->lights);
 627         IDirect3DRM_Release(frame->d3drm);
 628         free(frame);
 629     }
 630
 631     return refcount;
 632 }
 633
 634 static ULONG WINAPI d3drm_frame2_Release(IDirect3DRMFrame2 *iface)
 635 {
 636     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 637
 638     TRACE("iface %p.\n", iface);
 639
 640     return d3drm_frame3_Release(&frame->IDirect3DRMFrame3_iface);
 641 }
 642
 643 static ULONG WINAPI d3drm_frame1_Release(IDirect3DRMFrame *iface)
 644 {
 645     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
 646
 647     TRACE("iface %p.\n", iface);
 648
 649     return d3drm_frame3_Release(&frame->IDirect3DRMFrame3_iface);
 650 }
 651
 652 static HRESULT WINAPI d3drm_frame3_Clone(IDirect3DRMFrame3 *iface,
 653         IUnknown *outer, REFIID iid, void **out)
 654 {
 655     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
 656
 657     return E_NOTIMPL;
 658 }
 659
 660 static HRESULT WINAPI d3drm_frame2_Clone(IDirect3DRMFrame2 *iface,
 661         IUnknown *outer, REFIID iid, void **out)
 662 {
 663     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
 664
 665     return E_NOTIMPL;
 666 }
 667
 668 static HRESULT WINAPI d3drm_frame1_Clone(IDirect3DRMFrame *iface,
 669         IUnknown *outer, REFIID iid, void **out)
 670 {
 671     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
 672
 673     return E_NOTIMPL;
 674 }
 675
 676 static HRESULT WINAPI d3drm_frame3_AddDestroyCallback(IDirect3DRMFrame3 *iface,
 677         D3DRMOBJECTCALLBACK cb, void *ctx)
 678 {
 679     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
 680
 681     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 682
 683     return d3drm_object_add_destroy_callback(&frame->obj, cb, ctx);
 684 }
 685
 686 static HRESULT WINAPI d3drm_frame2_AddDestroyCallback(IDirect3DRMFrame2 *iface,
 687         D3DRMOBJECTCALLBACK cb, void *ctx)
 688 {
 689     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 690
 691     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 692
 693     return IDirect3DRMFrame3_AddDestroyCallback(&frame->IDirect3DRMFrame3_iface, cb, ctx);
 694 }
 695
 696 static HRESULT WINAPI d3drm_frame1_AddDestroyCallback(IDirect3DRMFrame *iface,
 697         D3DRMOBJECTCALLBACK cb, void *ctx)
 698 {
 699     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
 700
 701     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 702
 703     return IDirect3DRMFrame3_AddDestroyCallback(&frame->IDirect3DRMFrame3_iface, cb, ctx);
 704 }
 705
 706 static HRESULT WINAPI d3drm_frame3_DeleteDestroyCallback(IDirect3DRMFrame3 *iface,
 707         D3DRMOBJECTCALLBACK cb, void *ctx)
 708 {
 709     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
 710
 711     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 712
 713     return d3drm_object_delete_destroy_callback(&frame->obj, cb, ctx);
 714 }
 715
 716 static HRESULT WINAPI d3drm_frame2_DeleteDestroyCallback(IDirect3DRMFrame2 *iface,
 717         D3DRMOBJECTCALLBACK cb, void *ctx)
 718 {
 719     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 720
 721     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 722
 723     return IDirect3DRMFrame3_DeleteDestroyCallback(&frame->IDirect3DRMFrame3_iface, cb, ctx);
 724 }
 725
 726 static HRESULT WINAPI d3drm_frame1_DeleteDestroyCallback(IDirect3DRMFrame *iface,
 727         D3DRMOBJECTCALLBACK cb, void *ctx)
 728 {
 729     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
 730
 731     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
 732
 733     return IDirect3DRMFrame3_DeleteDestroyCallback(&frame->IDirect3DRMFrame3_iface, cb, ctx);
 734 }
 735
 736 static HRESULT WINAPI d3drm_frame3_SetAppData(IDirect3DRMFrame3 *iface, DWORD data)
 737 {
 738     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
 739
 740     TRACE("iface %p, data %#lx.\n", iface, data);
 741
 742     frame->obj.appdata = data;
 743
 744     return D3DRM_OK;
 745 }
 746
 747 static HRESULT WINAPI d3drm_frame2_SetAppData(IDirect3DRMFrame2 *iface, DWORD data)
 748 {
 749     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 750
 751     TRACE("iface %p, data %#lx.\n", iface, data);
 752
 753     return d3drm_frame3_SetAppData(&frame->IDirect3DRMFrame3_iface, data);
 754 }
 755
 756 static HRESULT WINAPI d3drm_frame1_SetAppData(IDirect3DRMFrame *iface, DWORD data)
 757 {
 758     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
 759
 760     TRACE("iface %p, data %#lx.\n", iface, data);
 761
 762     return d3drm_frame3_SetAppData(&frame->IDirect3DRMFrame3_iface, data);
 763 }
 764
 765 static DWORD WINAPI d3drm_frame3_GetAppData(IDirect3DRMFrame3 *iface)
 766 {
 767     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
 768
 769     TRACE("iface %p.\n", iface);
 770
 771     return frame->obj.appdata;
 772 }
 773
 774 static DWORD WINAPI d3drm_frame2_GetAppData(IDirect3DRMFrame2 *iface)
 775 {
 776     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 777
 778     TRACE("iface %p.\n", iface);
 779
 780     return d3drm_frame3_GetAppData(&frame->IDirect3DRMFrame3_iface);
 781 }
 782
 783 static DWORD WINAPI d3drm_frame1_GetAppData(IDirect3DRMFrame *iface)
 784 {
 785     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
 786
 787     TRACE("iface %p.\n", iface);
 788
 789     return d3drm_frame3_GetAppData(&frame->IDirect3DRMFrame3_iface);
 790 }
 791
 792 static HRESULT WINAPI d3drm_frame3_SetName(IDirect3DRMFrame3 *iface, const char *name)
 793 {
 794     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
 795
 796     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
 797
 798     return d3drm_object_set_name(&frame->obj, name);
 799 }
 800
 801 static HRESULT WINAPI d3drm_frame2_SetName(IDirect3DRMFrame2 *iface, const char *name)
 802 {
 803     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 804
 805     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
 806
 807     return d3drm_frame3_SetName(&frame->IDirect3DRMFrame3_iface, name);
 808 }
 809
 810 static HRESULT WINAPI d3drm_frame1_SetName(IDirect3DRMFrame *iface, const char *name)
 811 {
 812     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
 813
 814     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
 815
 816     return d3drm_frame3_SetName(&frame->IDirect3DRMFrame3_iface, name);
 817 }
 818
 819 static HRESULT WINAPI d3drm_frame3_GetName(IDirect3DRMFrame3 *iface, DWORD *size, char *name)
 820 {
 821     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
 822
 823     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 824
 825     return d3drm_object_get_name(&frame->obj, size, name);
 826 }
 827
 828 static HRESULT WINAPI d3drm_frame2_GetName(IDirect3DRMFrame2 *iface, DWORD *size, char *name)
 829 {
 830     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 831
 832     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 833
 834     return d3drm_frame3_GetName(&frame->IDirect3DRMFrame3_iface, size, name);
 835 }
 836
 837 static HRESULT WINAPI d3drm_frame1_GetName(IDirect3DRMFrame *iface, DWORD *size, char *name)
 838 {
 839     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
 840
 841     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 842
 843     return d3drm_frame3_GetName(&frame->IDirect3DRMFrame3_iface, size, name);
 844 }
 845
 846 static HRESULT WINAPI d3drm_frame3_GetClassName(IDirect3DRMFrame3 *iface, DWORD *size, char *name)
 847 {
 848     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
 849
 850     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 851
 852     return d3drm_object_get_class_name(&frame->obj, size, name);
 853 }
 854
 855 static HRESULT WINAPI d3drm_frame2_GetClassName(IDirect3DRMFrame2 *iface, DWORD *size, char *name)
 856 {
 857     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 858
 859     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 860
 861     return d3drm_frame3_GetClassName(&frame->IDirect3DRMFrame3_iface, size, name);
 862 }
 863
 864 static HRESULT WINAPI d3drm_frame1_GetClassName(IDirect3DRMFrame *iface, DWORD *size, char *name)
 865 {
 866     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
 867
 868     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
 869
 870     return d3drm_frame3_GetClassName(&frame->IDirect3DRMFrame3_iface, size, name);
 871 }
 872
 873 static HRESULT WINAPI d3drm_frame3_AddChild(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *child)
 874 {
 875     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
 876     struct d3drm_frame *child_obj = unsafe_impl_from_IDirect3DRMFrame3(child);
 877
 878     TRACE("iface %p, child %p.\n", iface, child);
 879
 880     if (!child_obj)
 881         return D3DRMERR_BADOBJECT;
 882
 883     if (child_obj->parent)
 884     {
 885         IDirect3DRMFrame3* parent = &child_obj->parent->IDirect3DRMFrame3_iface;
 886
 887         if (parent == iface)
 888         {
 889             /* Passed frame is already a child so return success */
 890             return D3DRM_OK;
 891         }
 892         else
 893         {
 894             /* Remove parent and continue */
 895             IDirect3DRMFrame3_DeleteChild(parent, child);
 896         }
 897     }
 898
 899     if (!d3drm_array_reserve((void **)&frame->children, &frame->children_size,
 900             frame->nb_children + 1, sizeof(*frame->children)))
 901         return E_OUTOFMEMORY;
 902
 903     frame->children[frame->nb_children++] = child;
 904     IDirect3DRMFrame3_AddRef(child);
 905     child_obj->parent = frame;
 906
 907     return D3DRM_OK;
 908 }
 909
 910 static HRESULT WINAPI d3drm_frame2_AddChild(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *child)
 911 {
 912     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 913     IDirect3DRMFrame3 *child3;
 914     HRESULT hr;
 915
 916     TRACE("iface %p, child %p.\n", iface, child);
 917
 918     if (!child)
 919         return D3DRMERR_BADOBJECT;
 920     hr = IDirect3DRMFrame_QueryInterface(child, &IID_IDirect3DRMFrame3, (void **)&child3);
 921     if (hr != S_OK)
 922         return D3DRMERR_BADOBJECT;
 923     IDirect3DRMFrame_Release(child);
 924
 925     return d3drm_frame3_AddChild(&frame->IDirect3DRMFrame3_iface, child3);
 926 }
 927
 928 static HRESULT WINAPI d3drm_frame1_AddChild(IDirect3DRMFrame *iface, IDirect3DRMFrame *child)
 929 {
 930     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
 931     struct d3drm_frame *child_frame = unsafe_impl_from_IDirect3DRMFrame(child);
 932
 933     TRACE("iface %p, child %p.\n", iface, child);
 934
 935     if (!child_frame)
 936         return D3DRMERR_BADOBJECT;
 937
 938     return d3drm_frame3_AddChild(&frame->IDirect3DRMFrame3_iface, &child_frame->IDirect3DRMFrame3_iface);
 939 }
 940
 941 static HRESULT WINAPI d3drm_frame3_AddLight(IDirect3DRMFrame3 *iface, IDirect3DRMLight *light)
 942 {
 943     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
 944     ULONG i;
 945
 946     TRACE("iface %p, light %p.\n", iface, light);
 947
 948     if (!light)
 949         return D3DRMERR_BADOBJECT;
 950
 951     /* Check if already existing and return gracefully without increasing ref count */
 952     for (i = 0; i < frame->nb_lights; i++)
 953         if (frame->lights[i] == light)
 954             return D3DRM_OK;
 955
 956     if (!d3drm_array_reserve((void **)&frame->lights, &frame->lights_size,
 957             frame->nb_lights + 1, sizeof(*frame->lights)))
 958         return E_OUTOFMEMORY;
 959
 960     frame->lights[frame->nb_lights++] = light;
 961     IDirect3DRMLight_AddRef(light);
 962
 963     return D3DRM_OK;
 964 }
 965
 966 static HRESULT WINAPI d3drm_frame2_AddLight(IDirect3DRMFrame2 *iface, IDirect3DRMLight *light)
 967 {
 968     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
 969
 970     TRACE("iface %p, light %p.\n", iface, light);
 971
 972     return d3drm_frame3_AddLight(&frame->IDirect3DRMFrame3_iface, light);
 973 }
 974
 975 static HRESULT WINAPI d3drm_frame1_AddLight(IDirect3DRMFrame *iface, IDirect3DRMLight *light)
 976 {
 977     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
 978
 979     TRACE("iface %p, light %p.\n", iface, light);
 980
 981     return d3drm_frame3_AddLight(&frame->IDirect3DRMFrame3_iface, light);
 982 }
 983
 984 static HRESULT WINAPI d3drm_frame3_AddMoveCallback(IDirect3DRMFrame3 *iface,
 985         D3DRMFRAME3MOVECALLBACK cb, void *ctx, DWORD flags)
 986 {
 987     FIXME("iface %p, cb %p, ctx %p flags %#lx stub!\n", iface, cb, ctx, flags);
 988
 989     return E_NOTIMPL;
 990 }
 991
 992 static HRESULT WINAPI d3drm_frame2_AddMoveCallback(IDirect3DRMFrame2 *iface,
 993         D3DRMFRAMEMOVECALLBACK cb, void *ctx)
 994 {
 995     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 996
 997     return E_NOTIMPL;
 998 }
 999
1000 static HRESULT WINAPI d3drm_frame1_AddMoveCallback(IDirect3DRMFrame *iface,
1001         D3DRMFRAMEMOVECALLBACK cb, void *ctx)
1002 {
1003     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1004
1005     return E_NOTIMPL;
1006 }
1007
1008 static HRESULT WINAPI d3drm_frame3_AddTransform(IDirect3DRMFrame3 *iface,
1009         D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
1010 {
1011     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1012     const struct d3drm_matrix *m = d3drm_matrix(matrix);
1013
1014     TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
1015
1016     if (m->_14 != 0.0f || m->_24 != 0.0f || m->_34 != 0.0f || m->_44 != 1.0f)
1017         return D3DRMERR_BADVALUE;
1018
1019     switch (type)
1020     {
1021         case D3DRMCOMBINE_REPLACE:
1022             frame->transform = *m;
1023             break;
1024
1025         case D3DRMCOMBINE_BEFORE:
1026             d3drm_matrix_multiply_affine(&frame->transform, m, &frame->transform);
1027             break;
1028
1029         case D3DRMCOMBINE_AFTER:
1030             d3drm_matrix_multiply_affine(&frame->transform, &frame->transform, m);
1031             break;
1032
1033         default:
1034             FIXME("Unhandled type %#x.\n", type);
1035             return D3DRMERR_BADVALUE;
1036     }
1037
1038     return S_OK;
1039 }
1040
1041 static HRESULT WINAPI d3drm_frame2_AddTransform(IDirect3DRMFrame2 *iface,
1042         D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
1043 {
1044     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1045
1046     TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
1047
1048     return d3drm_frame3_AddTransform(&frame->IDirect3DRMFrame3_iface, type, matrix);
1049 }
1050
1051 static HRESULT WINAPI d3drm_frame1_AddTransform(IDirect3DRMFrame *iface,
1052         D3DRMCOMBINETYPE type, D3DRMMATRIX4D matrix)
1053 {
1054     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1055
1056     TRACE("iface %p, type %#x, matrix %p.\n", iface, type, matrix);
1057
1058     return d3drm_frame3_AddTransform(&frame->IDirect3DRMFrame3_iface, type, matrix);
1059 }
1060
1061 static HRESULT WINAPI d3drm_frame3_AddTranslation(IDirect3DRMFrame3 *iface,
1062         D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1063 {
1064     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1065
1066     TRACE("iface %p, type %#x, x %.8e, y %.8e, z %.8e.\n", iface, type, x, y, z);
1067
1068     switch (type)
1069     {
1070         case D3DRMCOMBINE_REPLACE:
1071             frame->transform = identity;
1072             frame->transform._41 = x;
1073             frame->transform._42 = y;
1074             frame->transform._43 = z;
1075             break;
1076
1077         case D3DRMCOMBINE_BEFORE:
1078             frame->transform._41 += x * frame->transform._11 + y * frame->transform._21 + z * frame->transform._31;
1079             frame->transform._42 += x * frame->transform._12 + y * frame->transform._22 + z * frame->transform._32;
1080             frame->transform._43 += x * frame->transform._13 + y * frame->transform._23 + z * frame->transform._33;
1081             break;
1082
1083         case D3DRMCOMBINE_AFTER:
1084             frame->transform._41 += x;
1085             frame->transform._42 += y;
1086             frame->transform._43 += z;
1087             break;
1088
1089         default:
1090             FIXME("Unhandled type %#x.\n", type);
1091             return D3DRMERR_BADVALUE;
1092     }
1093
1094     return D3DRM_OK;
1095 }
1096
1097 static HRESULT WINAPI d3drm_frame2_AddTranslation(IDirect3DRMFrame2 *iface,
1098         D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1099 {
1100     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1101
1102     TRACE("iface %p, type %#x, x %.8e, y %.8e, z %.8e.\n", iface, type, x, y, z);
1103
1104     return d3drm_frame3_AddTranslation(&frame->IDirect3DRMFrame3_iface, type, x, y, z);
1105 }
1106
1107 static HRESULT WINAPI d3drm_frame1_AddTranslation(IDirect3DRMFrame *iface,
1108         D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z)
1109 {
1110     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1111
1112     TRACE("iface %p, type %#x, x %.8e, y %.8e, z %.8e.\n", iface, type, x, y, z);
1113
1114     return d3drm_frame3_AddTranslation(&frame->IDirect3DRMFrame3_iface, type, x, y, z);
1115 }
1116
1117 static HRESULT WINAPI d3drm_frame3_AddScale(IDirect3DRMFrame3 *iface,
1118         D3DRMCOMBINETYPE type, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1119 {
1120     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1121
1122     TRACE("iface %p, type %#x, sx %.8e, sy %.8e, sz %.8e.\n", iface, type, sx, sy, sz);
1123
1124     switch (type)
1125     {
1126         case D3DRMCOMBINE_REPLACE:
1127             frame->transform = identity;
1128             frame->transform._11 = sx;
1129             frame->transform._22 = sy;
1130             frame->transform._33 = sz;
1131             break;
1132
1133         case D3DRMCOMBINE_BEFORE:
1134             frame->transform._11 *= sx;
1135             frame->transform._12 *= sx;
1136             frame->transform._13 *= sx;
1137             frame->transform._21 *= sy;
1138             frame->transform._22 *= sy;
1139             frame->transform._23 *= sy;
1140             frame->transform._31 *= sz;
1141             frame->transform._32 *= sz;
1142             frame->transform._33 *= sz;
1143             break;
1144
1145         case D3DRMCOMBINE_AFTER:
1146             frame->transform._11 *= sx;
1147             frame->transform._12 *= sy;
1148             frame->transform._13 *= sz;
1149             frame->transform._21 *= sx;
1150             frame->transform._22 *= sy;
1151             frame->transform._23 *= sz;
1152             frame->transform._31 *= sx;
1153             frame->transform._32 *= sy;
1154             frame->transform._33 *= sz;
1155             frame->transform._41 *= sx;
1156             frame->transform._42 *= sy;
1157             frame->transform._43 *= sz;
1158             break;
1159
1160         default:
1161             FIXME("Unhandled type %#x.\n", type);
1162             return D3DRMERR_BADVALUE;
1163     }
1164
1165     return D3DRM_OK;
1166 }
1167
1168 static HRESULT WINAPI d3drm_frame2_AddScale(IDirect3DRMFrame2 *iface,
1169         D3DRMCOMBINETYPE type, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1170 {
1171     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1172
1173     TRACE("iface %p, type %#x, sx %.8e, sy %.8e, sz %.8e.\n", iface, type, sx, sy, sz);
1174
1175     return d3drm_frame3_AddScale(&frame->IDirect3DRMFrame3_iface, type, sx, sy, sz);
1176 }
1177
1178 static HRESULT WINAPI d3drm_frame1_AddScale(IDirect3DRMFrame *iface,
1179         D3DRMCOMBINETYPE type, D3DVALUE sx, D3DVALUE sy, D3DVALUE sz)
1180 {
1181     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1182
1183     TRACE("iface %p, type %#x, sx %.8e, sy %.8e, sz %.8e.\n", iface, type, sx, sy, sz);
1184
1185     return d3drm_frame3_AddScale(&frame->IDirect3DRMFrame3_iface, type, sx, sy, sz);
1186 }
1187
1188 static HRESULT WINAPI d3drm_frame3_AddRotation(IDirect3DRMFrame3 *iface,
1189         D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1190 {
1191     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1192     struct d3drm_matrix m;
1193     D3DVECTOR axis;
1194
1195     TRACE("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e.\n", iface, type, x, y, z, theta);
1196
1197     axis.u1.x = x;
1198     axis.u2.y = y;
1199     axis.u3.z = z;
1200
1201     switch (type)
1202     {
1203         case D3DRMCOMBINE_REPLACE:
1204             d3drm_matrix_set_rotation(&frame->transform, &axis, theta);
1205             break;
1206
1207         case D3DRMCOMBINE_BEFORE:
1208             d3drm_matrix_set_rotation(&m, &axis, theta);
1209             d3drm_matrix_multiply_affine(&frame->transform, &m, &frame->transform);
1210             break;
1211
1212         case D3DRMCOMBINE_AFTER:
1213             d3drm_matrix_set_rotation(&m, &axis, theta);
1214             d3drm_matrix_multiply_affine(&frame->transform, &frame->transform, &m);
1215             break;
1216
1217         default:
1218             FIXME("Unhandled type %#x.\n", type);
1219             return D3DRMERR_BADVALUE;
1220     }
1221
1222     return D3DRM_OK;
1223 }
1224
1225 static HRESULT WINAPI d3drm_frame2_AddRotation(IDirect3DRMFrame2 *iface,
1226         D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1227 {
1228     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1229
1230     TRACE("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e.\n", iface, type, x, y, z, theta);
1231
1232     return d3drm_frame3_AddRotation(&frame->IDirect3DRMFrame3_iface, type, x, y, z, theta);
1233 }
1234
1235 static HRESULT WINAPI d3drm_frame1_AddRotation(IDirect3DRMFrame *iface,
1236         D3DRMCOMBINETYPE type, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
1237 {
1238     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1239
1240     TRACE("iface %p, type %#x, x %.8e, y %.8e, z %.8e, theta %.8e.\n", iface, type, x, y, z, theta);
1241
1242     return d3drm_frame3_AddRotation(&frame->IDirect3DRMFrame3_iface, type, x, y, z, theta);
1243 }
1244
1245 static HRESULT WINAPI d3drm_frame3_AddVisual(IDirect3DRMFrame3 *iface, IUnknown *visual)
1246 {
1247     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1248     ULONG i;
1249
1250     TRACE("iface %p, visual %p.\n", iface, visual);
1251
1252     if (!visual)
1253         return D3DRMERR_BADOBJECT;
1254
1255     /* Check if already existing and return gracefully without increasing ref count */
1256     for (i = 0; i < frame->nb_visuals; i++)
1257         if (frame->visuals[i] == (IDirect3DRMVisual *)visual)
1258             return D3DRM_OK;
1259
1260     if (!d3drm_array_reserve((void **)&frame->visuals, &frame->visuals_size,
1261             frame->nb_visuals + 1, sizeof(*frame->visuals)))
1262         return E_OUTOFMEMORY;
1263
1264     frame->visuals[frame->nb_visuals++] = (IDirect3DRMVisual *)visual;
1265     IDirect3DRMVisual_AddRef(visual);
1266
1267     return D3DRM_OK;
1268 }
1269
1270 static HRESULT WINAPI d3drm_frame2_AddVisual(IDirect3DRMFrame2 *iface, IDirect3DRMVisual *visual)
1271 {
1272     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1273
1274     TRACE("iface %p, visual %p.\n", iface, visual);
1275
1276     return d3drm_frame3_AddVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1277 }
1278
1279 static HRESULT WINAPI d3drm_frame1_AddVisual(IDirect3DRMFrame *iface, IDirect3DRMVisual *visual)
1280 {
1281     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1282
1283     TRACE("iface %p, visual %p.\n", iface, visual);
1284
1285     return d3drm_frame3_AddVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1286 }
1287
1288 static HRESULT WINAPI d3drm_frame3_GetChildren(IDirect3DRMFrame3 *iface, IDirect3DRMFrameArray **children)
1289 {
1290     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1291     struct d3drm_frame_array *array;
1292
1293     TRACE("iface %p, children %p.\n", iface, children);
1294
1295     if (!children)
1296         return D3DRMERR_BADVALUE;
1297
1298     if (!(array = d3drm_frame_array_create(frame->nb_children, frame->children)))
1299         return E_OUTOFMEMORY;
1300
1301     *children = &array->IDirect3DRMFrameArray_iface;
1302
1303     return D3DRM_OK;
1304 }
1305
1306 static HRESULT WINAPI d3drm_frame2_GetChildren(IDirect3DRMFrame2 *iface, IDirect3DRMFrameArray **children)
1307 {
1308     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1309
1310     TRACE("iface %p, children %p.\n", iface, children);
1311
1312     return d3drm_frame3_GetChildren(&frame->IDirect3DRMFrame3_iface, children);
1313 }
1314
1315 static HRESULT WINAPI d3drm_frame1_GetChildren(IDirect3DRMFrame *iface, IDirect3DRMFrameArray **children)
1316 {
1317     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1318
1319     TRACE("iface %p, children %p.\n", iface, children);
1320
1321     return d3drm_frame3_GetChildren(&frame->IDirect3DRMFrame3_iface, children);
1322 }
1323
1324 static D3DCOLOR WINAPI d3drm_frame3_GetColor(IDirect3DRMFrame3 *iface)
1325 {
1326     FIXME("iface %p stub!\n", iface);
1327
1328     return 0;
1329 }
1330
1331 static D3DCOLOR WINAPI d3drm_frame2_GetColor(IDirect3DRMFrame2 *iface)
1332 {
1333     FIXME("iface %p stub!\n", iface);
1334
1335     return 0;
1336 }
1337
1338 static D3DCOLOR WINAPI d3drm_frame1_GetColor(IDirect3DRMFrame *iface)
1339 {
1340     FIXME("iface %p stub!\n", iface);
1341
1342     return 0;
1343 }
1344
1345 static HRESULT WINAPI d3drm_frame3_GetLights(IDirect3DRMFrame3 *iface, IDirect3DRMLightArray **lights)
1346 {
1347     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1348     struct d3drm_light_array *array;
1349
1350     TRACE("iface %p, lights %p.\n", iface, lights);
1351
1352     if (!lights)
1353         return D3DRMERR_BADVALUE;
1354
1355     if (!(array = d3drm_light_array_create(frame->nb_lights, frame->lights)))
1356         return E_OUTOFMEMORY;
1357
1358     *lights = &array->IDirect3DRMLightArray_iface;
1359
1360     return D3DRM_OK;
1361 }
1362
1363 static HRESULT WINAPI d3drm_frame2_GetLights(IDirect3DRMFrame2 *iface, IDirect3DRMLightArray **lights)
1364 {
1365     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1366
1367     TRACE("iface %p, lights %p.\n", iface, lights);
1368
1369     return d3drm_frame3_GetLights(&frame->IDirect3DRMFrame3_iface, lights);
1370 }
1371
1372 static HRESULT WINAPI d3drm_frame1_GetLights(IDirect3DRMFrame *iface, IDirect3DRMLightArray **lights)
1373 {
1374     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1375
1376     TRACE("iface %p, lights %p.\n", iface, lights);
1377
1378     return d3drm_frame3_GetLights(&frame->IDirect3DRMFrame3_iface, lights);
1379 }
1380
1381 static D3DRMMATERIALMODE WINAPI d3drm_frame3_GetMaterialMode(IDirect3DRMFrame3 *iface)
1382 {
1383     FIXME("iface %p stub!\n", iface);
1384
1385     return D3DRMMATERIAL_FROMPARENT;
1386 }
1387
1388 static D3DRMMATERIALMODE WINAPI d3drm_frame2_GetMaterialMode(IDirect3DRMFrame2 *iface)
1389 {
1390     FIXME("iface %p stub!\n", iface);
1391
1392     return D3DRMMATERIAL_FROMPARENT;
1393 }
1394
1395 static D3DRMMATERIALMODE WINAPI d3drm_frame1_GetMaterialMode(IDirect3DRMFrame *iface)
1396 {
1397     FIXME("iface %p stub!\n", iface);
1398
1399     return D3DRMMATERIAL_FROMPARENT;
1400 }
1401
1402 static HRESULT WINAPI d3drm_frame3_GetParent(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 **parent)
1403 {
1404     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1405
1406     TRACE("iface %p, parent %p.\n", iface, parent);
1407
1408     if (!parent)
1409         return D3DRMERR_BADVALUE;
1410
1411     if (frame->parent)
1412     {
1413         *parent = &frame->parent->IDirect3DRMFrame3_iface;
1414         IDirect3DRMFrame_AddRef(*parent);
1415     }
1416     else
1417     {
1418         *parent = NULL;
1419     }
1420
1421     return D3DRM_OK;
1422 }
1423
1424 static HRESULT WINAPI d3drm_frame2_GetParent(IDirect3DRMFrame2 *iface, IDirect3DRMFrame **parent)
1425 {
1426     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1427
1428     TRACE("iface %p, parent %p.\n", iface, parent);
1429
1430     if (!parent)
1431         return D3DRMERR_BADVALUE;
1432
1433     if (frame->parent)
1434     {
1435         *parent = &frame->parent->IDirect3DRMFrame_iface;
1436         IDirect3DRMFrame_AddRef(*parent);
1437     }
1438     else
1439     {
1440         *parent = NULL;
1441     }
1442
1443     return D3DRM_OK;
1444 }
1445
1446 static HRESULT WINAPI d3drm_frame1_GetParent(IDirect3DRMFrame *iface, IDirect3DRMFrame **parent)
1447 {
1448     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1449
1450     TRACE("iface %p, parent %p.\n", iface, parent);
1451
1452     return d3drm_frame2_GetParent(&frame->IDirect3DRMFrame2_iface, parent);
1453 }
1454
1455 static HRESULT WINAPI d3drm_frame3_GetPosition(IDirect3DRMFrame3 *iface,
1456         IDirect3DRMFrame3 *reference, D3DVECTOR *position)
1457 {
1458     FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1459
1460     return E_NOTIMPL;
1461 }
1462
1463 static HRESULT WINAPI d3drm_frame2_GetPosition(IDirect3DRMFrame2 *iface,
1464         IDirect3DRMFrame *reference, D3DVECTOR *position)
1465 {
1466     FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1467
1468     return E_NOTIMPL;
1469 }
1470
1471 static HRESULT WINAPI d3drm_frame1_GetPosition(IDirect3DRMFrame *iface,
1472         IDirect3DRMFrame *reference, D3DVECTOR *position)
1473 {
1474     FIXME("iface %p, reference %p, position %p stub!\n", iface, reference, position);
1475
1476     return E_NOTIMPL;
1477 }
1478
1479
1480 static HRESULT WINAPI d3drm_frame3_GetRotation(IDirect3DRMFrame3 *iface,
1481         IDirect3DRMFrame3 *reference, D3DVECTOR *axis, D3DVALUE *theta)
1482 {
1483     FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1484
1485     return E_NOTIMPL;
1486 }
1487
1488 static HRESULT WINAPI d3drm_frame2_GetRotation(IDirect3DRMFrame2 *iface,
1489         IDirect3DRMFrame *reference, D3DVECTOR *axis, D3DVALUE *theta)
1490 {
1491     FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1492
1493     return E_NOTIMPL;
1494 }
1495
1496 static HRESULT WINAPI d3drm_frame1_GetRotation(IDirect3DRMFrame *iface,
1497         IDirect3DRMFrame *reference, D3DVECTOR *axis, D3DVALUE *theta)
1498 {
1499     FIXME("iface %p, reference %p, axis %p, theta %p stub!\n", iface, reference, axis, theta);
1500
1501     return E_NOTIMPL;
1502 }
1503
1504 static HRESULT WINAPI d3drm_frame3_GetScene(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 **scene)
1505 {
1506     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1507
1508     TRACE("iface %p, scene %p.\n", iface, scene);
1509
1510     if (!scene)
1511         return D3DRMERR_BADVALUE;
1512
1513     while (frame->parent)
1514         frame = frame->parent;
1515
1516     *scene = &frame->IDirect3DRMFrame3_iface;
1517     IDirect3DRMFrame3_AddRef(*scene);
1518
1519     return D3DRM_OK;
1520 }
1521
1522 static HRESULT WINAPI d3drm_frame2_GetScene(IDirect3DRMFrame2 *iface, IDirect3DRMFrame **scene)
1523 {
1524     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1525     IDirect3DRMFrame3 *frame3;
1526     HRESULT hr;
1527
1528     TRACE("iface %p, scene %p.\n", iface, scene);
1529
1530     if (!scene)
1531         return D3DRMERR_BADVALUE;
1532
1533     hr = IDirect3DRMFrame3_GetScene(&frame->IDirect3DRMFrame3_iface, &frame3);
1534     if (FAILED(hr) || !frame3)
1535     {
1536         *scene = NULL;
1537         return hr;
1538     }
1539
1540     hr = IDirect3DRMFrame3_QueryInterface(frame3, &IID_IDirect3DRMFrame, (void **)scene);
1541     IDirect3DRMFrame3_Release(frame3);
1542
1543     return hr;
1544 }
1545
1546 static HRESULT WINAPI d3drm_frame1_GetScene(IDirect3DRMFrame *iface, IDirect3DRMFrame **scene)
1547 {
1548     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1549
1550     TRACE("iface %p, scene %p.\n", iface, scene);
1551
1552     return d3drm_frame2_GetScene(&frame->IDirect3DRMFrame2_iface, scene);
1553 }
1554
1555 static D3DRMSORTMODE WINAPI d3drm_frame3_GetSortMode(IDirect3DRMFrame3 *iface)
1556 {
1557     FIXME("iface %p stub!\n", iface);
1558
1559     return D3DRMSORT_FROMPARENT;
1560 }
1561
1562 static D3DRMSORTMODE WINAPI d3drm_frame2_GetSortMode(IDirect3DRMFrame2 *iface)
1563 {
1564     FIXME("iface %p stub!\n", iface);
1565
1566     return D3DRMSORT_FROMPARENT;
1567 }
1568
1569 static D3DRMSORTMODE WINAPI d3drm_frame1_GetSortMode(IDirect3DRMFrame *iface)
1570 {
1571     FIXME("iface %p stub!\n", iface);
1572
1573     return D3DRMSORT_FROMPARENT;
1574 }
1575
1576 static HRESULT WINAPI d3drm_frame3_GetTexture(IDirect3DRMFrame3 *iface, IDirect3DRMTexture3 **texture)
1577 {
1578     FIXME("iface %p, texture %p stub!\n", iface, texture);
1579
1580     return E_NOTIMPL;
1581 }
1582
1583 static HRESULT WINAPI d3drm_frame2_GetTexture(IDirect3DRMFrame2 *iface, IDirect3DRMTexture **texture)
1584 {
1585     FIXME("iface %p, texture %p stub!\n", iface, texture);
1586
1587     return E_NOTIMPL;
1588 }
1589
1590 static HRESULT WINAPI d3drm_frame1_GetTexture(IDirect3DRMFrame *iface, IDirect3DRMTexture **texture)
1591 {
1592     FIXME("iface %p, texture %p stub!\n", iface, texture);
1593
1594     return E_NOTIMPL;
1595 }
1596
1597 static HRESULT WINAPI d3drm_frame3_GetTransform(IDirect3DRMFrame3 *iface,
1598         IDirect3DRMFrame3 *reference, D3DRMMATRIX4D matrix)
1599 {
1600     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1601     struct d3drm_matrix *m = d3drm_matrix(matrix);
1602
1603     TRACE("iface %p, reference %p, matrix %p.\n", iface, reference, matrix);
1604
1605     if (reference)
1606         FIXME("Ignoring reference frame %p.\n", reference);
1607
1608     *m = frame->transform;
1609
1610     return D3DRM_OK;
1611 }
1612
1613 static HRESULT WINAPI d3drm_frame2_GetTransform(IDirect3DRMFrame2 *iface, D3DRMMATRIX4D matrix)
1614 {
1615     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1616     struct d3drm_matrix *m = d3drm_matrix(matrix);
1617
1618     TRACE("iface %p, matrix %p.\n", iface, matrix);
1619
1620     *m = frame->transform;
1621
1622     return D3DRM_OK;
1623 }
1624
1625 static HRESULT WINAPI d3drm_frame1_GetTransform(IDirect3DRMFrame *iface, D3DRMMATRIX4D matrix)
1626 {
1627     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1628
1629     TRACE("iface %p, matrix %p.\n", iface, matrix);
1630
1631     return d3drm_frame2_GetTransform(&frame->IDirect3DRMFrame2_iface, matrix);
1632 }
1633
1634 static HRESULT WINAPI d3drm_frame3_GetVelocity(IDirect3DRMFrame3 *iface,
1635         IDirect3DRMFrame3 *reference, D3DVECTOR *velocity, BOOL with_rotation)
1636 {
1637     FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1638             iface, reference, velocity, with_rotation);
1639
1640     return E_NOTIMPL;
1641 }
1642
1643 static HRESULT WINAPI d3drm_frame2_GetVelocity(IDirect3DRMFrame2 *iface,
1644         IDirect3DRMFrame *reference, D3DVECTOR *velocity, BOOL with_rotation)
1645 {
1646     FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1647             iface, reference, velocity, with_rotation);
1648
1649     return E_NOTIMPL;
1650 }
1651
1652 static HRESULT WINAPI d3drm_frame1_GetVelocity(IDirect3DRMFrame *iface,
1653         IDirect3DRMFrame *reference, D3DVECTOR *velocity, BOOL with_rotation)
1654 {
1655     FIXME("iface %p, reference %p, velocity %p, with_rotation %#x stub!\n",
1656             iface, reference, velocity, with_rotation);
1657
1658     return E_NOTIMPL;
1659 }
1660
1661 static HRESULT WINAPI d3drm_frame3_GetOrientation(IDirect3DRMFrame3 *iface,
1662         IDirect3DRMFrame3 *reference, D3DVECTOR *dir, D3DVECTOR *up)
1663 {
1664     FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1665
1666     return E_NOTIMPL;
1667 }
1668
1669 static HRESULT WINAPI d3drm_frame2_GetOrientation(IDirect3DRMFrame2 *iface,
1670         IDirect3DRMFrame *reference, D3DVECTOR *dir, D3DVECTOR *up)
1671 {
1672     FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1673
1674     return E_NOTIMPL;
1675 }
1676
1677 static HRESULT WINAPI d3drm_frame1_GetOrientation(IDirect3DRMFrame *iface,
1678         IDirect3DRMFrame *reference, D3DVECTOR *dir, D3DVECTOR *up)
1679 {
1680     FIXME("iface %p, reference %p, dir %p, up %p stub!\n", iface, reference, dir, up);
1681
1682     return E_NOTIMPL;
1683 }
1684
1685 static HRESULT WINAPI d3drm_frame3_GetVisuals(IDirect3DRMFrame3 *iface, DWORD *count, IUnknown **visuals)
1686 {
1687     FIXME("iface %p, count %p, visuals %p stub!\n", iface, count, visuals);
1688
1689     return E_NOTIMPL;
1690 }
1691
1692 static HRESULT WINAPI d3drm_frame2_GetVisuals(IDirect3DRMFrame2 *iface, IDirect3DRMVisualArray **visuals)
1693 {
1694     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1695     struct d3drm_visual_array *array;
1696
1697     TRACE("iface %p, visuals %p.\n", iface, visuals);
1698
1699     if (!visuals)
1700         return D3DRMERR_BADVALUE;
1701
1702     if (!(array = d3drm_visual_array_create(frame->nb_visuals, frame->visuals)))
1703         return E_OUTOFMEMORY;
1704
1705     *visuals = &array->IDirect3DRMVisualArray_iface;
1706
1707     return D3DRM_OK;
1708 }
1709
1710 static HRESULT WINAPI d3drm_frame1_GetVisuals(IDirect3DRMFrame *iface, IDirect3DRMVisualArray **visuals)
1711 {
1712     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1713
1714     TRACE("iface %p, visuals %p.\n", iface, visuals);
1715
1716     return d3drm_frame2_GetVisuals(&frame->IDirect3DRMFrame2_iface, visuals);
1717 }
1718
1719 static HRESULT WINAPI d3drm_frame2_GetTextureTopology(IDirect3DRMFrame2 *iface, BOOL *wrap_u, BOOL *wrap_v)
1720 {
1721     FIXME("iface %p, wrap_u %p, wrap_v %p stub!\n", iface, wrap_u, wrap_v);
1722
1723     return E_NOTIMPL;
1724 }
1725
1726 static HRESULT WINAPI d3drm_frame1_GetTextureTopology(IDirect3DRMFrame *iface, BOOL *wrap_u, BOOL *wrap_v)
1727 {
1728     FIXME("iface %p, wrap_u %p, wrap_v %p stub!\n", iface, wrap_u, wrap_v);
1729
1730     return E_NOTIMPL;
1731 }
1732
1733 static HRESULT WINAPI d3drm_frame3_InverseTransform(IDirect3DRMFrame3 *iface, D3DVECTOR *d, D3DVECTOR *s)
1734 {
1735     FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1736
1737     return E_NOTIMPL;
1738 }
1739
1740 static HRESULT WINAPI d3drm_frame2_InverseTransform(IDirect3DRMFrame2 *iface, D3DVECTOR *d, D3DVECTOR *s)
1741 {
1742     FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1743
1744     return E_NOTIMPL;
1745 }
1746
1747 static HRESULT WINAPI d3drm_frame1_InverseTransform(IDirect3DRMFrame *iface, D3DVECTOR *d, D3DVECTOR *s)
1748 {
1749     FIXME("iface %p, d %p, s %p stub!\n", iface, d, s);
1750
1751     return E_NOTIMPL;
1752 }
1753
1754 static HRESULT WINAPI d3drm_frame3_Load(IDirect3DRMFrame3 *iface, void *filename,
1755         void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURE3CALLBACK cb, void *ctx)
1756 {
1757     FIXME("iface %p, filename %p, name %p, flags %#lx, cb %p, ctx %p stub!\n",
1758             iface, filename, name, flags, cb, ctx);
1759
1760     return E_NOTIMPL;
1761 }
1762
1763 static HRESULT WINAPI d3drm_frame2_Load(IDirect3DRMFrame2 *iface, void *filename,
1764         void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURECALLBACK cb, void *ctx)
1765 {
1766     FIXME("iface %p, filename %p, name %p, flags %#lx, cb %p, ctx %p stub!\n",
1767             iface, filename, name, flags, cb, ctx);
1768
1769     return E_NOTIMPL;
1770 }
1771
1772 static HRESULT WINAPI d3drm_frame1_Load(IDirect3DRMFrame *iface, void *filename,
1773         void *name, D3DRMLOADOPTIONS flags, D3DRMLOADTEXTURECALLBACK cb, void *ctx)
1774 {
1775     FIXME("iface %p, filename %p, name %p, flags %#lx, cb %p, ctx %p stub!\n",
1776             iface, filename, name, flags, cb, ctx);
1777
1778     return E_NOTIMPL;
1779 }
1780
1781 static HRESULT WINAPI d3drm_frame3_LookAt(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *target,
1782         IDirect3DRMFrame3 *reference, D3DRMFRAMECONSTRAINT constraint)
1783 {
1784     FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1785
1786     return E_NOTIMPL;
1787 }
1788
1789 static HRESULT WINAPI d3drm_frame2_LookAt(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *target,
1790         IDirect3DRMFrame *reference, D3DRMFRAMECONSTRAINT constraint)
1791 {
1792     FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1793
1794     return E_NOTIMPL;
1795 }
1796
1797 static HRESULT WINAPI d3drm_frame1_LookAt(IDirect3DRMFrame *iface, IDirect3DRMFrame *target,
1798         IDirect3DRMFrame *reference, D3DRMFRAMECONSTRAINT constraint)
1799 {
1800     FIXME("iface %p, target %p, reference %p, constraint %#x stub!\n", iface, target, reference, constraint);
1801
1802     return E_NOTIMPL;
1803 }
1804
1805 static HRESULT WINAPI d3drm_frame3_Move(IDirect3DRMFrame3 *iface, D3DVALUE delta)
1806 {
1807     FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1808
1809     return E_NOTIMPL;
1810 }
1811
1812 static HRESULT WINAPI d3drm_frame2_Move(IDirect3DRMFrame2 *iface, D3DVALUE delta)
1813 {
1814     FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1815
1816     return E_NOTIMPL;
1817 }
1818
1819 static HRESULT WINAPI d3drm_frame1_Move(IDirect3DRMFrame *iface, D3DVALUE delta)
1820 {
1821     FIXME("iface %p, delta %.8e stub!\n", iface, delta);
1822
1823     return E_NOTIMPL;
1824 }
1825
1826 static HRESULT WINAPI d3drm_frame3_DeleteChild(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *child)
1827 {
1828     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1829     struct d3drm_frame *child_impl = unsafe_impl_from_IDirect3DRMFrame3(child);
1830     ULONG i;
1831
1832     TRACE("iface %p, child %p.\n", iface, child);
1833
1834     if (!child_impl)
1835         return D3DRMERR_BADOBJECT;
1836
1837     /* Check if child exists */
1838     for (i = 0; i < frame->nb_children; ++i)
1839     {
1840         if (frame->children[i] == child)
1841             break;
1842     }
1843
1844     if (i == frame->nb_children)
1845         return D3DRMERR_BADVALUE;
1846
1847     memmove(frame->children + i, frame->children + i + 1, sizeof(*frame->children) * (frame->nb_children - 1 - i));
1848     IDirect3DRMFrame3_Release(child);
1849     child_impl->parent = NULL;
1850     --frame->nb_children;
1851
1852     return D3DRM_OK;
1853 }
1854
1855 static HRESULT WINAPI d3drm_frame2_DeleteChild(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *child)
1856 {
1857     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1858     IDirect3DRMFrame3 *child3;
1859     HRESULT hr;
1860
1861     TRACE("iface %p, child %p.\n", iface, child);
1862
1863     if (!child)
1864         return D3DRMERR_BADOBJECT;
1865     if (FAILED(hr = IDirect3DRMFrame_QueryInterface(child, &IID_IDirect3DRMFrame3, (void **)&child3)))
1866         return D3DRMERR_BADOBJECT;
1867     IDirect3DRMFrame_Release(child);
1868
1869     return d3drm_frame3_DeleteChild(&frame->IDirect3DRMFrame3_iface, child3);
1870 }
1871
1872 static HRESULT WINAPI d3drm_frame1_DeleteChild(IDirect3DRMFrame *iface, IDirect3DRMFrame *child)
1873 {
1874     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1875     struct d3drm_frame *child_frame = unsafe_impl_from_IDirect3DRMFrame(child);
1876
1877     TRACE("iface %p, child %p.\n", iface, child);
1878
1879     if (!child_frame)
1880         return D3DRMERR_BADOBJECT;
1881
1882     return d3drm_frame3_DeleteChild(&frame->IDirect3DRMFrame3_iface, &child_frame->IDirect3DRMFrame3_iface);
1883 }
1884
1885 static HRESULT WINAPI d3drm_frame3_DeleteLight(IDirect3DRMFrame3 *iface, IDirect3DRMLight *light)
1886 {
1887     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1888     ULONG i;
1889
1890     TRACE("iface %p, light %p.\n", iface, light);
1891
1892     if (!light)
1893         return D3DRMERR_BADOBJECT;
1894
1895     /* Check if visual exists */
1896     for (i = 0; i < frame->nb_lights; ++i)
1897     {
1898         if (frame->lights[i] == light)
1899             break;
1900     }
1901
1902     if (i == frame->nb_lights)
1903         return D3DRMERR_BADVALUE;
1904
1905     memmove(frame->lights + i, frame->lights + i + 1, sizeof(*frame->lights) * (frame->nb_lights - 1 - i));
1906     IDirect3DRMLight_Release(light);
1907     --frame->nb_lights;
1908
1909     return D3DRM_OK;
1910 }
1911
1912 static HRESULT WINAPI d3drm_frame2_DeleteLight(IDirect3DRMFrame2 *iface, IDirect3DRMLight *light)
1913 {
1914     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1915
1916     TRACE("iface %p, light %p.\n", iface, light);
1917
1918     return d3drm_frame3_DeleteLight(&frame->IDirect3DRMFrame3_iface, light);
1919 }
1920
1921 static HRESULT WINAPI d3drm_frame1_DeleteLight(IDirect3DRMFrame *iface, IDirect3DRMLight *light)
1922 {
1923     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1924
1925     TRACE("iface %p, light %p.\n", iface, light);
1926
1927     return d3drm_frame3_DeleteLight(&frame->IDirect3DRMFrame3_iface, light);
1928 }
1929
1930 static HRESULT WINAPI d3drm_frame3_DeleteMoveCallback(IDirect3DRMFrame3 *iface,
1931         D3DRMFRAME3MOVECALLBACK cb, void *ctx)
1932 {
1933     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1934
1935     return E_NOTIMPL;
1936 }
1937
1938 static HRESULT WINAPI d3drm_frame2_DeleteMoveCallback(IDirect3DRMFrame2 *iface,
1939         D3DRMFRAMEMOVECALLBACK cb, void *ctx)
1940 {
1941     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1942
1943     return E_NOTIMPL;
1944 }
1945
1946 static HRESULT WINAPI d3drm_frame1_DeleteMoveCallback(IDirect3DRMFrame *iface,
1947         D3DRMFRAMEMOVECALLBACK cb, void *ctx)
1948 {
1949     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
1950
1951     return E_NOTIMPL;
1952 }
1953
1954 static HRESULT WINAPI d3drm_frame3_DeleteVisual(IDirect3DRMFrame3 *iface, IUnknown *visual)
1955 {
1956     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
1957     ULONG i;
1958
1959     TRACE("iface %p, visual %p.\n", iface, visual);
1960
1961     if (!visual)
1962         return D3DRMERR_BADOBJECT;
1963
1964     /* Check if visual exists */
1965     for (i = 0; i < frame->nb_visuals; ++i)
1966     {
1967         if (frame->visuals[i] == (IDirect3DRMVisual *)visual)
1968             break;
1969     }
1970
1971     if (i == frame->nb_visuals)
1972         return D3DRMERR_BADVALUE;
1973
1974     memmove(frame->visuals + i, frame->visuals + i + 1, sizeof(*frame->visuals) * (frame->nb_visuals - 1 - i));
1975     IDirect3DRMVisual_Release(visual);
1976     --frame->nb_visuals;
1977
1978     return D3DRM_OK;
1979 }
1980
1981 static HRESULT WINAPI d3drm_frame2_DeleteVisual(IDirect3DRMFrame2 *iface, IDirect3DRMVisual *visual)
1982 {
1983     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
1984
1985     TRACE("iface %p, visual %p.\n", iface, visual);
1986
1987     return d3drm_frame3_DeleteVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1988 }
1989
1990 static HRESULT WINAPI d3drm_frame1_DeleteVisual(IDirect3DRMFrame *iface, IDirect3DRMVisual *visual)
1991 {
1992     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
1993
1994     TRACE("iface %p, visual %p.\n", iface, visual);
1995
1996     return d3drm_frame3_DeleteVisual(&frame->IDirect3DRMFrame3_iface, (IUnknown *)visual);
1997 }
1998
1999 static D3DCOLOR WINAPI d3drm_frame3_GetSceneBackground(IDirect3DRMFrame3 *iface)
2000 {
2001     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
2002
2003     TRACE("iface %p.\n", iface);
2004
2005     return frame->scenebackground;
2006 }
2007
2008 static D3DCOLOR WINAPI d3drm_frame2_GetSceneBackground(IDirect3DRMFrame2 *iface)
2009 {
2010     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
2011
2012     TRACE("iface %p.\n", iface);
2013
2014     return d3drm_frame3_GetSceneBackground(&frame->IDirect3DRMFrame3_iface);
2015 }
2016
2017 static D3DCOLOR WINAPI d3drm_frame1_GetSceneBackground(IDirect3DRMFrame *iface)
2018 {
2019     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
2020
2021     TRACE("iface %p.\n", iface);
2022
2023     return d3drm_frame3_GetSceneBackground(&frame->IDirect3DRMFrame3_iface);
2024 }
2025
2026 static HRESULT WINAPI d3drm_frame3_GetSceneBackgroundDepth(IDirect3DRMFrame3 *iface,
2027         IDirectDrawSurface **surface)
2028 {
2029     FIXME("iface %p, surface %p stub!\n", iface, surface);
2030
2031     return E_NOTIMPL;
2032 }
2033
2034 static HRESULT WINAPI d3drm_frame2_GetSceneBackgroundDepth(IDirect3DRMFrame2 *iface,
2035         IDirectDrawSurface **surface)
2036 {
2037     FIXME("iface %p, surface %p stub!\n", iface, surface);
2038
2039     return E_NOTIMPL;
2040 }
2041
2042 static HRESULT WINAPI d3drm_frame1_GetSceneBackgroundDepth(IDirect3DRMFrame *iface,
2043         IDirectDrawSurface **surface)
2044 {
2045     FIXME("iface %p, surface %p stub!\n", iface, surface);
2046
2047     return E_NOTIMPL;
2048 }
2049
2050 static D3DCOLOR WINAPI d3drm_frame3_GetSceneFogColor(IDirect3DRMFrame3 *iface)
2051 {
2052     FIXME("iface %p stub!\n", iface);
2053
2054     return 0;
2055 }
2056
2057 static D3DCOLOR WINAPI d3drm_frame2_GetSceneFogColor(IDirect3DRMFrame2 *iface)
2058 {
2059     FIXME("iface %p stub!\n", iface);
2060
2061     return 0;
2062 }
2063
2064 static D3DCOLOR WINAPI d3drm_frame1_GetSceneFogColor(IDirect3DRMFrame *iface)
2065 {
2066     FIXME("iface %p stub!\n", iface);
2067
2068     return 0;
2069 }
2070
2071 static BOOL WINAPI d3drm_frame3_GetSceneFogEnable(IDirect3DRMFrame3 *iface)
2072 {
2073     FIXME("iface %p stub!\n", iface);
2074
2075     return FALSE;
2076 }
2077
2078 static BOOL WINAPI d3drm_frame2_GetSceneFogEnable(IDirect3DRMFrame2 *iface)
2079 {
2080     FIXME("iface %p stub!\n", iface);
2081
2082     return FALSE;
2083 }
2084
2085 static BOOL WINAPI d3drm_frame1_GetSceneFogEnable(IDirect3DRMFrame *iface)
2086 {
2087     FIXME("iface %p stub!\n", iface);
2088
2089     return FALSE;
2090 }
2091
2092 static D3DRMFOGMODE WINAPI d3drm_frame3_GetSceneFogMode(IDirect3DRMFrame3 *iface)
2093 {
2094     FIXME("iface %p stub!\n", iface);
2095
2096     return D3DRMFOG_LINEAR;
2097 }
2098
2099 static D3DRMFOGMODE WINAPI d3drm_frame2_GetSceneFogMode(IDirect3DRMFrame2 *iface)
2100 {
2101     FIXME("iface %p stub!\n", iface);
2102
2103     return D3DRMFOG_LINEAR;
2104 }
2105
2106 static D3DRMFOGMODE WINAPI d3drm_frame1_GetSceneFogMode(IDirect3DRMFrame *iface)
2107 {
2108     FIXME("iface %p stub!\n", iface);
2109
2110     return D3DRMFOG_LINEAR;
2111 }
2112
2113 static HRESULT WINAPI d3drm_frame3_GetSceneFogParams(IDirect3DRMFrame3 *iface,
2114         D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
2115 {
2116     FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
2117
2118     return E_NOTIMPL;
2119 }
2120
2121 static HRESULT WINAPI d3drm_frame2_GetSceneFogParams(IDirect3DRMFrame2 *iface,
2122         D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
2123 {
2124     FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
2125
2126     return E_NOTIMPL;
2127 }
2128
2129 static HRESULT WINAPI d3drm_frame1_GetSceneFogParams(IDirect3DRMFrame *iface,
2130         D3DVALUE *start, D3DVALUE *end, D3DVALUE *density)
2131 {
2132     FIXME("iface %p, start %p, end %p, density %p stub!\n", iface, start, end, density);
2133
2134     return E_NOTIMPL;
2135 }
2136
2137 static HRESULT WINAPI d3drm_frame3_SetSceneBackground(IDirect3DRMFrame3 *iface, D3DCOLOR color)
2138 {
2139     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
2140
2141     TRACE("iface %p, color 0x%08lx.\n", iface, color);
2142
2143     frame->scenebackground = color;
2144
2145     return D3DRM_OK;
2146 }
2147
2148 static HRESULT WINAPI d3drm_frame2_SetSceneBackground(IDirect3DRMFrame2 *iface, D3DCOLOR color)
2149 {
2150     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
2151
2152     TRACE("iface %p, color 0x%08lx.\n", iface, color);
2153
2154     return d3drm_frame3_SetSceneBackground(&frame->IDirect3DRMFrame3_iface, color);
2155 }
2156
2157 static HRESULT WINAPI d3drm_frame1_SetSceneBackground(IDirect3DRMFrame *iface, D3DCOLOR color)
2158 {
2159     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
2160
2161     TRACE("iface %p, color 0x%08lx.\n", iface, color);
2162
2163     return d3drm_frame3_SetSceneBackground(&frame->IDirect3DRMFrame3_iface, color);
2164 }
2165
2166 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundRGB(IDirect3DRMFrame3 *iface,
2167         D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2168 {
2169     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
2170
2171     TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
2172
2173     d3drm_set_color(&frame->scenebackground, red, green, blue, 1.0f);
2174
2175     return D3DRM_OK;
2176 }
2177
2178 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundRGB(IDirect3DRMFrame2 *iface,
2179         D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2180 {
2181     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
2182
2183     TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
2184
2185     return d3drm_frame3_SetSceneBackgroundRGB(&frame->IDirect3DRMFrame3_iface, red, green, blue);
2186 }
2187
2188 static HRESULT WINAPI d3drm_frame1_SetSceneBackgroundRGB(IDirect3DRMFrame *iface,
2189         D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2190 {
2191     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
2192
2193     TRACE("iface %p, red %.8e, green %.8e, blue %.8e.\n", iface, red, green, blue);
2194
2195     return d3drm_frame3_SetSceneBackgroundRGB(&frame->IDirect3DRMFrame3_iface, red, green, blue);
2196 }
2197
2198 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundDepth(IDirect3DRMFrame3 *iface,
2199         IDirectDrawSurface *surface)
2200 {
2201     FIXME("iface %p, surface %p stub!\n", iface, surface);
2202
2203     return E_NOTIMPL;
2204 }
2205
2206 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundDepth(IDirect3DRMFrame2 *iface,
2207         IDirectDrawSurface *surface)
2208 {
2209     FIXME("iface %p, surface %p stub!\n", iface, surface);
2210
2211     return E_NOTIMPL;
2212 }
2213
2214 static HRESULT WINAPI d3drm_frame1_SetSceneBackgroundDepth(IDirect3DRMFrame *iface,
2215         IDirectDrawSurface *surface)
2216 {
2217     FIXME("iface %p, surface %p stub!\n", iface, surface);
2218
2219     return E_NOTIMPL;
2220 }
2221
2222 static HRESULT WINAPI d3drm_frame3_SetSceneBackgroundImage(IDirect3DRMFrame3 *iface,
2223         IDirect3DRMTexture3 *texture)
2224 {
2225     FIXME("iface %p, texture %p stub!\n", iface, texture);
2226
2227     return E_NOTIMPL;
2228 }
2229
2230 static HRESULT WINAPI d3drm_frame2_SetSceneBackgroundImage(IDirect3DRMFrame2 *iface,
2231         IDirect3DRMTexture *texture)
2232 {
2233     FIXME("iface %p, texture %p stub!\n", iface, texture);
2234
2235     return E_NOTIMPL;
2236 }
2237
2238 static HRESULT WINAPI d3drm_frame1_SetSceneBackgroundImage(IDirect3DRMFrame *iface,
2239         IDirect3DRMTexture *texture)
2240 {
2241     FIXME("iface %p, texture %p stub!\n", iface, texture);
2242
2243     return E_NOTIMPL;
2244 }
2245
2246 static HRESULT WINAPI d3drm_frame3_SetSceneFogEnable(IDirect3DRMFrame3 *iface, BOOL enable)
2247 {
2248     FIXME("iface %p, enable %#x stub!\n", iface, enable);
2249
2250     return E_NOTIMPL;
2251 }
2252
2253 static HRESULT WINAPI d3drm_frame2_SetSceneFogEnable(IDirect3DRMFrame2 *iface, BOOL enable)
2254 {
2255     FIXME("iface %p, enable %#x stub!\n", iface, enable);
2256
2257     return E_NOTIMPL;
2258 }
2259
2260 static HRESULT WINAPI d3drm_frame1_SetSceneFogEnable(IDirect3DRMFrame *iface, BOOL enable)
2261 {
2262     FIXME("iface %p, enable %#x stub!\n", iface, enable);
2263
2264     return E_NOTIMPL;
2265 }
2266
2267 static HRESULT WINAPI d3drm_frame3_SetSceneFogColor(IDirect3DRMFrame3 *iface, D3DCOLOR color)
2268 {
2269     FIXME("iface %p, color 0x%08lx stub!\n", iface, color);
2270
2271     return E_NOTIMPL;
2272 }
2273
2274 static HRESULT WINAPI d3drm_frame2_SetSceneFogColor(IDirect3DRMFrame2 *iface, D3DCOLOR color)
2275 {
2276     FIXME("iface %p, color 0x%08lx stub!\n", iface, color);
2277
2278     return E_NOTIMPL;
2279 }
2280
2281 static HRESULT WINAPI d3drm_frame1_SetSceneFogColor(IDirect3DRMFrame *iface, D3DCOLOR color)
2282 {
2283     FIXME("iface %p, color 0x%08lx stub!\n", iface, color);
2284
2285     return E_NOTIMPL;
2286 }
2287
2288 static HRESULT WINAPI d3drm_frame3_SetSceneFogMode(IDirect3DRMFrame3 *iface, D3DRMFOGMODE mode)
2289 {
2290     FIXME("iface %p, mode %#x stub!\n", iface, mode);
2291
2292     return E_NOTIMPL;
2293 }
2294
2295 static HRESULT WINAPI d3drm_frame2_SetSceneFogMode(IDirect3DRMFrame2 *iface, D3DRMFOGMODE mode)
2296 {
2297     FIXME("iface %p, mode %#x stub!\n", iface, mode);
2298
2299     return E_NOTIMPL;
2300 }
2301
2302 static HRESULT WINAPI d3drm_frame1_SetSceneFogMode(IDirect3DRMFrame *iface, D3DRMFOGMODE mode)
2303 {
2304     FIXME("iface %p, mode %#x stub!\n", iface, mode);
2305
2306     return E_NOTIMPL;
2307 }
2308
2309 static HRESULT WINAPI d3drm_frame3_SetSceneFogParams(IDirect3DRMFrame3 *iface,
2310         D3DVALUE start, D3DVALUE end, D3DVALUE density)
2311 {
2312     FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
2313
2314     return E_NOTIMPL;
2315 }
2316
2317 static HRESULT WINAPI d3drm_frame2_SetSceneFogParams(IDirect3DRMFrame2 *iface,
2318         D3DVALUE start, D3DVALUE end, D3DVALUE density)
2319 {
2320     FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
2321
2322     return E_NOTIMPL;
2323 }
2324
2325 static HRESULT WINAPI d3drm_frame1_SetSceneFogParams(IDirect3DRMFrame *iface,
2326         D3DVALUE start, D3DVALUE end, D3DVALUE density)
2327 {
2328     FIXME("iface %p, start %.8e, end %.8e, density %.8e stub!\n", iface, start, end, density);
2329
2330     return E_NOTIMPL;
2331 }
2332
2333 static HRESULT WINAPI d3drm_frame3_SetColor(IDirect3DRMFrame3 *iface, D3DCOLOR color)
2334 {
2335     FIXME("iface %p, color 0x%08lx stub!\n", iface, color);
2336
2337     return E_NOTIMPL;
2338 }
2339
2340 static HRESULT WINAPI d3drm_frame2_SetColor(IDirect3DRMFrame2 *iface, D3DCOLOR color)
2341 {
2342     FIXME("iface %p, color 0x%08lx stub!\n", iface, color);
2343
2344     return E_NOTIMPL;
2345 }
2346
2347 static HRESULT WINAPI d3drm_frame1_SetColor(IDirect3DRMFrame *iface, D3DCOLOR color)
2348 {
2349     FIXME("iface %p, color 0x%08lx stub!\n", iface, color);
2350
2351     return E_NOTIMPL;
2352 }
2353
2354 static HRESULT WINAPI d3drm_frame3_SetColorRGB(IDirect3DRMFrame3 *iface,
2355         D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2356 {
2357     FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
2358
2359     return E_NOTIMPL;
2360 }
2361
2362 static HRESULT WINAPI d3drm_frame2_SetColorRGB(IDirect3DRMFrame2 *iface,
2363         D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2364 {
2365     FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
2366
2367     return E_NOTIMPL;
2368 }
2369
2370 static HRESULT WINAPI d3drm_frame1_SetColorRGB(IDirect3DRMFrame *iface,
2371         D3DVALUE red, D3DVALUE green, D3DVALUE blue)
2372 {
2373     FIXME("iface %p, red %.8e, green %.8e, blue %.8e stub!\n", iface, red, green, blue);
2374
2375     return E_NOTIMPL;
2376 }
2377
2378 static D3DRMZBUFFERMODE WINAPI d3drm_frame3_GetZbufferMode(IDirect3DRMFrame3 *iface)
2379 {
2380     FIXME("iface %p stub!\n", iface);
2381
2382     return D3DRMZBUFFER_FROMPARENT;
2383 }
2384
2385 static D3DRMZBUFFERMODE WINAPI d3drm_frame2_GetZbufferMode(IDirect3DRMFrame2 *iface)
2386 {
2387     FIXME("iface %p stub!\n", iface);
2388
2389     return D3DRMZBUFFER_FROMPARENT;
2390 }
2391
2392 static D3DRMZBUFFERMODE WINAPI d3drm_frame1_GetZbufferMode(IDirect3DRMFrame *iface)
2393 {
2394     FIXME("iface %p stub!\n", iface);
2395
2396     return D3DRMZBUFFER_FROMPARENT;
2397 }
2398
2399 static HRESULT WINAPI d3drm_frame3_SetMaterialMode(IDirect3DRMFrame3 *iface, D3DRMMATERIALMODE mode)
2400 {
2401     FIXME("iface %p, mode %#x stub!\n", iface, mode);
2402
2403     return E_NOTIMPL;
2404 }
2405
2406 static HRESULT WINAPI d3drm_frame2_SetMaterialMode(IDirect3DRMFrame2 *iface, D3DRMMATERIALMODE mode)
2407 {
2408     FIXME("iface %p, mode %#x stub!\n", iface, mode);
2409
2410     return E_NOTIMPL;
2411 }
2412
2413 static HRESULT WINAPI d3drm_frame1_SetMaterialMode(IDirect3DRMFrame *iface, D3DRMMATERIALMODE mode)
2414 {
2415     FIXME("iface %p, mode %#x stub!\n", iface, mode);
2416
2417     return E_NOTIMPL;
2418 }
2419
2420 static HRESULT WINAPI d3drm_frame3_SetOrientation(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *reference,
2421         D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2422 {
2423     FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2424             iface, reference, dx, dy, dz, ux, uy, uz);
2425
2426     return E_NOTIMPL;
2427 }
2428
2429 static HRESULT WINAPI d3drm_frame2_SetOrientation(IDirect3DRMFrame2 *iface, IDirect3DRMFrame *reference,
2430         D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2431 {
2432     FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2433             iface, reference, dx, dy, dz, ux, uy, uz);
2434
2435     return E_NOTIMPL;
2436 }
2437
2438 static HRESULT WINAPI d3drm_frame1_SetOrientation(IDirect3DRMFrame *iface, IDirect3DRMFrame *reference,
2439         D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2440 {
2441     FIXME("iface %p, reference %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2442             iface, reference, dx, dy, dz, ux, uy, uz);
2443
2444     return E_NOTIMPL;
2445 }
2446
2447 static HRESULT WINAPI d3drm_frame3_SetPosition(IDirect3DRMFrame3 *iface,
2448         IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2449 {
2450     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2451
2452     return E_NOTIMPL;
2453 }
2454
2455 static HRESULT WINAPI d3drm_frame2_SetPosition(IDirect3DRMFrame2 *iface,
2456         IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2457 {
2458     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2459
2460     return E_NOTIMPL;
2461 }
2462
2463 static HRESULT WINAPI d3drm_frame1_SetPosition(IDirect3DRMFrame *iface,
2464         IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z)
2465 {
2466     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e stub!\n", iface, reference, x, y, z);
2467
2468     return E_NOTIMPL;
2469 }
2470
2471 static HRESULT WINAPI d3drm_frame3_SetRotation(IDirect3DRMFrame3 *iface,
2472         IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2473 {
2474     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2475             iface, reference, x, y, z, theta);
2476
2477     return E_NOTIMPL;
2478 }
2479
2480 static HRESULT WINAPI d3drm_frame2_SetRotation(IDirect3DRMFrame2 *iface,
2481         IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2482 {
2483     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2484             iface, reference, x, y, z, theta);
2485
2486     return E_NOTIMPL;
2487 }
2488
2489 static HRESULT WINAPI d3drm_frame1_SetRotation(IDirect3DRMFrame *iface,
2490         IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, D3DVALUE theta)
2491 {
2492     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, theta %.8e stub!\n",
2493             iface, reference, x, y, z, theta);
2494
2495     return E_NOTIMPL;
2496 }
2497
2498 static HRESULT WINAPI d3drm_frame3_SetSortMode(IDirect3DRMFrame3 *iface, D3DRMSORTMODE mode)
2499 {
2500     FIXME("iface %p, mode %#x stub!\n", iface, mode);
2501
2502     return E_NOTIMPL;
2503 }
2504
2505 static HRESULT WINAPI d3drm_frame2_SetSortMode(IDirect3DRMFrame2 *iface, D3DRMSORTMODE mode)
2506 {
2507     FIXME("iface %p, mode %#x stub!\n", iface, mode);
2508
2509     return E_NOTIMPL;
2510 }
2511
2512 static HRESULT WINAPI d3drm_frame1_SetSortMode(IDirect3DRMFrame *iface, D3DRMSORTMODE mode)
2513 {
2514     FIXME("iface %p, mode %#x stub!\n", iface, mode);
2515
2516     return E_NOTIMPL;
2517 }
2518
2519 static HRESULT WINAPI d3drm_frame3_SetTexture(IDirect3DRMFrame3 *iface, IDirect3DRMTexture3 *texture)
2520 {
2521     FIXME("iface %p, texture %p stub!\n", iface, texture);
2522
2523     return E_NOTIMPL;
2524 }
2525
2526 static HRESULT WINAPI d3drm_frame2_SetTexture(IDirect3DRMFrame2 *iface, IDirect3DRMTexture *texture)
2527 {
2528     FIXME("iface %p, texture %p stub!\n", iface, texture);
2529
2530     return E_NOTIMPL;
2531 }
2532
2533 static HRESULT WINAPI d3drm_frame1_SetTexture(IDirect3DRMFrame *iface, IDirect3DRMTexture *texture)
2534 {
2535     FIXME("iface %p, texture %p stub!\n", iface, texture);
2536
2537     return E_NOTIMPL;
2538 }
2539
2540 static HRESULT WINAPI d3drm_frame2_SetTextureTopology(IDirect3DRMFrame2 *iface, BOOL wrap_u, BOOL wrap_v)
2541 {
2542     FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
2543
2544     return E_NOTIMPL;
2545 }
2546
2547 static HRESULT WINAPI d3drm_frame1_SetTextureTopology(IDirect3DRMFrame *iface, BOOL wrap_u, BOOL wrap_v)
2548 {
2549     FIXME("iface %p, wrap_u %#x, wrap_v %#x stub!\n", iface, wrap_u, wrap_v);
2550
2551     return E_NOTIMPL;
2552 }
2553
2554 static HRESULT WINAPI d3drm_frame3_SetVelocity(IDirect3DRMFrame3 *iface,
2555         IDirect3DRMFrame3 *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2556 {
2557     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x.\n",
2558             iface, reference, x, y, z, with_rotation);
2559
2560     return E_NOTIMPL;
2561 }
2562
2563 static HRESULT WINAPI d3drm_frame2_SetVelocity(IDirect3DRMFrame2 *iface,
2564         IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2565 {
2566     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x stub!\n",
2567             iface, reference, x, y, z, with_rotation);
2568
2569     return E_NOTIMPL;
2570 }
2571
2572 static HRESULT WINAPI d3drm_frame1_SetVelocity(IDirect3DRMFrame *iface,
2573         IDirect3DRMFrame *reference, D3DVALUE x, D3DVALUE y, D3DVALUE z, BOOL with_rotation)
2574 {
2575     FIXME("iface %p, reference %p, x %.8e, y %.8e, z %.8e, with_rotation %#x stub!\n",
2576             iface, reference, x, y, z, with_rotation);
2577
2578     return E_NOTIMPL;
2579 }
2580
2581 static HRESULT WINAPI d3drm_frame3_SetZbufferMode(IDirect3DRMFrame3 *iface, D3DRMZBUFFERMODE mode)
2582 {
2583     FIXME("iface %p, mode %#x stub!\n", iface, mode);
2584
2585     return E_NOTIMPL;
2586 }
2587
2588 static HRESULT WINAPI d3drm_frame2_SetZbufferMode(IDirect3DRMFrame2 *iface, D3DRMZBUFFERMODE mode)
2589 {
2590     FIXME("iface %p, mode %#x stub!\n", iface, mode);
2591
2592     return E_NOTIMPL;
2593 }
2594
2595 static HRESULT WINAPI d3drm_frame1_SetZbufferMode(IDirect3DRMFrame *iface, D3DRMZBUFFERMODE mode)
2596 {
2597     FIXME("iface %p, mode %#x stub!\n", iface, mode);
2598
2599     return E_NOTIMPL;
2600 }
2601
2602 static HRESULT WINAPI d3drm_frame3_Transform(IDirect3DRMFrame3 *iface, D3DVECTOR *d, D3DVECTOR *s)
2603 {
2604     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
2605
2606     TRACE("iface %p, d %p, s %p.\n", iface, d, s);
2607
2608     d3drm_vector_transform_affine(d, s, &frame->transform);
2609     while ((frame = frame->parent))
2610     {
2611         d3drm_vector_transform_affine(d, d, &frame->transform);
2612     }
2613
2614     return D3DRM_OK;
2615 }
2616
2617 static HRESULT WINAPI d3drm_frame2_Transform(IDirect3DRMFrame2 *iface, D3DVECTOR *d, D3DVECTOR *s)
2618 {
2619     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame2(iface);
2620
2621     TRACE("iface %p, d %p, s %p.\n", iface, d, s);
2622
2623     return d3drm_frame3_Transform(&frame->IDirect3DRMFrame3_iface, d, s);
2624 }
2625
2626 static HRESULT WINAPI d3drm_frame1_Transform(IDirect3DRMFrame *iface, D3DVECTOR *d, D3DVECTOR *s)
2627 {
2628     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame(iface);
2629
2630     TRACE("iface %p, d %p, s %p.\n", iface, d, s);
2631
2632     return d3drm_frame3_Transform(&frame->IDirect3DRMFrame3_iface, d, s);
2633 }
2634
2635 static HRESULT WINAPI d3drm_frame2_AddMoveCallback2(IDirect3DRMFrame2 *iface,
2636         D3DRMFRAMEMOVECALLBACK cb, void *ctx, DWORD flags)
2637 {
2638     FIXME("iface %p, cb %p, ctx %p, flags %#lx stub!\n", iface, cb, ctx, flags);
2639
2640     return E_NOTIMPL;
2641 }
2642
2643 static HRESULT WINAPI d3drm_frame3_GetBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2644 {
2645     FIXME("iface %p, box %p stub!\n", iface, box);
2646
2647     return E_NOTIMPL;
2648 }
2649
2650 static HRESULT WINAPI d3drm_frame2_GetBox(IDirect3DRMFrame2 *iface, D3DRMBOX *box)
2651 {
2652     FIXME("iface %p, box %p stub!\n", iface, box);
2653
2654     return E_NOTIMPL;
2655 }
2656
2657 static BOOL WINAPI d3drm_frame3_GetBoxEnable(IDirect3DRMFrame3 *iface)
2658 {
2659     FIXME("iface %p stub!\n", iface);
2660
2661     return FALSE;
2662 }
2663
2664 static BOOL WINAPI d3drm_frame2_GetBoxEnable(IDirect3DRMFrame2 *iface)
2665 {
2666     FIXME("iface %p stub!\n", iface);
2667
2668     return FALSE;
2669 }
2670
2671 static HRESULT WINAPI d3drm_frame3_GetAxes(IDirect3DRMFrame3 *iface, D3DVECTOR *dir, D3DVECTOR *up)
2672 {
2673     FIXME("iface %p, dir %p, up %p stub!\n", iface, dir, up);
2674
2675     return E_NOTIMPL;
2676 }
2677
2678 static HRESULT WINAPI d3drm_frame2_GetAxes(IDirect3DRMFrame2 *iface, D3DVECTOR *dir, D3DVECTOR *up)
2679 {
2680     FIXME("iface %p, dir %p, up %p stub!\n", iface, dir, up);
2681
2682     return E_NOTIMPL;
2683 }
2684
2685 static HRESULT WINAPI d3drm_frame3_GetMaterial(IDirect3DRMFrame3 *iface, IDirect3DRMMaterial2 **material)
2686 {
2687     FIXME("iface %p, material %p stub!\n", iface, material);
2688
2689     return E_NOTIMPL;
2690 }
2691
2692 static HRESULT WINAPI d3drm_frame2_GetMaterial(IDirect3DRMFrame2 *iface, IDirect3DRMMaterial **material)
2693 {
2694     FIXME("iface %p, material %p stub!\n", iface, material);
2695
2696     return E_NOTIMPL;
2697 }
2698
2699 static BOOL WINAPI d3drm_frame3_GetInheritAxes(IDirect3DRMFrame3 *iface)
2700 {
2701     FIXME("iface %p stub!\n", iface);
2702
2703     return FALSE;
2704 }
2705
2706 static BOOL WINAPI d3drm_frame2_GetInheritAxes(IDirect3DRMFrame2 *iface)
2707 {
2708     FIXME("iface %p stub!\n", iface);
2709
2710     return FALSE;
2711 }
2712
2713 static HRESULT WINAPI d3drm_frame3_GetHierarchyBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2714 {
2715     FIXME("iface %p, box %p stub!\n", iface, box);
2716
2717     return E_NOTIMPL;
2718 }
2719
2720 static HRESULT WINAPI d3drm_frame2_GetHierarchyBox(IDirect3DRMFrame2 *iface, D3DRMBOX *box)
2721 {
2722     FIXME("iface %p, box %p stub!\n", iface, box);
2723
2724     return E_NOTIMPL;
2725 }
2726
2727 static HRESULT WINAPI d3drm_frame3_SetBox(IDirect3DRMFrame3 *iface, D3DRMBOX *box)
2728 {
2729     FIXME("iface %p, box %p stub!\n", iface, box);
2730
2731     return E_NOTIMPL;
2732 }
2733
2734 static HRESULT WINAPI d3drm_frame3_SetBoxEnable(IDirect3DRMFrame3 *iface, BOOL enable)
2735 {
2736     FIXME("iface %p, enable %#x stub!\n", iface, enable);
2737
2738     return E_NOTIMPL;
2739 }
2740
2741 static HRESULT WINAPI d3drm_frame3_SetAxes(IDirect3DRMFrame3 *iface,
2742         D3DVALUE dx, D3DVALUE dy, D3DVALUE dz, D3DVALUE ux, D3DVALUE uy, D3DVALUE uz)
2743 {
2744     FIXME("iface %p, dx %.8e, dy %.8e, dz %.8e, ux %.8e, uy %.8e, uz %.8e stub!\n",
2745             iface, dx, dy, dz, ux, uy, uz);
2746
2747     return E_NOTIMPL;
2748 }
2749
2750 static HRESULT WINAPI d3drm_frame3_SetInheritAxes(IDirect3DRMFrame3 *iface, BOOL inherit)
2751 {
2752     FIXME("iface %p, inherit %#x stub!\n", iface, inherit);
2753
2754     return E_NOTIMPL;
2755 }
2756
2757 static HRESULT WINAPI d3drm_frame3_SetMaterial(IDirect3DRMFrame3 *iface, IDirect3DRMMaterial2 *material)
2758 {
2759     FIXME("iface %p, material %p stub!\n", iface, material);
2760
2761     return E_NOTIMPL;
2762 }
2763
2764 static HRESULT WINAPI d3drm_frame3_SetQuaternion(IDirect3DRMFrame3 *iface,
2765         IDirect3DRMFrame3 *reference, D3DRMQUATERNION *q)
2766 {
2767     FIXME("iface %p, reference %p, q %p stub!\n", iface, reference, q);
2768
2769     return E_NOTIMPL;
2770 }
2771
2772 static HRESULT WINAPI d3drm_frame3_RayPick(IDirect3DRMFrame3 *iface, IDirect3DRMFrame3 *reference,
2773         D3DRMRAY *ray, DWORD flags, IDirect3DRMPicked2Array **visuals)
2774 {
2775     FIXME("iface %p, reference %p, ray %p, flags %#lx, visuals %p stub!\n",
2776             iface, reference, ray, flags, visuals);
2777
2778     return E_NOTIMPL;
2779 }
2780
2781 static HRESULT WINAPI d3drm_frame3_Save(IDirect3DRMFrame3 *iface,
2782         const char *filename, D3DRMXOFFORMAT format, D3DRMSAVEOPTIONS flags)
2783 {
2784     FIXME("iface %p, filename %s, format %#x, flags %#lx stub!\n",
2785             iface, debugstr_a(filename), format, flags);
2786
2787     return E_NOTIMPL;
2788 }
2789
2790 static HRESULT WINAPI d3drm_frame3_TransformVectors(IDirect3DRMFrame3 *iface,
2791         IDirect3DRMFrame3 *reference, DWORD num, D3DVECTOR *dst, D3DVECTOR *src)
2792 {
2793     FIXME("iface %p, reference %p, num %lu, dst %p, src %p stub!\n", iface, reference, num, dst, src);
2794
2795     return E_NOTIMPL;
2796 }
2797
2798 static HRESULT WINAPI d3drm_frame3_InverseTransformVectors(IDirect3DRMFrame3 *iface,
2799         IDirect3DRMFrame3 *reference, DWORD num, D3DVECTOR *dst, D3DVECTOR *src)
2800 {
2801     FIXME("iface %p, reference %p, num %lu, dst %p, src %p stub!\n", iface, reference, num, dst, src);
2802
2803     return E_NOTIMPL;
2804 }
2805
2806 static HRESULT WINAPI d3drm_frame3_SetTraversalOptions(IDirect3DRMFrame3 *iface, DWORD options)
2807 {
2808     static const DWORD supported_options = D3DRMFRAME_RENDERENABLE | D3DRMFRAME_PICKENABLE;
2809     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
2810
2811     TRACE("iface %p, options %#lx.\n", iface, options);
2812
2813     if (options & ~supported_options)
2814         return D3DRMERR_BADVALUE;
2815
2816     frame->traversal_options = options;
2817
2818     return D3DRM_OK;
2819 }
2820
2821 static HRESULT WINAPI d3drm_frame3_GetTraversalOptions(IDirect3DRMFrame3 *iface, DWORD *options)
2822 {
2823     struct d3drm_frame *frame = impl_from_IDirect3DRMFrame3(iface);
2824
2825     TRACE("iface %p, options %p.\n", iface, options);
2826
2827     if (!options)
2828         return D3DRMERR_BADVALUE;
2829
2830     *options = frame->traversal_options;
2831
2832     return D3DRM_OK;
2833 }
2834
2835 static HRESULT WINAPI d3drm_frame3_SetSceneFogMethod(IDirect3DRMFrame3 *iface, DWORD flags)
2836 {
2837     FIXME("iface %p, flags %#lx stub!\n", iface, flags);
2838
2839     return E_NOTIMPL;
2840 }
2841
2842 static HRESULT WINAPI d3drm_frame3_GetSceneFogMethod(IDirect3DRMFrame3 *iface, DWORD *fog_mode)
2843 {
2844     FIXME("iface %p, fog_mode %p stub!\n", iface, fog_mode);
2845
2846     return E_NOTIMPL;
2847 }
2848
2849 static HRESULT WINAPI d3drm_frame3_SetMaterialOverride(IDirect3DRMFrame3 *iface,
2850         D3DRMMATERIALOVERRIDE *override)
2851 {
2852     FIXME("iface %p, override %p stub!\n", iface, override);
2853
2854     return E_NOTIMPL;
2855 }
2856
2857 static HRESULT WINAPI d3drm_frame3_GetMaterialOverride(IDirect3DRMFrame3 *iface,
2858         D3DRMMATERIALOVERRIDE *override)
2859 {
2860     FIXME("iface %p, override %p stub!\n", iface, override);
2861
2862     return E_NOTIMPL;
2863 }
2864
2865 static const struct IDirect3DRMFrame3Vtbl d3drm_frame3_vtbl =
2866 {
2867     d3drm_frame3_QueryInterface,
2868     d3drm_frame3_AddRef,
2869     d3drm_frame3_Release,
2870     d3drm_frame3_Clone,
2871     d3drm_frame3_AddDestroyCallback,
2872     d3drm_frame3_DeleteDestroyCallback,
2873     d3drm_frame3_SetAppData,
2874     d3drm_frame3_GetAppData,
2875     d3drm_frame3_SetName,
2876     d3drm_frame3_GetName,
2877     d3drm_frame3_GetClassName,
2878     d3drm_frame3_AddChild,
2879     d3drm_frame3_AddLight,
2880     d3drm_frame3_AddMoveCallback,
2881     d3drm_frame3_AddTransform,
2882     d3drm_frame3_AddTranslation,
2883     d3drm_frame3_AddScale,
2884     d3drm_frame3_AddRotation,
2885     d3drm_frame3_AddVisual,
2886     d3drm_frame3_GetChildren,
2887     d3drm_frame3_GetColor,
2888     d3drm_frame3_GetLights,
2889     d3drm_frame3_GetMaterialMode,
2890     d3drm_frame3_GetParent,
2891     d3drm_frame3_GetPosition,
2892     d3drm_frame3_GetRotation,
2893     d3drm_frame3_GetScene,
2894     d3drm_frame3_GetSortMode,
2895     d3drm_frame3_GetTexture,
2896     d3drm_frame3_GetTransform,
2897     d3drm_frame3_GetVelocity,
2898     d3drm_frame3_GetOrientation,
2899     d3drm_frame3_GetVisuals,
2900     d3drm_frame3_InverseTransform,
2901     d3drm_frame3_Load,
2902     d3drm_frame3_LookAt,
2903     d3drm_frame3_Move,
2904     d3drm_frame3_DeleteChild,
2905     d3drm_frame3_DeleteLight,
2906     d3drm_frame3_DeleteMoveCallback,
2907     d3drm_frame3_DeleteVisual,
2908     d3drm_frame3_GetSceneBackground,
2909     d3drm_frame3_GetSceneBackgroundDepth,
2910     d3drm_frame3_GetSceneFogColor,
2911     d3drm_frame3_GetSceneFogEnable,
2912     d3drm_frame3_GetSceneFogMode,
2913     d3drm_frame3_GetSceneFogParams,
2914     d3drm_frame3_SetSceneBackground,
2915     d3drm_frame3_SetSceneBackgroundRGB,
2916     d3drm_frame3_SetSceneBackgroundDepth,
2917     d3drm_frame3_SetSceneBackgroundImage,
2918     d3drm_frame3_SetSceneFogEnable,
2919     d3drm_frame3_SetSceneFogColor,
2920     d3drm_frame3_SetSceneFogMode,
2921     d3drm_frame3_SetSceneFogParams,
2922     d3drm_frame3_SetColor,
2923     d3drm_frame3_SetColorRGB,
2924     d3drm_frame3_GetZbufferMode,
2925     d3drm_frame3_SetMaterialMode,
2926     d3drm_frame3_SetOrientation,
2927     d3drm_frame3_SetPosition,
2928     d3drm_frame3_SetRotation,
2929     d3drm_frame3_SetSortMode,
2930     d3drm_frame3_SetTexture,
2931     d3drm_frame3_SetVelocity,
2932     d3drm_frame3_SetZbufferMode,
2933     d3drm_frame3_Transform,
2934     d3drm_frame3_GetBox,
2935     d3drm_frame3_GetBoxEnable,
2936     d3drm_frame3_GetAxes,
2937     d3drm_frame3_GetMaterial,
2938     d3drm_frame3_GetInheritAxes,
2939     d3drm_frame3_GetHierarchyBox,
2940     d3drm_frame3_SetBox,
2941     d3drm_frame3_SetBoxEnable,
2942     d3drm_frame3_SetAxes,
2943     d3drm_frame3_SetInheritAxes,
2944     d3drm_frame3_SetMaterial,
2945     d3drm_frame3_SetQuaternion,
2946     d3drm_frame3_RayPick,
2947     d3drm_frame3_Save,
2948     d3drm_frame3_TransformVectors,
2949     d3drm_frame3_InverseTransformVectors,
2950     d3drm_frame3_SetTraversalOptions,
2951     d3drm_frame3_GetTraversalOptions,
2952     d3drm_frame3_SetSceneFogMethod,
2953     d3drm_frame3_GetSceneFogMethod,
2954     d3drm_frame3_SetMaterialOverride,
2955     d3drm_frame3_GetMaterialOverride,
2956 };
2957
2958 static const struct IDirect3DRMFrame2Vtbl d3drm_frame2_vtbl =
2959 {
2960     d3drm_frame2_QueryInterface,
2961     d3drm_frame2_AddRef,
2962     d3drm_frame2_Release,
2963     d3drm_frame2_Clone,
2964     d3drm_frame2_AddDestroyCallback,
2965     d3drm_frame2_DeleteDestroyCallback,
2966     d3drm_frame2_SetAppData,
2967     d3drm_frame2_GetAppData,
2968     d3drm_frame2_SetName,
2969     d3drm_frame2_GetName,
2970     d3drm_frame2_GetClassName,
2971     d3drm_frame2_AddChild,
2972     d3drm_frame2_AddLight,
2973     d3drm_frame2_AddMoveCallback,
2974     d3drm_frame2_AddTransform,
2975     d3drm_frame2_AddTranslation,
2976     d3drm_frame2_AddScale,
2977     d3drm_frame2_AddRotation,
2978     d3drm_frame2_AddVisual,
2979     d3drm_frame2_GetChildren,
2980     d3drm_frame2_GetColor,
2981     d3drm_frame2_GetLights,
2982     d3drm_frame2_GetMaterialMode,
2983     d3drm_frame2_GetParent,
2984     d3drm_frame2_GetPosition,
2985     d3drm_frame2_GetRotation,
2986     d3drm_frame2_GetScene,
2987     d3drm_frame2_GetSortMode,
2988     d3drm_frame2_GetTexture,
2989     d3drm_frame2_GetTransform,
2990     d3drm_frame2_GetVelocity,
2991     d3drm_frame2_GetOrientation,
2992     d3drm_frame2_GetVisuals,
2993     d3drm_frame2_GetTextureTopology,
2994     d3drm_frame2_InverseTransform,
2995     d3drm_frame2_Load,
2996     d3drm_frame2_LookAt,
2997     d3drm_frame2_Move,
2998     d3drm_frame2_DeleteChild,
2999     d3drm_frame2_DeleteLight,
3000     d3drm_frame2_DeleteMoveCallback,
3001     d3drm_frame2_DeleteVisual,
3002     d3drm_frame2_GetSceneBackground,
3003     d3drm_frame2_GetSceneBackgroundDepth,
3004     d3drm_frame2_GetSceneFogColor,
3005     d3drm_frame2_GetSceneFogEnable,
3006     d3drm_frame2_GetSceneFogMode,
3007     d3drm_frame2_GetSceneFogParams,
3008     d3drm_frame2_SetSceneBackground,
3009     d3drm_frame2_SetSceneBackgroundRGB,
3010     d3drm_frame2_SetSceneBackgroundDepth,
3011     d3drm_frame2_SetSceneBackgroundImage,
3012     d3drm_frame2_SetSceneFogEnable,
3013     d3drm_frame2_SetSceneFogColor,
3014     d3drm_frame2_SetSceneFogMode,
3015     d3drm_frame2_SetSceneFogParams,
3016     d3drm_frame2_SetColor,
3017     d3drm_frame2_SetColorRGB,
3018     d3drm_frame2_GetZbufferMode,
3019     d3drm_frame2_SetMaterialMode,
3020     d3drm_frame2_SetOrientation,
3021     d3drm_frame2_SetPosition,
3022     d3drm_frame2_SetRotation,
3023     d3drm_frame2_SetSortMode,
3024     d3drm_frame2_SetTexture,
3025     d3drm_frame2_SetTextureTopology,
3026     d3drm_frame2_SetVelocity,
3027     d3drm_frame2_SetZbufferMode,
3028     d3drm_frame2_Transform,
3029     d3drm_frame2_AddMoveCallback2,
3030     d3drm_frame2_GetBox,
3031     d3drm_frame2_GetBoxEnable,
3032     d3drm_frame2_GetAxes,
3033     d3drm_frame2_GetMaterial,
3034     d3drm_frame2_GetInheritAxes,
3035     d3drm_frame2_GetHierarchyBox,
3036 };
3037
3038 static const struct IDirect3DRMFrameVtbl d3drm_frame1_vtbl =
3039 {
3040     d3drm_frame1_QueryInterface,
3041     d3drm_frame1_AddRef,
3042     d3drm_frame1_Release,
3043     d3drm_frame1_Clone,
3044     d3drm_frame1_AddDestroyCallback,
3045     d3drm_frame1_DeleteDestroyCallback,
3046     d3drm_frame1_SetAppData,
3047     d3drm_frame1_GetAppData,
3048     d3drm_frame1_SetName,
3049     d3drm_frame1_GetName,
3050     d3drm_frame1_GetClassName,
3051     d3drm_frame1_AddChild,
3052     d3drm_frame1_AddLight,
3053     d3drm_frame1_AddMoveCallback,
3054     d3drm_frame1_AddTransform,
3055     d3drm_frame1_AddTranslation,
3056     d3drm_frame1_AddScale,
3057     d3drm_frame1_AddRotation,
3058     d3drm_frame1_AddVisual,
3059     d3drm_frame1_GetChildren,
3060     d3drm_frame1_GetColor,
3061     d3drm_frame1_GetLights,
3062     d3drm_frame1_GetMaterialMode,
3063     d3drm_frame1_GetParent,
3064     d3drm_frame1_GetPosition,
3065     d3drm_frame1_GetRotation,
3066     d3drm_frame1_GetScene,
3067     d3drm_frame1_GetSortMode,
3068     d3drm_frame1_GetTexture,
3069     d3drm_frame1_GetTransform,
3070     d3drm_frame1_GetVelocity,
3071     d3drm_frame1_GetOrientation,
3072     d3drm_frame1_GetVisuals,
3073     d3drm_frame1_GetTextureTopology,
3074     d3drm_frame1_InverseTransform,
3075     d3drm_frame1_Load,
3076     d3drm_frame1_LookAt,
3077     d3drm_frame1_Move,
3078     d3drm_frame1_DeleteChild,
3079     d3drm_frame1_DeleteLight,
3080     d3drm_frame1_DeleteMoveCallback,
3081     d3drm_frame1_DeleteVisual,
3082     d3drm_frame1_GetSceneBackground,
3083     d3drm_frame1_GetSceneBackgroundDepth,
3084     d3drm_frame1_GetSceneFogColor,
3085     d3drm_frame1_GetSceneFogEnable,
3086     d3drm_frame1_GetSceneFogMode,
3087     d3drm_frame1_GetSceneFogParams,
3088     d3drm_frame1_SetSceneBackground,
3089     d3drm_frame1_SetSceneBackgroundRGB,
3090     d3drm_frame1_SetSceneBackgroundDepth,
3091     d3drm_frame1_SetSceneBackgroundImage,
3092     d3drm_frame1_SetSceneFogEnable,
3093     d3drm_frame1_SetSceneFogColor,
3094     d3drm_frame1_SetSceneFogMode,
3095     d3drm_frame1_SetSceneFogParams,
3096     d3drm_frame1_SetColor,
3097     d3drm_frame1_SetColorRGB,
3098     d3drm_frame1_GetZbufferMode,
3099     d3drm_frame1_SetMaterialMode,
3100     d3drm_frame1_SetOrientation,
3101     d3drm_frame1_SetPosition,
3102     d3drm_frame1_SetRotation,
3103     d3drm_frame1_SetSortMode,
3104     d3drm_frame1_SetTexture,
3105     d3drm_frame1_SetTextureTopology,
3106     d3drm_frame1_SetVelocity,
3107     d3drm_frame1_SetZbufferMode,
3108     d3drm_frame1_Transform,
3109 };
3110
3111 struct d3drm_frame *unsafe_impl_from_IDirect3DRMFrame3(IDirect3DRMFrame3 *iface)
3112 {
3113     if (!iface)
3114         return NULL;
3115     assert(iface->lpVtbl == &d3drm_frame3_vtbl);
3116
3117     return impl_from_IDirect3DRMFrame3(iface);
3118 }
3119
3120 struct d3drm_frame *unsafe_impl_from_IDirect3DRMFrame(IDirect3DRMFrame *iface)
3121 {
3122     if (!iface)
3123         return NULL;
3124     assert(iface->lpVtbl == &d3drm_frame1_vtbl);
3125
3126     return impl_from_IDirect3DRMFrame(iface);
3127 }
3128
3129 HRESULT d3drm_frame_create(struct d3drm_frame **frame, IUnknown *parent_frame, IDirect3DRM *d3drm)
3130 {
3131     static const char classname[] = "Frame";
3132     struct d3drm_frame *object;
3133     HRESULT hr = D3DRM_OK;
3134
3135     TRACE("frame %p, parent_frame %p, d3drm %p.\n", frame, parent_frame, d3drm);
3136
3137     if (!(object = calloc(1, sizeof(*object))))
3138         return E_OUTOFMEMORY;
3139
3140     object->IDirect3DRMFrame_iface.lpVtbl = &d3drm_frame1_vtbl;
3141     object->IDirect3DRMFrame2_iface.lpVtbl = &d3drm_frame2_vtbl;
3142     object->IDirect3DRMFrame3_iface.lpVtbl = &d3drm_frame3_vtbl;
3143     object->d3drm = d3drm;
3144     object->ref = 1;
3145     d3drm_set_color(&object->scenebackground, 0.0f, 0.0f, 0.0f, 1.0f);
3146     object->traversal_options = D3DRMFRAME_RENDERENABLE | D3DRMFRAME_PICKENABLE;
3147
3148     d3drm_object_init(&object->obj, classname);
3149
3150     object->transform = identity;
3151
3152     if (parent_frame)
3153     {
3154         IDirect3DRMFrame3 *p;
3155
3156         if (FAILED(hr = IDirect3DRMFrame_QueryInterface(parent_frame, &IID_IDirect3DRMFrame3, (void **)&p)))
3157         {
3158             free(object);
3159             return hr;
3160         }
3161         IDirect3DRMFrame_Release(parent_frame);
3162         IDirect3DRMFrame3_AddChild(p, &object->IDirect3DRMFrame3_iface);
3163     }
3164
3165     IDirect3DRM_AddRef(object->d3drm);
3166
3167     *frame = object;
3168
3169     return hr;
3170 }
3171
3172 static HRESULT WINAPI d3drm_animation2_QueryInterface(IDirect3DRMAnimation2 *iface, REFIID riid, void **out)
3173 {
3174     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3175
3176     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
3177
3178     if (IsEqualGUID(riid, &IID_IDirect3DRMAnimation)
3179             || IsEqualGUID(riid, &IID_IDirect3DRMObject)
3180             || IsEqualGUID(riid, &IID_IUnknown))
3181     {
3182         *out = &animation->IDirect3DRMAnimation_iface;
3183     }
3184     else if (IsEqualGUID(riid, &IID_IDirect3DRMAnimation2))
3185     {
3186         *out = &animation->IDirect3DRMAnimation2_iface;
3187     }
3188     else
3189     {
3190         *out = NULL;
3191         WARN("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(riid));
3192         return CLASS_E_CLASSNOTAVAILABLE;
3193     }
3194
3195     IUnknown_AddRef((IUnknown *)*out);
3196     return S_OK;
3197 }
3198
3199 static HRESULT WINAPI d3drm_animation1_QueryInterface(IDirect3DRMAnimation *iface, REFIID riid, void **out)
3200 {
3201     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3202
3203     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
3204
3205     return IDirect3DRMAnimation2_QueryInterface(&animation->IDirect3DRMAnimation2_iface, riid, out);
3206 }
3207
3208 static ULONG WINAPI d3drm_animation2_AddRef(IDirect3DRMAnimation2 *iface)
3209 {
3210     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3211     ULONG refcount = InterlockedIncrement(&animation->ref);
3212
3213     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
3214
3215     return refcount;
3216 }
3217
3218 static ULONG WINAPI d3drm_animation1_AddRef(IDirect3DRMAnimation *iface)
3219 {
3220     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3221     return IDirect3DRMAnimation2_AddRef(&animation->IDirect3DRMAnimation2_iface);
3222 }
3223
3224 static ULONG WINAPI d3drm_animation2_Release(IDirect3DRMAnimation2 *iface)
3225 {
3226     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3227     ULONG refcount = InterlockedDecrement(&animation->ref);
3228
3229     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
3230
3231     if (!refcount)
3232     {
3233         d3drm_object_cleanup((IDirect3DRMObject *)&animation->IDirect3DRMAnimation_iface, &animation->obj);
3234         IDirect3DRM_Release(animation->d3drm);
3235         free(animation->rotate.keys);
3236         free(animation->scale.keys);
3237         free(animation->position.keys);
3238         free(animation);
3239     }
3240
3241     return refcount;
3242 }
3243
3244 static ULONG WINAPI d3drm_animation1_Release(IDirect3DRMAnimation *iface)
3245 {
3246     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3247
3248     return IDirect3DRMAnimation2_Release(&animation->IDirect3DRMAnimation2_iface);
3249 }
3250
3251 static HRESULT WINAPI d3drm_animation2_Clone(IDirect3DRMAnimation2 *iface, IUnknown *outer, REFIID iid, void **out)
3252 {
3253     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
3254
3255     return E_NOTIMPL;
3256 }
3257
3258 static HRESULT WINAPI d3drm_animation1_Clone(IDirect3DRMAnimation *iface, IUnknown *outer, REFIID iid, void **out)
3259 {
3260     FIXME("iface %p, outer %p, iid %s, out %p stub!\n", iface, outer, debugstr_guid(iid), out);
3261
3262     return E_NOTIMPL;
3263 }
3264
3265 static HRESULT WINAPI d3drm_animation2_AddDestroyCallback(IDirect3DRMAnimation2 *iface,
3266         D3DRMOBJECTCALLBACK cb, void *ctx)
3267 {
3268     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3269
3270     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
3271
3272     return d3drm_object_add_destroy_callback(&animation->obj, cb, ctx);
3273 }
3274
3275 static HRESULT WINAPI d3drm_animation1_AddDestroyCallback(IDirect3DRMAnimation *iface,
3276         D3DRMOBJECTCALLBACK cb, void *ctx)
3277 {
3278     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3279
3280     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
3281
3282     return IDirect3DRMAnimation2_AddDestroyCallback(&animation->IDirect3DRMAnimation2_iface, cb, ctx);
3283 }
3284
3285 static HRESULT WINAPI d3drm_animation2_DeleteDestroyCallback(IDirect3DRMAnimation2 *iface,
3286         D3DRMOBJECTCALLBACK cb, void *ctx)
3287 {
3288     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3289
3290     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
3291
3292     return d3drm_object_delete_destroy_callback(&animation->obj, cb, ctx);
3293 }
3294
3295 static HRESULT WINAPI d3drm_animation1_DeleteDestroyCallback(IDirect3DRMAnimation *iface,
3296         D3DRMOBJECTCALLBACK cb, void *ctx)
3297 {
3298     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3299
3300     TRACE("iface %p, cb %p, ctx %p.\n", iface, cb, ctx);
3301
3302     return IDirect3DRMAnimation2_DeleteDestroyCallback(&animation->IDirect3DRMAnimation2_iface, cb, ctx);
3303 }
3304
3305 static HRESULT WINAPI d3drm_animation2_SetAppData(IDirect3DRMAnimation2 *iface, DWORD data)
3306 {
3307     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3308
3309     TRACE("iface %p, data %#lx.\n", iface, data);
3310
3311     animation->obj.appdata = data;
3312
3313     return D3DRM_OK;
3314 }
3315
3316 static HRESULT WINAPI d3drm_animation1_SetAppData(IDirect3DRMAnimation *iface, DWORD data)
3317 {
3318     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3319
3320     TRACE("iface %p, data %#lx.\n", iface, data);
3321
3322     return d3drm_animation2_SetAppData(&animation->IDirect3DRMAnimation2_iface, data);
3323 }
3324
3325 static DWORD WINAPI d3drm_animation2_GetAppData(IDirect3DRMAnimation2 *iface)
3326 {
3327     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3328
3329     TRACE("iface %p.\n", iface);
3330
3331     return animation->obj.appdata;
3332 }
3333
3334 static DWORD WINAPI d3drm_animation1_GetAppData(IDirect3DRMAnimation *iface)
3335 {
3336     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3337
3338     TRACE("iface %p.\n", iface);
3339
3340     return d3drm_animation2_GetAppData(&animation->IDirect3DRMAnimation2_iface);
3341 }
3342
3343 static HRESULT WINAPI d3drm_animation2_SetName(IDirect3DRMAnimation2 *iface, const char *name)
3344 {
3345     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3346
3347     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
3348
3349     return d3drm_object_set_name(&animation->obj, name);
3350 }
3351
3352 static HRESULT WINAPI d3drm_animation1_SetName(IDirect3DRMAnimation *iface, const char *name)
3353 {
3354     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3355
3356     TRACE("iface %p, name %s.\n", iface, debugstr_a(name));
3357
3358     return d3drm_animation2_SetName(&animation->IDirect3DRMAnimation2_iface, name);
3359 }
3360
3361 static HRESULT WINAPI d3drm_animation2_GetName(IDirect3DRMAnimation2 *iface, DWORD *size, char *name)
3362 {
3363     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3364
3365     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
3366
3367     return d3drm_object_get_name(&animation->obj, size, name);
3368 }
3369
3370 static HRESULT WINAPI d3drm_animation1_GetName(IDirect3DRMAnimation *iface, DWORD *size, char *name)
3371 {
3372     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3373
3374     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
3375
3376     return d3drm_animation2_GetName(&animation->IDirect3DRMAnimation2_iface, size, name);
3377 }
3378
3379 static HRESULT WINAPI d3drm_animation2_GetClassName(IDirect3DRMAnimation2 *iface, DWORD *size, char *name)
3380 {
3381     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3382
3383     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
3384
3385     return d3drm_object_get_class_name(&animation->obj, size, name);
3386 }
3387
3388 static HRESULT WINAPI d3drm_animation1_GetClassName(IDirect3DRMAnimation *iface, DWORD *size, char *name)
3389 {
3390     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3391
3392     TRACE("iface %p, size %p, name %p.\n", iface, size, name);
3393
3394     return d3drm_animation2_GetClassName(&animation->IDirect3DRMAnimation2_iface, size, name);
3395 }
3396
3397 static HRESULT WINAPI d3drm_animation2_SetOptions(IDirect3DRMAnimation2 *iface, D3DRMANIMATIONOPTIONS options)
3398 {
3399     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3400     static const DWORD supported_options = D3DRMANIMATION_OPEN | D3DRMANIMATION_CLOSED | D3DRMANIMATION_LINEARPOSITION
3401         | D3DRMANIMATION_SPLINEPOSITION | D3DRMANIMATION_SCALEANDROTATION | D3DRMANIMATION_POSITION;
3402
3403     TRACE("iface %p, options %#lx.\n", iface, options);
3404
3405     if (!(options & supported_options))
3406         return D3DRMERR_BADVALUE;
3407
3408     if ((options & (D3DRMANIMATION_OPEN | D3DRMANIMATION_CLOSED)) == (D3DRMANIMATION_OPEN | D3DRMANIMATION_CLOSED) ||
3409             (options & (D3DRMANIMATION_LINEARPOSITION | D3DRMANIMATION_SPLINEPOSITION)) ==
3410             (D3DRMANIMATION_LINEARPOSITION | D3DRMANIMATION_SPLINEPOSITION) ||
3411             (options & (D3DRMANIMATION_SCALEANDROTATION | D3DRMANIMATION_POSITION)) ==
3412             (D3DRMANIMATION_SCALEANDROTATION | D3DRMANIMATION_POSITION))
3413     {
3414         return D3DRMERR_BADVALUE;
3415     }
3416
3417     animation->options = options;
3418
3419     return D3DRM_OK;
3420 }
3421
3422 static HRESULT WINAPI d3drm_animation1_SetOptions(IDirect3DRMAnimation *iface, D3DRMANIMATIONOPTIONS options)
3423 {
3424     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3425
3426     TRACE("iface %p, %#lx.\n", iface, options);
3427
3428     return d3drm_animation2_SetOptions(&animation->IDirect3DRMAnimation2_iface, options);
3429 }
3430
3431 static SIZE_T d3drm_animation_lookup_key(const struct d3drm_animation_key *keys,
3432         SIZE_T count, D3DVALUE time)
3433 {
3434     SIZE_T start = 0, cur = 0, end = count;
3435
3436     while (start < end)
3437     {
3438         cur = start + (end - start) / 2;
3439
3440         if (time == keys[cur].time)
3441             return cur;
3442
3443         if (time < keys[cur].time)
3444             end = cur;
3445         else
3446             start = cur + 1;
3447     }
3448
3449     return cur;
3450 }
3451
3452 static SIZE_T d3drm_animation_get_index_min(const struct d3drm_animation_key *keys, SIZE_T count, D3DVALUE time)
3453 {
3454     SIZE_T i;
3455
3456     i = d3drm_animation_lookup_key(keys, count, time);
3457     while (i > 0 && keys[i - 1].time == time)
3458         --i;
3459
3460     return i;
3461 }
3462
3463 static SIZE_T d3drm_animation_get_index_max(const struct d3drm_animation_key *keys, SIZE_T count, D3DVALUE time)
3464 {
3465     SIZE_T i;
3466
3467     i = d3drm_animation_lookup_key(keys, count, time);
3468     while (i < count - 1 && keys[i + 1].time == time)
3469         ++i;
3470
3471     return i;
3472 }
3473
3474 static SIZE_T d3drm_animation_get_insert_position(const struct d3drm_animation_keys *keys, D3DVALUE time)
3475 {
3476     if (!keys->count || time < keys->keys[0].time)
3477         return 0;
3478
3479     if (time >= keys->keys[keys->count - 1].time)
3480         return keys->count;
3481
3482     return d3drm_animation_get_index_max(keys->keys, keys->count, time);
3483 }
3484
3485 static const struct d3drm_animation_key *d3drm_animation_get_range(const struct d3drm_animation_keys *keys,
3486         D3DVALUE time_min, D3DVALUE time_max, SIZE_T *count)
3487 {
3488     SIZE_T min;
3489
3490     if (!keys->count || time_max < keys->keys[0].time
3491             || time_min > keys->keys[keys->count - 1].time)
3492         return NULL;
3493
3494     min = d3drm_animation_get_index_min(keys->keys, keys->count, time_min);
3495     if (count)
3496         *count = d3drm_animation_get_index_max(&keys->keys[min], keys->count - min, time_max) - min + 1;
3497
3498     return &keys->keys[min];
3499 }
3500
3501 static HRESULT WINAPI d3drm_animation2_AddKey(IDirect3DRMAnimation2 *iface, D3DRMANIMATIONKEY *key)
3502 {
3503     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3504     struct d3drm_animation_keys *keys;
3505     SIZE_T index;
3506
3507     TRACE("iface %p, key %p.\n", iface, key);
3508
3509     if (!key || key->dwSize != sizeof(*key))
3510         return E_INVALIDARG;
3511
3512     switch (key->dwKeyType)
3513     {
3514         case D3DRMANIMATION_POSITIONKEY:
3515             keys = &animation->position;
3516             break;
3517         case D3DRMANIMATION_SCALEKEY:
3518             keys = &animation->scale;
3519             break;
3520         case D3DRMANIMATION_ROTATEKEY:
3521             keys = &animation->rotate;
3522             break;
3523         default:
3524             return E_INVALIDARG;
3525     }
3526
3527     index = d3drm_animation_get_insert_position(keys, key->dvTime);
3528
3529     if (!d3drm_array_reserve((void **)&keys->keys, &keys->size, keys->count + 1, sizeof(*keys->keys)))
3530         return E_OUTOFMEMORY;
3531
3532     if (index < keys->count)
3533         memmove(&keys->keys[index + 1], &keys->keys[index], sizeof(*keys->keys) * (keys->count - index));
3534     keys->keys[index].time = key->dvTime;
3535     switch (key->dwKeyType)
3536     {
3537         case D3DRMANIMATION_POSITIONKEY:
3538             keys->keys[index].u.position = key->u.dvPositionKey;
3539             break;
3540         case D3DRMANIMATION_SCALEKEY:
3541             keys->keys[index].u.scale = key->u.dvScaleKey;
3542             break;
3543         case D3DRMANIMATION_ROTATEKEY:
3544             keys->keys[index].u.rotate = key->u.dqRotateKey;
3545             break;
3546     }
3547     ++keys->count;
3548
3549     return D3DRM_OK;
3550 }
3551
3552 static HRESULT WINAPI d3drm_animation2_AddRotateKey(IDirect3DRMAnimation2 *iface, D3DVALUE time, D3DRMQUATERNION *q)
3553 {
3554     D3DRMANIMATIONKEY key;
3555
3556     TRACE("iface %p, time %.8e, q %p.\n", iface, time, q);
3557
3558     key.dwSize = sizeof(key);
3559     key.dwKeyType = D3DRMANIMATION_ROTATEKEY;
3560     key.dvTime = time;
3561     key.dwID = 0;
3562     key.u.dqRotateKey = *q;
3563
3564     return d3drm_animation2_AddKey(iface, &key);
3565 }
3566
3567 static HRESULT WINAPI d3drm_animation1_AddRotateKey(IDirect3DRMAnimation *iface, D3DVALUE time, D3DRMQUATERNION *q)
3568 {
3569     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3570
3571     TRACE("iface %p, time %.8e, q %p.\n", iface, time, q);
3572
3573     return d3drm_animation2_AddRotateKey(&animation->IDirect3DRMAnimation2_iface, time, q);
3574 }
3575
3576 static HRESULT WINAPI d3drm_animation2_AddPositionKey(IDirect3DRMAnimation2 *iface, D3DVALUE time,
3577         D3DVALUE x, D3DVALUE y, D3DVALUE z)
3578 {
3579     D3DRMANIMATIONKEY key;
3580
3581     TRACE("iface %p, time %.8e, x %.8e, y %.8e, z %.8e.\n", iface, time, x, y, z);
3582
3583     key.dwSize = sizeof(key);
3584     key.dwKeyType = D3DRMANIMATION_POSITIONKEY;
3585     key.dvTime = time;
3586     key.dwID = 0;
3587     key.u.dvPositionKey.u1.x = x;
3588     key.u.dvPositionKey.u2.y = y;
3589     key.u.dvPositionKey.u3.z = z;
3590
3591     return d3drm_animation2_AddKey(iface, &key);
3592 }
3593
3594 static HRESULT WINAPI d3drm_animation1_AddPositionKey(IDirect3DRMAnimation *iface, D3DVALUE time,
3595         D3DVALUE x, D3DVALUE y, D3DVALUE z)
3596 {
3597     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3598
3599     TRACE("iface %p, time %.8e, x %.8e, y %.8e, z %.8e.\n", iface, time, x, y, z);
3600
3601     return d3drm_animation2_AddPositionKey(&animation->IDirect3DRMAnimation2_iface, time, x, y, z);
3602 }
3603
3604 static HRESULT WINAPI d3drm_animation2_AddScaleKey(IDirect3DRMAnimation2 *iface, D3DVALUE time,
3605         D3DVALUE x, D3DVALUE y, D3DVALUE z)
3606 {
3607     D3DRMANIMATIONKEY key;
3608
3609     TRACE("iface %p, time %.8e, x %.8e, y %.8e, z %.8e.\n", iface, time, x, y, z);
3610
3611     key.dwSize = sizeof(key);
3612     key.dwKeyType = D3DRMANIMATION_SCALEKEY;
3613     key.dvTime = time;
3614     key.dwID = 0;
3615     key.u.dvScaleKey.u1.x = x;
3616     key.u.dvScaleKey.u2.y = y;
3617     key.u.dvScaleKey.u3.z = z;
3618
3619     return d3drm_animation2_AddKey(iface, &key);
3620 }
3621
3622 static HRESULT WINAPI d3drm_animation1_AddScaleKey(IDirect3DRMAnimation *iface, D3DVALUE time,
3623         D3DVALUE x, D3DVALUE y, D3DVALUE z)
3624 {
3625     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3626
3627     TRACE("iface %p, time %.8e, x %.8e, y %.8e, z %.8e.\n", iface, time, x, y, z);
3628
3629     return d3drm_animation2_AddScaleKey(&animation->IDirect3DRMAnimation2_iface, time, x, y, z);
3630 }
3631
3632 static void d3drm_animation_delete_key(struct d3drm_animation_keys *keys, const struct d3drm_animation_key *key)
3633 {
3634     SIZE_T index = key - keys->keys;
3635
3636     if (index < keys->count - 1)
3637         memmove(&keys->keys[index], &keys->keys[index + 1], sizeof(*keys->keys) * (keys->count - index - 1));
3638     --keys->count;
3639 }
3640
3641 static HRESULT WINAPI d3drm_animation2_DeleteKey(IDirect3DRMAnimation2 *iface, D3DVALUE time)
3642 {
3643     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3644     const struct d3drm_animation_key *key;
3645
3646     TRACE("iface %p, time %.8e.\n", iface, time);
3647
3648     if ((key = d3drm_animation_get_range(&animation->rotate, time, time, NULL)))
3649         d3drm_animation_delete_key(&animation->rotate, key);
3650
3651     if ((key = d3drm_animation_get_range(&animation->position, time, time, NULL)))
3652         d3drm_animation_delete_key(&animation->position, key);
3653
3654     if ((key = d3drm_animation_get_range(&animation->scale, time, time, NULL)))
3655         d3drm_animation_delete_key(&animation->scale, key);
3656
3657     return D3DRM_OK;
3658 }
3659
3660 static HRESULT WINAPI d3drm_animation1_DeleteKey(IDirect3DRMAnimation *iface, D3DVALUE time)
3661 {
3662     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3663
3664     TRACE("iface %p, time %.8e.\n", iface, time);
3665
3666     return d3drm_animation2_DeleteKey(&animation->IDirect3DRMAnimation2_iface, time);
3667 }
3668
3669 static HRESULT WINAPI d3drm_animation1_SetFrame(IDirect3DRMAnimation *iface, IDirect3DRMFrame *frame)
3670 {
3671     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3672     HRESULT hr = D3DRM_OK;
3673
3674     TRACE("iface %p, frame %p.\n", iface, frame);
3675
3676     if (frame)
3677     {
3678         hr = IDirect3DRMFrame_QueryInterface(frame, &IID_IDirect3DRMFrame3, (void **)&animation->frame);
3679         if (SUCCEEDED(hr))
3680             IDirect3DRMFrame3_Release(animation->frame);
3681     }
3682     else
3683         animation->frame = NULL;
3684
3685     return hr;
3686 }
3687
3688 static HRESULT WINAPI d3drm_animation1_SetTime(IDirect3DRMAnimation *iface, D3DVALUE time)
3689 {
3690     FIXME("iface %p, time %.8e.\n", iface, time);
3691
3692     return E_NOTIMPL;
3693 }
3694
3695 static D3DRMANIMATIONOPTIONS WINAPI d3drm_animation2_GetOptions(IDirect3DRMAnimation2 *iface)
3696 {
3697     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3698
3699     TRACE("iface %p.\n", iface);
3700
3701     return animation->options;
3702 }
3703
3704 static D3DRMANIMATIONOPTIONS WINAPI d3drm_animation1_GetOptions(IDirect3DRMAnimation *iface)
3705 {
3706     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation(iface);
3707
3708     TRACE("iface %p.\n", iface);
3709
3710     return d3drm_animation2_GetOptions(&animation->IDirect3DRMAnimation2_iface);
3711 }
3712
3713 static HRESULT WINAPI d3drm_animation2_SetFrame(IDirect3DRMAnimation2 *iface, IDirect3DRMFrame3 *frame)
3714 {
3715     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3716
3717     TRACE("iface %p, frame %p.\n", iface, frame);
3718
3719     animation->frame = frame;
3720
3721     return D3DRM_OK;
3722 }
3723
3724 static HRESULT WINAPI d3drm_animation2_SetTime(IDirect3DRMAnimation2 *iface, D3DVALUE time)
3725 {
3726     FIXME("iface %p, time %.8e.\n", iface, time);
3727
3728     return E_NOTIMPL;
3729 }
3730
3731 static HRESULT WINAPI d3drm_animation2_GetFrame(IDirect3DRMAnimation2 *iface, IDirect3DRMFrame3 **frame)
3732 {
3733     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3734
3735     TRACE("iface %p, frame %p.\n", iface, frame);
3736
3737     if (!frame)
3738         return D3DRMERR_BADVALUE;
3739
3740     *frame = animation->frame;
3741     if (*frame)
3742         IDirect3DRMFrame3_AddRef(*frame);
3743
3744     return D3DRM_OK;
3745 }
3746
3747 static HRESULT WINAPI d3drm_animation2_DeleteKeyByID(IDirect3DRMAnimation2 *iface, DWORD id)
3748 {
3749     FIXME("iface %p, id %#lx.\n", iface, id);
3750
3751     return E_NOTIMPL;
3752 }
3753
3754 static HRESULT WINAPI d3drm_animation2_ModifyKey(IDirect3DRMAnimation2 *iface, D3DRMANIMATIONKEY *key)
3755 {
3756     FIXME("iface %p, key %p.\n", iface, key);
3757
3758     return E_NOTIMPL;
3759 }
3760
3761 static HRESULT WINAPI d3drm_animation2_GetKeys(IDirect3DRMAnimation2 *iface, D3DVALUE time_min, D3DVALUE time_max,
3762         DWORD *key_count, D3DRMANIMATIONKEY *keys)
3763 {
3764     struct d3drm_animation *animation = impl_from_IDirect3DRMAnimation2(iface);
3765     const struct d3drm_animation_key *key;
3766     SIZE_T count, i;
3767
3768     TRACE("iface %p, time min %.8e, time max %.8e, key_count %p, keys %p.\n",
3769             iface, time_min, time_max, key_count, keys);
3770
3771     if (!key_count)
3772         return D3DRMERR_BADVALUE;
3773
3774     *key_count = 0;
3775
3776     if ((key = d3drm_animation_get_range(&animation->rotate, time_min, time_max, &count)))
3777     {
3778         if (keys)
3779         {
3780             for (i = 0; i < count; ++i)
3781             {
3782                 keys[i].dwSize = sizeof(*keys);
3783                 keys[i].dwKeyType = D3DRMANIMATION_ROTATEKEY;
3784                 keys[i].dvTime = key[i].time;
3785                 keys[i].dwID = 0; /* FIXME */
3786                 keys[i].u.dqRotateKey = key[i].u.rotate;
3787             }
3788             keys += count;
3789         }
3790         *key_count += count;
3791     }
3792
3793     if ((key = d3drm_animation_get_range(&animation->position, time_min, time_max, &count)))
3794     {
3795         if (keys)
3796         {
3797             for (i = 0; i < count; ++i)
3798             {
3799                 keys[i].dwSize = sizeof(*keys);
3800                 keys[i].dwKeyType = D3DRMANIMATION_POSITIONKEY;
3801                 keys[i].dvTime = key[i].time;
3802                 keys[i].dwID = 0; /* FIXME */
3803                 keys[i].u.dvPositionKey = key[i].u.position;
3804             }
3805             keys += count;
3806         }
3807         *key_count += count;
3808     }
3809
3810     if ((key = d3drm_animation_get_range(&animation->scale, time_min, time_max, &count)))
3811     {
3812         if (keys)
3813         {
3814             for (i = 0; keys && i < count; ++i)
3815             {
3816                 keys[i].dwSize = sizeof(*keys);
3817                 keys[i].dwKeyType = D3DRMANIMATION_SCALEKEY;
3818                 keys[i].dvTime = key[i].time;
3819                 keys[i].dwID = 0; /* FIXME */
3820                 keys[i].u.dvScaleKey = key[i].u.scale;
3821             }
3822             keys += count;
3823         }
3824         *key_count += count;
3825     }
3826
3827     return *key_count ? D3DRM_OK : D3DRMERR_NOSUCHKEY;
3828 }
3829
3830 static const struct IDirect3DRMAnimationVtbl d3drm_animation1_vtbl =
3831 {
3832     d3drm_animation1_QueryInterface,
3833     d3drm_animation1_AddRef,
3834     d3drm_animation1_Release,
3835     d3drm_animation1_Clone,
3836     d3drm_animation1_AddDestroyCallback,
3837     d3drm_animation1_DeleteDestroyCallback,
3838     d3drm_animation1_SetAppData,
3839     d3drm_animation1_GetAppData,
3840     d3drm_animation1_SetName,
3841     d3drm_animation1_GetName,
3842     d3drm_animation1_GetClassName,
3843     d3drm_animation1_SetOptions,
3844     d3drm_animation1_AddRotateKey,
3845     d3drm_animation1_AddPositionKey,
3846     d3drm_animation1_AddScaleKey,
3847     d3drm_animation1_DeleteKey,
3848     d3drm_animation1_SetFrame,
3849     d3drm_animation1_SetTime,
3850     d3drm_animation1_GetOptions,
3851 };
3852
3853 static const struct IDirect3DRMAnimation2Vtbl d3drm_animation2_vtbl =
3854 {
3855     d3drm_animation2_QueryInterface,
3856     d3drm_animation2_AddRef,
3857     d3drm_animation2_Release,
3858     d3drm_animation2_Clone,
3859     d3drm_animation2_AddDestroyCallback,
3860     d3drm_animation2_DeleteDestroyCallback,
3861     d3drm_animation2_SetAppData,
3862     d3drm_animation2_GetAppData,
3863     d3drm_animation2_SetName,
3864     d3drm_animation2_GetName,
3865     d3drm_animation2_GetClassName,
3866     d3drm_animation2_SetOptions,
3867     d3drm_animation2_AddRotateKey,
3868     d3drm_animation2_AddPositionKey,
3869     d3drm_animation2_AddScaleKey,
3870     d3drm_animation2_DeleteKey,
3871     d3drm_animation2_SetFrame,
3872     d3drm_animation2_SetTime,
3873     d3drm_animation2_GetOptions,
3874     d3drm_animation2_GetFrame,
3875     d3drm_animation2_DeleteKeyByID,
3876     d3drm_animation2_AddKey,
3877     d3drm_animation2_ModifyKey,
3878     d3drm_animation2_GetKeys,
3879 };
3880
3881 HRESULT d3drm_animation_create(struct d3drm_animation **animation, IDirect3DRM *d3drm)
3882 {
3883     static const char classname[] = "Animation";
3884     struct d3drm_animation *object;
3885     HRESULT hr = D3DRM_OK;
3886
3887     TRACE("animation %p, d3drm %p.\n", animation, d3drm);
3888
3889     if (!(object = calloc(1, sizeof(*object))))
3890         return E_OUTOFMEMORY;
3891
3892     object->IDirect3DRMAnimation_iface.lpVtbl = &d3drm_animation1_vtbl;
3893     object->IDirect3DRMAnimation2_iface.lpVtbl = &d3drm_animation2_vtbl;
3894     object->d3drm = d3drm;
3895     object->ref = 1;
3896     object->options = D3DRMANIMATION_CLOSED | D3DRMANIMATION_LINEARPOSITION;
3897
3898     d3drm_object_init(&object->obj, classname);
3899
3900     IDirect3DRM_AddRef(object->d3drm);
3901
3902     *animation = object;
3903
3904     return hr;
3905 }