[PATCH 1/3] d3dx9: Implement D3DXCreateAnimationController with a stubbed ID3DXAnimationController interface. (try 3)
Alistair Leslie-Hughes
leslie_alistair at hotmail.com
Tue Jan 12 01:34:30 CST 2016
From: Christian Costa <titan.costa at gmail.com>
Correct QI to be like the IDevice11 one.
Changed DOUBLE to double in the interface.
Adjusted parameter names in D3DXCreateAnimationController
Corrected Interface
Changed to use %.16e in TRACE
Signed-off-by: Alistair Leslie-Hughes <leslie_alistair at hotmail.com>
---
dlls/d3dx9_36/Makefile.in | 1 +
dlls/d3dx9_36/animation.c | 452 ++++++++++++++++++++++++++++++++++++++++++++
dlls/d3dx9_36/d3dx9_36.spec | 2 +-
include/d3dx9anim.h | 40 ++--
4 files changed, 474 insertions(+), 21 deletions(-)
create mode 100644 dlls/d3dx9_36/animation.c
diff --git a/dlls/d3dx9_36/Makefile.in b/dlls/d3dx9_36/Makefile.in
index 5958c57..95e3045 100644
--- a/dlls/d3dx9_36/Makefile.in
+++ b/dlls/d3dx9_36/Makefile.in
@@ -3,6 +3,7 @@ IMPORTLIB = d3dx9
IMPORTS = d3d9 d3dcompiler dxguid d3dxof ole32 gdi32 user32
C_SRCS = \
+ animation.c \
core.c \
d3dx9_36_main.c \
effect.c \
diff --git a/dlls/d3dx9_36/animation.c b/dlls/d3dx9_36/animation.c
new file mode 100644
index 0000000..5ac9b85
--- /dev/null
+++ b/dlls/d3dx9_36/animation.c
@@ -0,0 +1,452 @@
+/*
+ * Animation Controller operations specific to D3DX9.
+ *
+ * Copyright (C) 2015 Christian Costa
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "wine/debug.h"
+#include "d3dx9_36_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
+
+struct d3dx9_animation_controller
+{
+ ID3DXAnimationController ID3DXAnimationController_iface;
+ LONG ref;
+};
+
+static inline struct d3dx9_animation_controller *impl_from_ID3DXAnimationController(ID3DXAnimationController *iface)
+{
+ return CONTAINING_RECORD(iface, struct d3dx9_animation_controller, ID3DXAnimationController_iface);
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_QueryInterface(ID3DXAnimationController *iface, REFIID riid, void **out)
+{
+ TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
+
+ if (IsEqualGUID(riid, &IID_IUnknown) ||
+ IsEqualGUID(riid, &IID_ID3DXAnimationController))
+ {
+ iface->lpVtbl->AddRef(iface);
+ *out = iface;
+ return D3D_OK;
+ }
+
+ WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
+ *out = NULL;
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI d3dx9_animation_controller_AddRef(ID3DXAnimationController *iface)
+{
+ struct d3dx9_animation_controller *animation = impl_from_ID3DXAnimationController(iface);
+ ULONG refcount = InterlockedIncrement(&animation->ref);
+
+ TRACE("%p increasing refcount to %u.\n", animation, refcount);
+
+ return refcount;
+}
+
+static ULONG WINAPI d3dx9_animation_controller_Release(ID3DXAnimationController *iface)
+{
+ struct d3dx9_animation_controller *animation = impl_from_ID3DXAnimationController(iface);
+ ULONG refcount = InterlockedDecrement(&animation->ref);
+
+ TRACE("%p decreasing refcount to %u.\n", animation, refcount);
+
+ if (!refcount)
+ {
+ HeapFree(GetProcessHeap(), 0, animation);
+ }
+
+ return refcount;
+}
+
+static UINT WINAPI d3dx9_animation_controller_GetMaxNumAnimationOutputs(ID3DXAnimationController *iface)
+{
+ FIXME("iface %p stub.\n", iface);
+
+ return 0;
+}
+
+static UINT WINAPI d3dx9_animation_controller_GetMaxNumAnimationSets(ID3DXAnimationController *iface)
+{
+ FIXME("iface %p stub.\n", iface);
+
+ return 0;
+}
+
+static UINT WINAPI d3dx9_animation_controller_GetMaxNumTracks(ID3DXAnimationController *iface)
+{
+ FIXME("iface %p stub.\n", iface);
+
+ return 0;
+}
+
+static UINT WINAPI d3dx9_animation_controller_GetMaxNumEvents(ID3DXAnimationController *iface)
+{
+ FIXME("iface %p stub.\n", iface);
+
+ return 0;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_RegisterAnimationOutput(ID3DXAnimationController *iface,
+ const char *name, D3DXMATRIX *matrix, D3DXVECTOR3 *scale, D3DXQUATERNION *rotation, D3DXVECTOR3 *translation)
+{
+ FIXME("iface %p, name %s, matrix %p, scale %p, rotation %p, translation %p stub.\n", iface, wine_dbgstr_a(name),
+ matrix, scale, rotation, translation);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_RegisterAnimationSet(ID3DXAnimationController *iface,
+ ID3DXAnimationSet *anim_set)
+{
+ FIXME("iface %p, anim_set %p stub.\n", iface, anim_set);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_UnregisterAnimationSet(ID3DXAnimationController *iface,
+ ID3DXAnimationSet *anim_set)
+{
+ FIXME("iface %p, anim_set %p stub.\n", iface, anim_set);
+
+ return E_NOTIMPL;
+}
+
+static UINT WINAPI d3dx9_animation_controller_GetNumAnimationSets(ID3DXAnimationController *iface)
+{
+ FIXME("iface %p stub.\n", iface);
+
+ return 0;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_GetAnimationSet(ID3DXAnimationController *iface,
+ UINT index, ID3DXAnimationSet **anim_set)
+{
+ FIXME("iface %p, index %u, anim_set %p stub.\n", iface, index, anim_set);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_GetAnimationSetByName(ID3DXAnimationController *iface,
+ const char *name, ID3DXAnimationSet **anim_set)
+{
+ FIXME("iface %p, name %s, anim_set %p stub.\n", iface, wine_dbgstr_a(name), anim_set);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_AdvanceTime(ID3DXAnimationController *iface, double time_delta,
+ ID3DXAnimationCallbackHandler *callback_handler)
+{
+ FIXME("iface %p, time_delta %.16e, callback_handler %p stub.\n", iface, time_delta, callback_handler);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_Reset(ID3DXAnimationController *iface)
+{
+ FIXME("iface %p stub.\n", iface);
+
+ return E_NOTIMPL;
+}
+
+static double WINAPI d3dx9_animation_controller_GetTime(ID3DXAnimationController *iface)
+{
+ FIXME("iface %p stub.\n", iface);
+
+ return 0.0;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_SetTrackAnimationSet(ID3DXAnimationController *iface,
+ UINT track, ID3DXAnimationSet *anim_set)
+{
+ FIXME("iface %p, track %u, anim_set %p stub.\n", iface, track, anim_set);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_GetTrackAnimationSet(ID3DXAnimationController *iface,
+ UINT track, ID3DXAnimationSet **anim_set)
+{
+ FIXME("iface %p, track %u, anim_set %p stub.\n", iface, track, anim_set);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_SetTrackPriority(ID3DXAnimationController *iface,
+ UINT track, D3DXPRIORITY_TYPE priority)
+{
+ FIXME("iface %p, track %u, priority %d stub.\n", iface, track, priority);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_SetTrackSpeed(ID3DXAnimationController *iface,
+ UINT track, float speed)
+{
+ FIXME("iface %p, track %u, speed %f stub.\n", iface, track, speed);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_SetTrackWeight(ID3DXAnimationController *iface,
+ UINT track, float weight)
+{
+ FIXME("iface %p, track %u, weight %f stub.\n", iface, track, weight);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_SetTrackPosition(ID3DXAnimationController *iface,
+ UINT track, double position)
+{
+ FIXME("iface %p, track %u, position %.16e stub.\n", iface, track, position);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_SetTrackEnable(ID3DXAnimationController *iface,
+ UINT track, BOOL enable)
+{
+ FIXME("iface %p, track %u, enable %u stub.\n", iface, track, enable);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_SetTrackDesc(ID3DXAnimationController *iface,
+ UINT track, D3DXTRACK_DESC *desc)
+{
+ FIXME("iface %p, track %u, desc %p stub.\n", iface, track, desc);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_GetTrackDesc(ID3DXAnimationController *iface,
+ UINT track, D3DXTRACK_DESC *desc)
+{
+ FIXME("iface %p, track %u, desc %p stub.\n", iface, track, desc);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_SetPriorityBlend(ID3DXAnimationController *iface,
+ float blend_weight)
+{
+ FIXME("iface %p, blend_weight %f stub.\n", iface, blend_weight);
+
+ return E_NOTIMPL;
+}
+
+static float WINAPI d3dx9_animation_controller_GetPriorityBlend(ID3DXAnimationController *iface)
+{
+ FIXME("iface %p stub.\n", iface);
+
+ return 0.0f;
+}
+
+static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_KeyTrackSpeed(ID3DXAnimationController *iface,
+ UINT track, float new_speed, double start_time, double duration, D3DXTRANSITION_TYPE transition)
+{
+ FIXME("iface %p, track %u, new_speed %f, start_time %.16e, duration %.16e, transition %u stub.\n", iface,
+ track, new_speed, start_time, duration, transition);
+
+ return 0;
+}
+
+static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_KeyTrackWeight(ID3DXAnimationController *iface,
+ UINT track, float new_weight, double start_time, double duration, D3DXTRANSITION_TYPE transition)
+{
+ FIXME("iface %p, track %u, new_weight %f, start_time %.16e, duration %.16e, transition %u stub.\n", iface,
+ track, new_weight, start_time, duration, transition);
+
+ return 0;
+}
+
+static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_KeyTrackPosition(ID3DXAnimationController *iface,
+ UINT track, double new_position, double start_time)
+{
+ FIXME("iface %p, track %u, new_position %.16e, start_time %.16e stub.\n", iface,
+ track, new_position, start_time);
+
+ return 0;
+}
+
+static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_KeyTrackEnable(ID3DXAnimationController *iface,
+ UINT track, BOOL new_enable, double start_time)
+{
+ FIXME("iface %p, track %u, new_enable %u, start_time %.16e stub.\n", iface,
+ track, new_enable, start_time);
+
+ return 0;
+}
+
+static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_KeyTrackBlend(ID3DXAnimationController *iface,
+ float new_blend_weight, double start_time, double duration, D3DXTRANSITION_TYPE transition)
+{
+ FIXME("iface %p, new_blend_weight %f, start_time %.16e, duration %.16e, transition %u stub.\n", iface,
+ new_blend_weight, start_time, duration, transition);
+
+ return 0;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_UnkeyEvent(ID3DXAnimationController *iface, D3DXEVENTHANDLE event)
+{
+ FIXME("iface %p, event %u stub.\n", iface, event);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_UnkeyAllTrackEvents(ID3DXAnimationController *iface, UINT track)
+{
+ FIXME("iface %p, track %u stub.\n", iface, track);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_UnkeyAllPriorityBlends(ID3DXAnimationController *iface)
+{
+ FIXME("iface %p stub.\n", iface);
+
+ return E_NOTIMPL;
+}
+
+static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_GetCurrentTrackEvent(ID3DXAnimationController *iface,
+ UINT track, D3DXEVENT_TYPE event_type)
+{
+ FIXME("iface %p, track %u, event_type %u stub.\n", iface, track, event_type);
+
+ return 0;
+}
+
+static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_GetCurrentPriorityBlend(ID3DXAnimationController *iface)
+{
+ FIXME("iface %p stub.\n", iface);
+
+ return 0;
+}
+
+static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_GetUpcomingTrackEvent(ID3DXAnimationController *iface,
+ UINT track, D3DXEVENTHANDLE event)
+{
+ FIXME("iface %p, track %u, event %u stub.\n", iface, track, event);
+
+ return 0;
+}
+
+static D3DXEVENTHANDLE WINAPI d3dx9_animation_controller_GetUpcomingPriorityBlend(ID3DXAnimationController *iface,
+ D3DXEVENTHANDLE event)
+{
+ FIXME("iface %p, handle %u stub.\n", iface, event);
+
+ return 0;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_ValidateEvent(ID3DXAnimationController *iface, D3DXEVENTHANDLE event)
+{
+ FIXME("iface %p, event %u stub.\n", iface, event);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_GetEventDesc(ID3DXAnimationController *iface,
+ D3DXEVENTHANDLE event, D3DXEVENT_DESC *desc)
+{
+ FIXME("iface %p, event %u, desc %p stub.\n", iface, event, desc);
+
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI d3dx9_animation_controller_CloneAnimationController(ID3DXAnimationController *iface, UINT max_num_anim_outputs,
+ UINT max_num_anim_sets, UINT max_num_tracks, UINT max_num_events, ID3DXAnimationController **anim_controller)
+{
+ FIXME("iface %p, max_num_anim_outputs %u, max_num_anim_sets %u, max_num_tracks %u, max_num_events %u, anim_controller %p stub.\n",
+ iface, max_num_anim_outputs, max_num_anim_sets, max_num_tracks, max_num_events, anim_controller);
+
+ return E_NOTIMPL;
+}
+
+static const struct ID3DXAnimationControllerVtbl d3dx9_animation_controller_vtbl =
+{
+ d3dx9_animation_controller_QueryInterface,
+ d3dx9_animation_controller_AddRef,
+ d3dx9_animation_controller_Release,
+ d3dx9_animation_controller_GetMaxNumAnimationOutputs,
+ d3dx9_animation_controller_GetMaxNumAnimationSets,
+ d3dx9_animation_controller_GetMaxNumTracks,
+ d3dx9_animation_controller_GetMaxNumEvents,
+ d3dx9_animation_controller_RegisterAnimationOutput,
+ d3dx9_animation_controller_RegisterAnimationSet,
+ d3dx9_animation_controller_UnregisterAnimationSet,
+ d3dx9_animation_controller_GetNumAnimationSets,
+ d3dx9_animation_controller_GetAnimationSet,
+ d3dx9_animation_controller_GetAnimationSetByName,
+ d3dx9_animation_controller_AdvanceTime,
+ d3dx9_animation_controller_Reset,
+ d3dx9_animation_controller_GetTime,
+ d3dx9_animation_controller_SetTrackAnimationSet,
+ d3dx9_animation_controller_GetTrackAnimationSet,
+ d3dx9_animation_controller_SetTrackPriority,
+ d3dx9_animation_controller_SetTrackSpeed,
+ d3dx9_animation_controller_SetTrackWeight,
+ d3dx9_animation_controller_SetTrackPosition,
+ d3dx9_animation_controller_SetTrackEnable,
+ d3dx9_animation_controller_SetTrackDesc,
+ d3dx9_animation_controller_GetTrackDesc,
+ d3dx9_animation_controller_SetPriorityBlend,
+ d3dx9_animation_controller_GetPriorityBlend,
+ d3dx9_animation_controller_KeyTrackSpeed,
+ d3dx9_animation_controller_KeyTrackWeight,
+ d3dx9_animation_controller_KeyTrackPosition,
+ d3dx9_animation_controller_KeyTrackEnable,
+ d3dx9_animation_controller_KeyTrackBlend,
+ d3dx9_animation_controller_UnkeyEvent,
+ d3dx9_animation_controller_UnkeyAllTrackEvents,
+ d3dx9_animation_controller_UnkeyAllPriorityBlends,
+ d3dx9_animation_controller_GetCurrentTrackEvent,
+ d3dx9_animation_controller_GetCurrentPriorityBlend,
+ d3dx9_animation_controller_GetUpcomingTrackEvent,
+ d3dx9_animation_controller_GetUpcomingPriorityBlend,
+ d3dx9_animation_controller_ValidateEvent,
+ d3dx9_animation_controller_GetEventDesc,
+ d3dx9_animation_controller_CloneAnimationController
+};
+
+HRESULT WINAPI D3DXCreateAnimationController(UINT max_outputs, UINT max_sets,
+ UINT max_tracks, UINT max_events, ID3DXAnimationController **controller)
+{
+ struct d3dx9_animation_controller *object;
+
+ TRACE("max_outputs %u, max_sets %u, max_tracks %u, max_events %u, controller %p.\n",
+ max_outputs, max_sets, max_tracks, max_events, controller);
+
+ if (!controller)
+ return D3DERR_INVALIDCALL;
+
+ object = HeapAlloc(GetProcessHeap(), 0, sizeof(*object));
+ if (!object)
+ return E_OUTOFMEMORY;
+
+ object->ID3DXAnimationController_iface.lpVtbl = &d3dx9_animation_controller_vtbl;
+ object->ref = 1;
+
+ *controller = &object->ID3DXAnimationController_iface;
+
+ return D3D_OK;
+}
diff --git a/dlls/d3dx9_36/d3dx9_36.spec b/dlls/d3dx9_36/d3dx9_36.spec
index 5eda041..aa7c928 100644
--- a/dlls/d3dx9_36/d3dx9_36.spec
+++ b/dlls/d3dx9_36/d3dx9_36.spec
@@ -30,7 +30,7 @@
@ stub D3DXConcatenateMeshes(ptr long long ptr ptr ptr ptr ptr)
@ stdcall D3DXConvertMeshSubsetToSingleStrip(ptr long long ptr ptr)
@ stub D3DXConvertMeshSubsetToStrips(ptr long long ptr ptr ptr ptr)
-@ stub D3DXCreateAnimationController(long long long long ptr)
+@ stdcall D3DXCreateAnimationController(long long long long ptr)
@ stdcall D3DXCreateBox(ptr float float float ptr ptr)
@ stdcall D3DXCreateBuffer(long ptr)
@ stub D3DXCreateCompressedAnimationSet(ptr long long ptr long ptr ptr)
diff --git a/include/d3dx9anim.h b/include/d3dx9anim.h
index b5f2232..81b8e2f 100644
--- a/include/d3dx9anim.h
+++ b/include/d3dx9anim.h
@@ -327,37 +327,37 @@ DECLARE_INTERFACE_(ID3DXAnimationController, IUnknown)
STDMETHOD_(UINT, GetNumAnimationSets)(THIS) PURE;
STDMETHOD(GetAnimationSet)(THIS_ UINT index, ID3DXAnimationSet **anim_set) PURE;
STDMETHOD(GetAnimationSetByName)(THIS_ const char *name, ID3DXAnimationSet **anim_set) PURE;
- STDMETHOD(AdvanceTime)(THIS_ double time_delta, ID3DXAnimationCallbackHandler **callback_handler) PURE;
+ STDMETHOD(AdvanceTime)(THIS_ double time_delta, ID3DXAnimationCallbackHandler *callback_handler) PURE;
STDMETHOD(ResetTime)(THIS) PURE;
- STDMETHOD_(DOUBLE, GetTime)(THIS) PURE;
+ STDMETHOD_(double, GetTime)(THIS) PURE;
STDMETHOD(SetTrackAnimationSet)(THIS_ UINT track, ID3DXAnimationSet *anim_set) PURE;
STDMETHOD(GetTrackAnimationSet)(THIS_ UINT track, ID3DXAnimationSet **anim_set) PURE;
- STDMETHOD(GetTrackPriority)(THIS_ UINT track, D3DXPRIORITY_TYPE *priority) PURE;
- STDMETHOD(SetTrackSpeed)(THIS_ UINT track, FLOAT speed) PURE;
- STDMETHOD(SetTrackWeight)(THIS_ UINT track, FLOAT weight) PURE;
- STDMETHOD(SetTrackPosition)(THIS_ UINT track, DOUBLE position) PURE;
+ STDMETHOD(SetTrackPriority)(THIS_ UINT track, D3DXPRIORITY_TYPE priority) PURE;
+ STDMETHOD(SetTrackSpeed)(THIS_ UINT track, float speed) PURE;
+ STDMETHOD(SetTrackWeight)(THIS_ UINT track, float weight) PURE;
+ STDMETHOD(SetTrackPosition)(THIS_ UINT track, double position) PURE;
STDMETHOD(SetTrackEnable)(THIS_ UINT track, BOOL enable) PURE;
- STDMETHOD(SetTrackDesc)(THIS_ UINT track, LPD3DXTRACK_DESC desc) PURE;
- STDMETHOD(GetTrackDesc)(THIS_ UINT track, LPD3DXTRACK_DESC desc) PURE;
- STDMETHOD(SetPriorityBlend)(THIS_ FLOAT blend_weight) PURE;
- STDMETHOD_(FLOAT, GetPriorityBlend)(THIS) PURE;
- STDMETHOD_(D3DXEVENTHANDLE, KeyTrackSpeed)(THIS_ UINT track, FLOAT new_speed,
- DOUBLE start_time, DOUBLE duration, D3DXTRANSITION_TYPE transition) PURE;
- STDMETHOD_(D3DXEVENTHANDLE, KeyTrackWeight)(THIS_ UINT track, FLOAT new_weight,
- DOUBLE start_time, DOUBLE duration, D3DXTRANSITION_TYPE transition) PURE;
- STDMETHOD_(D3DXEVENTHANDLE, KeyTrackPosition)(THIS_ UINT track, DOUBLE new_position, DOUBLE start_time) PURE;
- STDMETHOD_(D3DXEVENTHANDLE, KeyTrackEnable)(THIS_ UINT track, BOOL new_enable, DOUBLE start_time) PURE;
- STDMETHOD_(D3DXEVENTHANDLE, KeyPriorityBlend)(THIS_ FLOAT new_blend_weight,
- DOUBLE start_time, DOUBLE duration, D3DXTRANSITION_TYPE transition) PURE;
+ STDMETHOD(SetTrackDesc)(THIS_ UINT track, D3DXTRACK_DESC *desc) PURE;
+ STDMETHOD(GetTrackDesc)(THIS_ UINT track, D3DXTRACK_DESC *desc) PURE;
+ STDMETHOD(SetPriorityBlend)(THIS_ float blend_weight) PURE;
+ STDMETHOD_(float, GetPriorityBlend)(THIS) PURE;
+ STDMETHOD_(D3DXEVENTHANDLE, KeyTrackSpeed)(THIS_ UINT track, float new_speed,
+ double start_time, double duration, D3DXTRANSITION_TYPE transition) PURE;
+ STDMETHOD_(D3DXEVENTHANDLE, KeyTrackWeight)(THIS_ UINT track, float new_weight,
+ double start_time, double duration, D3DXTRANSITION_TYPE transition) PURE;
+ STDMETHOD_(D3DXEVENTHANDLE, KeyTrackPosition)(THIS_ UINT track, double new_position, double start_time) PURE;
+ STDMETHOD_(D3DXEVENTHANDLE, KeyTrackEnable)(THIS_ UINT track, BOOL new_enable, double start_time) PURE;
+ STDMETHOD_(D3DXEVENTHANDLE, KeyPriorityBlend)(THIS_ float new_blend_weight,
+ double start_time, double duration, D3DXTRANSITION_TYPE transition) PURE;
STDMETHOD(UnkeyEvent)(THIS_ D3DXEVENTHANDLE event) PURE;
STDMETHOD(UnkeyAllTrackEvents)(THIS_ UINT track) PURE;
STDMETHOD(UnkeyAllPriorityBlends)(THIS) PURE;
STDMETHOD_(D3DXEVENTHANDLE, GetCurrentTrackEvent)(THIS_ UINT track, D3DXEVENT_TYPE event_type) PURE;
STDMETHOD_(D3DXEVENTHANDLE, GetCurrentPriorityBlend)(THIS) PURE;
STDMETHOD_(D3DXEVENTHANDLE, GetUpcomingTrackEvent)(THIS_ UINT track, D3DXEVENTHANDLE event) PURE;
- STDMETHOD_(D3DXEVENTHANDLE, GetUpcomingPriorityBlend)(THIS_ D3DXEVENTHANDLE handle) PURE;
+ STDMETHOD_(D3DXEVENTHANDLE, GetUpcomingPriorityBlend)(THIS_ D3DXEVENTHANDLE event) PURE;
STDMETHOD(ValidateEvent)(THIS_ D3DXEVENTHANDLE event) PURE;
- STDMETHOD(GetEventDesc)(THIS_ D3DXEVENTHANDLE event, LPD3DXEVENT_DESC desc) PURE;
+ STDMETHOD(GetEventDesc)(THIS_ D3DXEVENTHANDLE event, D3DXEVENT_DESC *desc) PURE;
STDMETHOD(CloneAnimationController)(THIS_ UINT max_num_anim_outputs, UINT max_num_anim_sets,
UINT max_num_tracks, UINT max_num_events, ID3DXAnimationController **anim_controller) PURE;
};
--
2.6.4
More information about the wine-patches
mailing list