dlls/d3dx9_36/animation.c

   1 /*
   2  * Animation Controller operations specific to D3DX9.
   3  *
   4  * Copyright (C) 2015 Christian Costa
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21
  22 #include "d3dx9_private.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
  25
  26 struct d3dx9_animation_controller
  27 {
  28     ID3DXAnimationController ID3DXAnimationController_iface;
  29     LONG ref;
  30
  31     UINT max_outputs;
  32     UINT max_sets;
  33     UINT max_tracks;
  34     UINT max_events;
  35 };
  36
  37 static inline struct d3dx9_animation_controller *impl_from_ID3DXAnimationController(ID3DXAnimationController *iface)
  38 {
  39     return CONTAINING_RECORD(iface, struct d3dx9_animation_controller, ID3DXAnimationController_iface);
  40 }
  41
  42 static HRESULT WINAPI d3dx9_animation_controller_QueryInterface(ID3DXAnimationController *iface, REFIID riid, void **out)
  43 {
  44     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  45
  46     if (IsEqualGUID(riid, &IID_IUnknown) ||
  47         IsEqualGUID(riid, &IID_ID3DXAnimationController))
  48     {
  49         iface->lpVtbl->AddRef(iface);
  50         *out = iface;
  51         return D3D_OK;
  52     }
  53
  54     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  55     *out = NULL;
  56     return E_NOINTERFACE;
  57 }
  58
  59 static ULONG WINAPI d3dx9_animation_controller_AddRef(ID3DXAnimationController *iface)
  60 {
  61     struct d3dx9_animation_controller *animation = impl_from_ID3DXAnimationController(iface);
  62     ULONG refcount = InterlockedIncrement(&animation->ref);
  63
  64     TRACE("%p increasing refcount to %lu.\n", animation, refcount);
  65
  66     return refcount;
  67 }
  68
  69 static ULONG WINAPI d3dx9_animation_controller_Release(ID3DXAnimationController *iface)
  70 {
  71     struct d3dx9_animation_controller *animation = impl_from_ID3DXAnimationController(iface);
  72     ULONG refcount = InterlockedDecrement(&animation->ref);
  73
  74     TRACE("%p decreasing refcount to %lu.\n", animation, refcount);
  75
  76     if (!refcount)
  77     {
  78         HeapFree(GetProcessHeap(), 0, animation);
  79     }
  80
  81     return refcount;
  82 }
  83
  84 static UINT WINAPI d3dx9_animation_controller_GetMaxNumAnimationOutputs(ID3DXAnimationController *iface)
  85 {
  86     struct d3dx9_animation_controller *animation = impl_from_ID3DXAnimationController(iface);
  87
  88     TRACE("iface %p.\n", iface);
  89
  90     return animation->max_outputs;
  91 }
  92
  93 static UINT WINAPI d3dx9_animation_controller_GetMaxNumAnimationSets(ID3DXAnimationController *iface)
  94 {
  95     struct d3dx9_animation_controller *animation = impl_from_ID3DXAnimationController(iface);
  96
  97     TRACE("iface %p.\n", iface);
  98
  99     return animation->max_sets;
 100 }
 101
 102 static UINT WINAPI d3dx9_animation_controller_GetMaxNumTracks(ID3DXAnimationController *iface)
 103 {
 104     struct d3dx9_animation_controller *animation = impl_from_ID3DXAnimationController(iface);
 105
 106     TRACE("iface %p.\n", iface);
 107
 108     return animation->max_tracks;
 109 }
 110
 111 static UINT WINAPI d3dx9_animation_controller_GetMaxNumEvents(ID3DXAnimationController *iface)
 112 {
 113     struct d3dx9_animation_controller *animation = impl_from_ID3DXAnimationController(iface);
 114
 115     TRACE("iface %p.\n", iface);
 116
 117     return animation->max_events;
 118 }
 119
 120 static HRESULT WINAPI d3dx9_animation_controller_RegisterAnimationOutput(ID3DXAnimationController *iface,
 121         const char *name, D3DXMATRIX *matrix, D3DXVECTOR3 *scale, D3DXQUATERNION *rotation, D3DXVECTOR3 *translation)
 122 {
 123     FIXME("iface %p, name %s, matrix %p, scale %p, rotation %p, translation %p stub.\n", iface, debugstr_a(name),
 124             matrix, scale, rotation, translation);
 125
 126     return E_NOTIMPL;
 127 }
 128
 129 static HRESULT WINAPI d3dx9_animation_controller_RegisterAnimationSet(ID3DXAnimationController *iface,
 130         ID3DXAnimationSet *anim_set)
 131 {
 132     FIXME("iface %p, anim_set %p stub.\n", iface, anim_set);
 133
 134     return E_NOTIMPL;
 135 }
 136
 137 static HRESULT WINAPI d3dx9_animation_controller_UnregisterAnimationSet(ID3DXAnimationController *iface,
 138         ID3DXAnimationSet *anim_set)
 139 {
 140     FIXME("iface %p, anim_set %p stub.\n", iface, anim_set);
 141
 142     return E_NOTIMPL;
 143 }
 144
 145 static UINT WINAPI d3dx9_animation_controller_GetNumAnimationSets(ID3DXAnimationController *iface)
 146 {
 147     FIXME("iface %p stub.\n", iface);
 148
 149     return 0;
 150 }
 151
 152 static HRESULT WINAPI d3dx9_animation_controller_GetAnimationSet(ID3DXAnimationController *iface,
 153         UINT index, ID3DXAnimationSet **anim_set)
 154 {
 155     FIXME("iface %p, index %u, anim_set %p stub.\n", iface, index, anim_set);
 156
 157     return E_NOTIMPL;
 158 }
 159
 160 static HRESULT WINAPI d3dx9_animation_controller_GetAnimationSetByName(ID3DXAnimationController *iface,
 161         const char *name, ID3DXAnimationSet **anim_set)
 162 {
 163     FIXME("iface %p, name %s, anim_set %p stub.\n", iface, debugstr_a(name), anim_set);
 164
 165     return E_NOTIMPL;
 166 }
 167
 168 static HRESULT WINAPI d3dx9_animation_controller_AdvanceTime(ID3DXAnimationController *iface, double time_delta,
 169         ID3DXAnimationCallbackHandler *callback_handler)
 170 {
 171     FIXME("iface %p, time_delta %.16e, callback_handler %p stub.\n", iface, time_delta, callback_handler);
 172
 173     return E_NOTIMPL;
 174 }
 175
 176 static HRESULT WINAPI d3dx9_animation_controller_Reset(ID3DXAnimationController *iface)
 177 {
 178     FIXME("iface %p stub.\n", iface);
 179
 180     return E_NOTIMPL;
 181 }
 182
 183 static double WINAPI d3dx9_animation_controller_GetTime(ID3DXAnimationController *iface)
 184 {
 185     FIXME("iface %p stub.\n", iface);
 186
 187     return 0.0;
 188 }
 189
 190 static HRESULT WINAPI d3dx9_animation_controller_SetTrackAnimationSet(ID3DXAnimationController *iface,
 191         UINT track, ID3DXAnimationSet *anim_set)
 192 {
 193     FIXME("iface %p, track %u, anim_set %p stub.\n", iface, track, anim_set);
 194
 195     return E_NOTIMPL;
 196 }
 197
 198 static HRESULT WINAPI d3dx9_animation_controller_GetTrackAnimationSet(ID3DXAnimationController *iface,
 199         UINT track, ID3DXAnimationSet **anim_set)
 200 {
 201     FIXME("iface %p, track %u, anim_set %p stub.\n", iface, track, anim_set);
 202
 203     return E_NOTIMPL;
 204 }
 205
 206 static HRESULT WINAPI d3dx9_animation_controller_SetTrackPriority(ID3DXAnimationController *iface,
 207         UINT track, D3DXPRIORITY_TYPE priority)
 208 {
 209     FIXME("iface %p, track %u, priority %u stub.\n", iface, track, priority);
 210
 211     return E_NOTIMPL;
 212 }
 213
 214 static HRESULT WINAPI d3dx9_animation_controller_SetTrackSpeed(ID3DXAnimationController *iface,
 215         UINT track, float speed)
 216 {
 217     FIXME("iface %p, track %u, speed %.8e stub.\n", iface, track, speed);
 218
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI d3dx9_animation_controller_SetTrackWeight(ID3DXAnimationController *iface,
 223         UINT track, float weight)
 224 {
 225     FIXME("iface %p, track %u, weight %.8e stub.\n", iface, track, weight);
 226
 227     return E_NOTIMPL;
 228 }
 229
 230 static HRESULT WINAPI d3dx9_animation_controller_SetTrackPosition(ID3DXAnimationController *iface,
 231         UINT track, double position)
 232 {
 233     FIXME("iface %p, track %u, position %.16e stub.\n", iface, track, position);
 234
 235     return E_NOTIMPL;
 236 }
 237
 238 static HRESULT WINAPI d3dx9_animation_controller_SetTrackEnable(ID3DXAnimationController *iface,
 239         UINT track, BOOL enable)
 240 {
 241     FIXME("iface %p, track %u, enable %#x stub.\n", iface, track, enable);
 242
 243     return E_NOTIMPL;
 244 }
 245
 246 static HRESULT WINAPI d3dx9_animation_controller_SetTrackDesc(ID3DXAnimationController *iface,
 247         UINT track, D3DXTRACK_DESC *desc)
 248 {
 249     FIXME("iface %p, track %u, desc %p stub.\n", iface, track, desc);
 250
 251     return E_NOTIMPL;
 252 }
 253
 254 static HRESULT WINAPI d3dx9_animation_controller_GetTrackDesc(ID3DXAnimationController *iface,
 255         UINT track, D3DXTRACK_DESC *desc)
 256 {
 257     FIXME("iface %p, track %u, desc %p stub.\n", iface, track, desc);
 258
 259     return E_NOTIMPL;
 260 }
 261
 262 static HRESULT WINAPI d3dx9_animation_controller_SetPriorityBlend(ID3DXAnimationController *iface,
 263         float blend_weight)
 264 {
 265     FIXME("iface %p, blend_weight %.8e stub.\n", iface, blend_weight);
 266
 267     return E_NOTIMPL;
 268 }
 269
 270 static float WINAPI d3dx9_animation_controller_GetPriorityBlend(ID3DXAnimationController *iface)
 271 {
 272     FIXME("iface %p stub.\n", iface);
 273
 274     return 0.0f;
 275 }
 276
 277 static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_KeyTrackSpeed(ID3DXAnimationController *iface,
 278         UINT track, float new_speed, double start_time, double duration, D3DXTRANSITION_TYPE transition)
 279 {
 280     FIXME("iface %p, track %u, new_speed %.8e, start_time %.16e, duration %.16e, transition %u stub.\n", iface,
 281             track, new_speed, start_time, duration, transition);
 282
 283     return 0;
 284 }
 285
 286 static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_KeyTrackWeight(ID3DXAnimationController *iface,
 287         UINT track, float new_weight, double start_time, double duration, D3DXTRANSITION_TYPE transition)
 288 {
 289     FIXME("iface %p, track %u, new_weight %.8e, start_time %.16e, duration %.16e, transition %u stub.\n", iface,
 290             track, new_weight, start_time, duration, transition);
 291
 292     return 0;
 293 }
 294
 295 static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_KeyTrackPosition(ID3DXAnimationController *iface,
 296         UINT track, double new_position, double start_time)
 297 {
 298     FIXME("iface %p, track %u, new_position %.16e, start_time %.16e stub.\n", iface,
 299             track, new_position, start_time);
 300
 301     return 0;
 302 }
 303
 304 static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_KeyTrackEnable(ID3DXAnimationController *iface,
 305         UINT track, BOOL new_enable, double start_time)
 306 {
 307     FIXME("iface %p, track %u, new_enable %#x, start_time %.16e stub.\n", iface,
 308             track, new_enable, start_time);
 309
 310     return 0;
 311 }
 312
 313 static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_KeyTrackBlend(ID3DXAnimationController *iface,
 314         float new_blend_weight, double start_time, double duration, D3DXTRANSITION_TYPE transition)
 315 {
 316     FIXME("iface %p, new_blend_weight %.8e, start_time %.16e, duration %.16e, transition %u stub.\n", iface,
 317             new_blend_weight, start_time, duration, transition);
 318
 319     return 0;
 320 }
 321
 322 static HRESULT WINAPI d3dx9_animation_controller_UnkeyEvent(ID3DXAnimationController *iface, D3DXEVENTHANDLE event)
 323 {
 324     FIXME("iface %p, event %lu stub.\n", iface, event);
 325
 326     return E_NOTIMPL;
 327 }
 328
 329 static HRESULT WINAPI d3dx9_animation_controller_UnkeyAllTrackEvents(ID3DXAnimationController *iface, UINT track)
 330 {
 331     FIXME("iface %p, track %u stub.\n", iface, track);
 332
 333     return E_NOTIMPL;
 334 }
 335
 336 static HRESULT WINAPI d3dx9_animation_controller_UnkeyAllPriorityBlends(ID3DXAnimationController *iface)
 337 {
 338     FIXME("iface %p stub.\n", iface);
 339
 340     return E_NOTIMPL;
 341 }
 342
 343 static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_GetCurrentTrackEvent(ID3DXAnimationController *iface,
 344         UINT track, D3DXEVENT_TYPE event_type)
 345 {
 346     FIXME("iface %p, track %u, event_type %u stub.\n", iface, track, event_type);
 347
 348     return 0;
 349 }
 350
 351 static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_GetCurrentPriorityBlend(ID3DXAnimationController *iface)
 352 {
 353     FIXME("iface %p stub.\n", iface);
 354
 355     return 0;
 356 }
 357
 358 static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_GetUpcomingTrackEvent(ID3DXAnimationController *iface,
 359         UINT track, D3DXEVENTHANDLE event)
 360 {
 361     FIXME("iface %p, track %u, event %lu stub.\n", iface, track, event);
 362
 363     return 0;
 364 }
 365
 366 static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_GetUpcomingPriorityBlend(ID3DXAnimationController *iface,
 367         D3DXEVENTHANDLE event)
 368 {
 369     FIXME("iface %p, event %lu stub.\n", iface, event);
 370
 371     return 0;
 372 }
 373
 374 static HRESULT WINAPI d3dx9_animation_controller_ValidateEvent(ID3DXAnimationController *iface, D3DXEVENTHANDLE event)
 375 {
 376     FIXME("iface %p, event %lu stub.\n", iface, event);
 377
 378     return E_NOTIMPL;
 379 }
 380
 381 static HRESULT WINAPI d3dx9_animation_controller_GetEventDesc(ID3DXAnimationController *iface,
 382         D3DXEVENTHANDLE event, D3DXEVENT_DESC *desc)
 383 {
 384     FIXME("iface %p, event %lu, desc %p stub.\n", iface, event, desc);
 385
 386     return E_NOTIMPL;
 387 }
 388
 389 static HRESULT WINAPI d3dx9_animation_controller_CloneAnimationController(ID3DXAnimationController *iface, UINT max_outputs,
 390         UINT max_sets, UINT max_tracks, UINT max_events, ID3DXAnimationController **anim_controller)
 391 {
 392     FIXME("iface %p, max_outputs %u, max_sets %u, max_tracks %u, max_events %u, anim_controller %p stub.\n",
 393             iface, max_outputs, max_sets, max_tracks, max_events, anim_controller);
 394
 395     return E_NOTIMPL;
 396 }
 397
 398 static const struct ID3DXAnimationControllerVtbl d3dx9_animation_controller_vtbl =
 399 {
 400     d3dx9_animation_controller_QueryInterface,
 401     d3dx9_animation_controller_AddRef,
 402     d3dx9_animation_controller_Release,
 403     d3dx9_animation_controller_GetMaxNumAnimationOutputs,
 404     d3dx9_animation_controller_GetMaxNumAnimationSets,
 405     d3dx9_animation_controller_GetMaxNumTracks,
 406     d3dx9_animation_controller_GetMaxNumEvents,
 407     d3dx9_animation_controller_RegisterAnimationOutput,
 408     d3dx9_animation_controller_RegisterAnimationSet,
 409     d3dx9_animation_controller_UnregisterAnimationSet,
 410     d3dx9_animation_controller_GetNumAnimationSets,
 411     d3dx9_animation_controller_GetAnimationSet,
 412     d3dx9_animation_controller_GetAnimationSetByName,
 413     d3dx9_animation_controller_AdvanceTime,
 414     d3dx9_animation_controller_Reset,
 415     d3dx9_animation_controller_GetTime,
 416     d3dx9_animation_controller_SetTrackAnimationSet,
 417     d3dx9_animation_controller_GetTrackAnimationSet,
 418     d3dx9_animation_controller_SetTrackPriority,
 419     d3dx9_animation_controller_SetTrackSpeed,
 420     d3dx9_animation_controller_SetTrackWeight,
 421     d3dx9_animation_controller_SetTrackPosition,
 422     d3dx9_animation_controller_SetTrackEnable,
 423     d3dx9_animation_controller_SetTrackDesc,
 424     d3dx9_animation_controller_GetTrackDesc,
 425     d3dx9_animation_controller_SetPriorityBlend,
 426     d3dx9_animation_controller_GetPriorityBlend,
 427     d3dx9_animation_controller_KeyTrackSpeed,
 428     d3dx9_animation_controller_KeyTrackWeight,
 429     d3dx9_animation_controller_KeyTrackPosition,
 430     d3dx9_animation_controller_KeyTrackEnable,
 431     d3dx9_animation_controller_KeyTrackBlend,
 432     d3dx9_animation_controller_UnkeyEvent,
 433     d3dx9_animation_controller_UnkeyAllTrackEvents,
 434     d3dx9_animation_controller_UnkeyAllPriorityBlends,
 435     d3dx9_animation_controller_GetCurrentTrackEvent,
 436     d3dx9_animation_controller_GetCurrentPriorityBlend,
 437     d3dx9_animation_controller_GetUpcomingTrackEvent,
 438     d3dx9_animation_controller_GetUpcomingPriorityBlend,
 439     d3dx9_animation_controller_ValidateEvent,
 440     d3dx9_animation_controller_GetEventDesc,
 441     d3dx9_animation_controller_CloneAnimationController
 442 };
 443
 444 HRESULT WINAPI D3DXCreateAnimationController(UINT max_outputs, UINT max_sets,
 445         UINT max_tracks, UINT max_events, ID3DXAnimationController **controller)
 446 {
 447     struct d3dx9_animation_controller *object;
 448
 449     TRACE("max_outputs %u, max_sets %u, max_tracks %u, max_events %u, controller %p.\n",
 450             max_outputs, max_sets, max_tracks, max_events, controller);
 451
 452     if (!max_outputs || !max_sets || !max_tracks || !max_events || !controller)
 453         return D3D_OK;
 454
 455     object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object));
 456     if (!object)
 457         return E_OUTOFMEMORY;
 458
 459     object->ID3DXAnimationController_iface.lpVtbl = &d3dx9_animation_controller_vtbl;
 460     object->ref = 1;
 461     object->max_outputs = max_outputs;
 462     object->max_sets    = max_sets;
 463     object->max_tracks  = max_tracks;
 464     object->max_events  = max_events;
 465
 466     *controller = &object->ID3DXAnimationController_iface;
 467
 468     return D3D_OK;
 469 }
 470
 471 struct d3dx9_keyframed_animation_set
 472 {
 473     ID3DXKeyframedAnimationSet ID3DXKeyframedAnimationSet_iface;
 474     LONG ref;
 475
 476     const char *name;
 477     double ticks_per_second;
 478     D3DXPLAYBACK_TYPE playback_type;
 479     unsigned int animation_count;
 480     unsigned int callback_key_count;
 481     const D3DXKEY_CALLBACK *callback_keys;
 482 };
 483
 484 static inline struct d3dx9_keyframed_animation_set *impl_from_ID3DXKeyframedAnimationSet(ID3DXKeyframedAnimationSet *iface)
 485 {
 486     return CONTAINING_RECORD(iface, struct d3dx9_keyframed_animation_set, ID3DXKeyframedAnimationSet_iface);
 487 }
 488
 489 static HRESULT WINAPI d3dx9_keyframed_animation_QueryInterface(ID3DXKeyframedAnimationSet *iface,
 490         REFIID riid, void **obj)
 491 {
 492     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), obj);
 493
 494     if (IsEqualGUID(riid, &IID_IUnknown)
 495             || IsEqualGUID(riid, &IID_ID3DXAnimationSet)
 496             || IsEqualGUID(riid, &IID_ID3DXKeyframedAnimationSet))
 497     {
 498         iface->lpVtbl->AddRef(iface);
 499         *obj = iface;
 500         return D3D_OK;
 501     }
 502
 503     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 504     *obj = NULL;
 505     return E_NOINTERFACE;
 506 }
 507
 508 static ULONG WINAPI d3dx9_keyframed_animation_AddRef(ID3DXKeyframedAnimationSet *iface)
 509 {
 510     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 511     ULONG refcount = InterlockedIncrement(&set->ref);
 512
 513     TRACE("%p increasing refcount to %lu.\n", set, refcount);
 514
 515     return refcount;
 516 }
 517
 518 static ULONG WINAPI d3dx9_keyframed_animation_Release(ID3DXKeyframedAnimationSet *iface)
 519 {
 520     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 521     ULONG refcount = InterlockedDecrement(&set->ref);
 522
 523     TRACE("%p decreasing refcount to %lu.\n", set, refcount);
 524
 525     if (!refcount)
 526     {
 527         heap_free((char *)set->name);
 528         heap_free(set);
 529     }
 530
 531     return refcount;
 532 }
 533
 534 static const char * WINAPI d3dx9_keyframed_animation_GetName(ID3DXKeyframedAnimationSet *iface)
 535 {
 536     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 537
 538     TRACE("set %p.\n", set);
 539     return set->name;
 540 }
 541
 542 static double WINAPI d3dx9_keyframed_animation_GetPeriod(ID3DXKeyframedAnimationSet *iface)
 543 {
 544     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 545
 546     FIXME("set %p stub.\n", set);
 547     return 0.0;
 548 }
 549
 550 static double WINAPI d3dx9_keyframed_animation_GetPeriodicPosition(ID3DXKeyframedAnimationSet *iface, double position)
 551 {
 552     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 553
 554     FIXME("set %p, position %.16e stub.\n", set, position);
 555     return 0.0;
 556 }
 557
 558 static UINT WINAPI d3dx9_keyframed_animation_GetNumAnimations(ID3DXKeyframedAnimationSet *iface)
 559 {
 560     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 561
 562     FIXME("set %p stub.\n", set);
 563     return 0;
 564 }
 565
 566 static HRESULT WINAPI d3dx9_keyframed_animation_GetAnimationNameByIndex(ID3DXKeyframedAnimationSet *iface,
 567         UINT index, const char **name)
 568 {
 569     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 570
 571     FIXME("set %p, index %u, name %p stub.\n", set, index, name);
 572     return E_NOTIMPL;
 573 }
 574
 575 static HRESULT WINAPI d3dx9_keyframed_animation_GetAnimationIndexByName(ID3DXKeyframedAnimationSet *iface,
 576         const char *name, UINT *index)
 577 {
 578     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 579
 580     FIXME("set %p, name %s, index %p stub.\n", set, debugstr_a(name), index);
 581     return E_NOTIMPL;
 582 }
 583
 584 static HRESULT WINAPI d3dx9_keyframed_animation_GetSRT(ID3DXKeyframedAnimationSet *iface, double periodic_position,
 585         UINT animation, D3DXVECTOR3 *scale, D3DXQUATERNION *rotation, D3DXVECTOR3 *translation)
 586 {
 587     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 588
 589     FIXME("set %p, periodic_position %.16e, animation %u, scale %p, rotation %p, translation %p stub.\n",
 590             set, periodic_position, animation, scale, rotation, translation);
 591     return E_NOTIMPL;
 592 }
 593
 594 static HRESULT WINAPI d3dx9_keyframed_animation_GetCallback(ID3DXKeyframedAnimationSet *iface, double position,
 595         DWORD flags, double *callback_position, void **callback_data)
 596 {
 597     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 598
 599     FIXME("set %p, position %.16e, flags %#lx, callback_position %p, callback_data %p stub.\n",
 600             set, position, flags, callback_position, callback_data);
 601     return E_NOTIMPL;
 602 }
 603
 604 static D3DXPLAYBACK_TYPE WINAPI d3dx9_keyframed_animation_GetPlaybackType(ID3DXKeyframedAnimationSet *iface)
 605 {
 606     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 607
 608     TRACE("set %p.\n", set);
 609     return set->playback_type;
 610 }
 611
 612 static double WINAPI d3dx9_keyframed_animation_GetSourceTicksPerSecond(ID3DXKeyframedAnimationSet *iface)
 613 {
 614     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 615
 616     TRACE("set %p.\n", set);
 617     return set->ticks_per_second;
 618 }
 619
 620 static UINT WINAPI d3dx9_keyframed_animation_GetNumScaleKeys(ID3DXKeyframedAnimationSet *iface, UINT keys)
 621 {
 622     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 623
 624     FIXME("set %p, keys %u stub.\n", set, keys);
 625     return 0;
 626 }
 627
 628 static HRESULT WINAPI d3dx9_keyframed_animation_GetScaleKeys(ID3DXKeyframedAnimationSet *iface, UINT animation,
 629         D3DXKEY_VECTOR3 *scale_keys)
 630 {
 631     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 632
 633     FIXME("set %p, animation %u, scale_keys %p stub.\n", set, animation, scale_keys);
 634     return E_NOTIMPL;
 635 }
 636
 637 static HRESULT WINAPI d3dx9_keyframed_animation_GetScaleKey(ID3DXKeyframedAnimationSet *iface, UINT animation,
 638         UINT key, D3DXKEY_VECTOR3 *scale_key)
 639 {
 640     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 641
 642     FIXME("set %p, animation %u, key %u, scale_key %p stub.\n", set, animation, key, scale_key);
 643     return E_NOTIMPL;
 644 }
 645
 646 static HRESULT WINAPI d3dx9_keyframed_animation_SetScaleKey(ID3DXKeyframedAnimationSet *iface, UINT animation,
 647         UINT key, D3DXKEY_VECTOR3 *scale_key)
 648 {
 649     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 650
 651     FIXME("set %p, animation %u, key %u, scale_key %p stub.\n", set, animation, key, scale_key);
 652     return E_NOTIMPL;
 653 }
 654
 655 static UINT WINAPI d3dx9_keyframed_animation_GetNumRotationKeys(ID3DXKeyframedAnimationSet *iface, UINT animation)
 656 {
 657     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 658
 659     FIXME("set %p, animation %u stub.\n", set, animation);
 660     return E_NOTIMPL;
 661 }
 662
 663 static HRESULT WINAPI d3dx9_keyframed_animation_GetRotationKeys(ID3DXKeyframedAnimationSet *iface,
 664         UINT animation, D3DXKEY_QUATERNION *rotation_keys)
 665 {
 666     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 667
 668     FIXME("set %p, animation %u, rotation_keys %p stub.\n", set, animation, rotation_keys);
 669     return E_NOTIMPL;
 670 }
 671
 672 static HRESULT WINAPI d3dx9_keyframed_animation_GetRotationKey(ID3DXKeyframedAnimationSet *iface,
 673         UINT animation, UINT key, D3DXKEY_QUATERNION *rotation_key)
 674 {
 675     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 676
 677     FIXME("set %p, animation %u, key %u, rotation_key %p stub.\n", set, animation, key, rotation_key);
 678     return E_NOTIMPL;
 679 }
 680
 681 static HRESULT WINAPI d3dx9_keyframed_animation_SetRotationKey(ID3DXKeyframedAnimationSet *iface,
 682         UINT animation, UINT key, D3DXKEY_QUATERNION *rotation_key)
 683 {
 684     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 685
 686     FIXME("set %p, animation %u, key %u, rotation_key %p stub.\n", set, animation, key, rotation_key);
 687     return E_NOTIMPL;
 688 }
 689
 690 static UINT WINAPI d3dx9_keyframed_animation_GetNumTranslationKeys(ID3DXKeyframedAnimationSet *iface, UINT animation)
 691 {
 692     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 693
 694     FIXME("set %p, animation %u stub.\n", set, animation);
 695     return E_NOTIMPL;
 696 }
 697
 698 static HRESULT WINAPI d3dx9_keyframed_animation_GetTranslationKeys(ID3DXKeyframedAnimationSet *iface,
 699         UINT animation, D3DXKEY_VECTOR3 *translation_keys)
 700 {
 701     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 702
 703     FIXME("set %p, animation %u, translation_keys %p stub.\n", set, animation, translation_keys);
 704     return E_NOTIMPL;
 705 }
 706
 707 static HRESULT WINAPI d3dx9_keyframed_animation_GetTranslationKey(ID3DXKeyframedAnimationSet *iface,
 708         UINT animation, UINT key, D3DXKEY_VECTOR3 *translation_key)
 709 {
 710     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 711
 712     FIXME("set %p, animation %u, key %u, translation_key %p stub.\n", set, animation, key, translation_key);
 713     return E_NOTIMPL;
 714 }
 715
 716 static HRESULT WINAPI d3dx9_keyframed_animation_SetTranslationKey(ID3DXKeyframedAnimationSet *iface,
 717         UINT animation, UINT key, D3DXKEY_VECTOR3 *translation_key)
 718 {
 719     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 720
 721     FIXME("set %p, animation %u, key %u, translation_key %p stub.\n", set, animation, key, translation_key);
 722     return E_NOTIMPL;
 723 }
 724
 725 static UINT WINAPI d3dx9_keyframed_animation_GetNumCallbackKeys(ID3DXKeyframedAnimationSet *iface)
 726 {
 727     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 728
 729     FIXME("set %p stub.\n", set);
 730     return E_NOTIMPL;
 731 }
 732
 733 static HRESULT WINAPI d3dx9_keyframed_animation_GetCallbackKeys(ID3DXKeyframedAnimationSet *iface,
 734         D3DXKEY_CALLBACK *callback_keys)
 735 {
 736     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 737
 738     FIXME("set %p, callback_keys %p stub.\n", set, callback_keys);
 739     return E_NOTIMPL;
 740 }
 741
 742 static HRESULT WINAPI d3dx9_keyframed_animation_GetCallbackKey(ID3DXKeyframedAnimationSet *iface,
 743         UINT key, D3DXKEY_CALLBACK *callback_key)
 744 {
 745     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 746
 747     FIXME("set %p, key %u, callback_key %p stub.\n", set, key, callback_key);
 748     return E_NOTIMPL;
 749 }
 750
 751 static HRESULT WINAPI d3dx9_keyframed_animation_SetCallbackKey(ID3DXKeyframedAnimationSet *iface,
 752         UINT key, D3DXKEY_CALLBACK *callback_key)
 753 {
 754     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 755
 756     FIXME("set %p, key %u, callback_key %p stub.\n", set, key, callback_key);
 757     return E_NOTIMPL;
 758 }
 759
 760 static HRESULT WINAPI d3dx9_keyframed_animation_UnregisterScaleKey(ID3DXKeyframedAnimationSet *iface,
 761         UINT animation, UINT key)
 762 {
 763     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 764
 765     FIXME("set %p, animation %u, key %u stub.\n", set, animation, key);
 766     return E_NOTIMPL;
 767 }
 768
 769 static HRESULT WINAPI d3dx9_keyframed_animation_UnregisterRotationKey(ID3DXKeyframedAnimationSet *iface,
 770         UINT animation, UINT key)
 771 {
 772     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 773
 774     FIXME("set %p, animation %u, key %u stub.\n", set, animation, key);
 775     return E_NOTIMPL;
 776 }
 777
 778 static HRESULT WINAPI d3dx9_keyframed_animation_UnregisterTranslationKey(ID3DXKeyframedAnimationSet *iface,
 779         UINT animation, UINT key)
 780 {
 781     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 782
 783     FIXME("set %p, animation %u, key %u stub.\n", set, animation, key);
 784     return E_NOTIMPL;
 785 }
 786
 787 static HRESULT WINAPI d3dx9_keyframed_animation_RegisterAnimationSRTKeys(ID3DXKeyframedAnimationSet *iface,
 788         const char *name, UINT scale_keys_count, UINT rotation_keys_count, UINT translation_keys_count,
 789         const D3DXKEY_VECTOR3 *scale_keys, const D3DXKEY_QUATERNION *rotation_keys,
 790         const D3DXKEY_VECTOR3 *translation_keys, DWORD *animation_index)
 791 {
 792     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 793
 794     FIXME("set %p, name %s, scale_keys_count %u, rotation_keys_count %u, translation_keys_count %u, "
 795             "scale_keys %p, rotation_keys %p, translation_keys %p, animation_index %p stub.\n",
 796             set, debugstr_a(name), scale_keys_count, rotation_keys_count, translation_keys_count,
 797             scale_keys, rotation_keys, translation_keys, animation_index);
 798     return E_NOTIMPL;
 799 }
 800
 801 static HRESULT WINAPI d3dx9_keyframed_animation_Compress(ID3DXKeyframedAnimationSet *iface,
 802         DWORD flags, float lossiness, D3DXFRAME *hierarchy, ID3DXBuffer **compressed_data)
 803 {
 804     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 805
 806     FIXME("set %p, flags %#lx, lossiness %.8e, hierarchy %p, compressed_data %p stub.\n",
 807             set, flags, lossiness, hierarchy, compressed_data);
 808     return E_NOTIMPL;
 809 }
 810
 811 static HRESULT WINAPI d3dx9_keyframed_animation_UnregisterAnimation(ID3DXKeyframedAnimationSet *iface, UINT index)
 812 {
 813     struct d3dx9_keyframed_animation_set *set = impl_from_ID3DXKeyframedAnimationSet(iface);
 814
 815     FIXME("set %p, index %u stub.\n", set, index);
 816     return E_NOTIMPL;
 817 }
 818
 819 static const struct ID3DXKeyframedAnimationSetVtbl d3dx9_keyframed_animation_vtbl =
 820 {
 821     d3dx9_keyframed_animation_QueryInterface,
 822     d3dx9_keyframed_animation_AddRef,
 823     d3dx9_keyframed_animation_Release,
 824     d3dx9_keyframed_animation_GetName,
 825     d3dx9_keyframed_animation_GetPeriod,
 826     d3dx9_keyframed_animation_GetPeriodicPosition,
 827     d3dx9_keyframed_animation_GetNumAnimations,
 828     d3dx9_keyframed_animation_GetAnimationNameByIndex,
 829     d3dx9_keyframed_animation_GetAnimationIndexByName,
 830     d3dx9_keyframed_animation_GetSRT,
 831     d3dx9_keyframed_animation_GetCallback,
 832     d3dx9_keyframed_animation_GetPlaybackType,
 833     d3dx9_keyframed_animation_GetSourceTicksPerSecond,
 834     d3dx9_keyframed_animation_GetNumScaleKeys,
 835     d3dx9_keyframed_animation_GetScaleKeys,
 836     d3dx9_keyframed_animation_GetScaleKey,
 837     d3dx9_keyframed_animation_SetScaleKey,
 838     d3dx9_keyframed_animation_GetNumRotationKeys,
 839     d3dx9_keyframed_animation_GetRotationKeys,
 840     d3dx9_keyframed_animation_GetRotationKey,
 841     d3dx9_keyframed_animation_SetRotationKey,
 842     d3dx9_keyframed_animation_GetNumTranslationKeys,
 843     d3dx9_keyframed_animation_GetTranslationKeys,
 844     d3dx9_keyframed_animation_GetTranslationKey,
 845     d3dx9_keyframed_animation_SetTranslationKey,
 846     d3dx9_keyframed_animation_GetNumCallbackKeys,
 847     d3dx9_keyframed_animation_GetCallbackKeys,
 848     d3dx9_keyframed_animation_GetCallbackKey,
 849     d3dx9_keyframed_animation_SetCallbackKey,
 850     d3dx9_keyframed_animation_UnregisterScaleKey,
 851     d3dx9_keyframed_animation_UnregisterRotationKey,
 852     d3dx9_keyframed_animation_UnregisterTranslationKey,
 853     d3dx9_keyframed_animation_RegisterAnimationSRTKeys,
 854     d3dx9_keyframed_animation_Compress,
 855     d3dx9_keyframed_animation_UnregisterAnimation
 856 };
 857
 858 HRESULT WINAPI D3DXCreateKeyframedAnimationSet(const char *name, double ticks_per_second,
 859         D3DXPLAYBACK_TYPE playback_type, UINT animation_count, UINT callback_key_count,
 860         const D3DXKEY_CALLBACK *callback_keys, ID3DXKeyframedAnimationSet **animation_set)
 861 {
 862     struct d3dx9_keyframed_animation_set *object;
 863     char *string;
 864
 865     TRACE("name %s, ticks_per_second %.16e, playback_type %u, animation_count %u, "
 866             "callback_key_count %u, callback_keys %p, animation_set %p.\n",
 867             debugstr_a(name), ticks_per_second, playback_type, animation_count,
 868             callback_key_count, callback_keys, animation_set);
 869
 870     if (!animation_count)
 871         return D3DERR_INVALIDCALL;
 872
 873     if (!(object = heap_alloc(sizeof(*object))))
 874         return E_OUTOFMEMORY;
 875
 876     object->ID3DXKeyframedAnimationSet_iface.lpVtbl = &d3dx9_keyframed_animation_vtbl;
 877     object->ref = 1;
 878     if (!(string = heap_alloc(strlen(name) + 1)))
 879     {
 880         heap_free(object);
 881         return E_OUTOFMEMORY;
 882     }
 883     strcpy(string, name);
 884     object->name = string;
 885     object->ticks_per_second = ticks_per_second;
 886     object->playback_type = playback_type;
 887     object->animation_count = animation_count;
 888     object->callback_key_count = callback_key_count;
 889     object->callback_keys = callback_keys;
 890
 891     *animation_set = &object->ID3DXKeyframedAnimationSet_iface;
 892
 893     return D3D_OK;
 894 }