diff options
Diffstat (limited to 'Runtime/Animation/AnimationClip.h')
| -rw-r--r-- | Runtime/Animation/AnimationClip.h | 346 |
1 files changed, 346 insertions, 0 deletions
diff --git a/Runtime/Animation/AnimationClip.h b/Runtime/Animation/AnimationClip.h new file mode 100644 index 0000000..1c4c1c2 --- /dev/null +++ b/Runtime/Animation/AnimationClip.h @@ -0,0 +1,346 @@ +#ifndef ANIMATIONCLIP_H +#define ANIMATIONCLIP_H + +#include "Runtime/BaseClasses/NamedObject.h" +#include "Runtime/Serialize/SerializeTraits.h" +#include "Runtime/Utilities/LinkedList.h" +#include "Runtime/Math/Quaternion.h" +#include "Runtime/Math/Vector2.h" +#include "Runtime/Geometry/AABB.h" +#include "Runtime/Math/AnimationCurve.h" +#include "AnimationEvent.h" +#include "Runtime/Mono/MonoScript.h" +#include "Runtime/mecanim/memory.h" +#include "AnimationClipBindings.h" +#include "PPtrKeyframes.h" + +#include "Motion.h" + +#if UNITY_EDITOR +#include "AnimationClipSettings.h" +#endif + +namespace mecanim +{ + namespace animation + { + struct ClipMuscleConstant; + struct ClipMuscleInput; + } +} + +struct AnimationClipStats; + +namespace Unity { class GameObject; } +using namespace Unity; + +class BaseAnimationTrack; +class NewAnimationTrack; +class MonoScript; +class Animation; +class AnimationState; +class CompressedAnimationCurve; + +/* + TODO: + * We currently don't handle double cover operator automatically for rotation curves + * We are not synchronizing animation state cached range correctly + * GetCurve is not implemented yet +*/ + +class AnimationClip : public Motion +{ +public: + struct QuaternionCurve + { + UnityStr path; + AnimationCurveQuat curve; + int hash; + + QuaternionCurve () { hash = 0; } + void CopyWithoutCurve(QuaternionCurve& other) const + { + other.path = path; + other.hash = hash; + } + + DECLARE_SERIALIZE (QuaternionCurve) + }; + + struct Vector3Curve + { + UnityStr path; + AnimationCurveVec3 curve; + int hash; + + Vector3Curve () { hash = 0; } + void CopyWithoutCurve(Vector3Curve& other) const + { + other.path = path; + other.hash = hash; + } + + DECLARE_SERIALIZE (Vector3Curve) + }; + +public: + + + struct PPtrCurve + { + UnityStr path; + UnityStr attribute; + int classID; + MonoScriptPPtr script; + PPtrKeyframes curve; + + PPtrCurve () { } + + DECLARE_SERIALIZE (PPtrCurve) + }; + + struct FloatCurve + { + UnityStr path; + UnityStr attribute; + int classID; + MonoScriptPPtr script; + AnimationCurve curve; + int hash; + + FloatCurve () { hash = 0; } + void CopyWithoutCurve(FloatCurve& other) const + { + other.path = path; + other.attribute = attribute; + other.classID = classID; + other.script = script; + other.hash = hash; + } + + DECLARE_SERIALIZE (FloatCurve) + }; + + typedef UNITY_VECTOR(kMemAnimation, QuaternionCurve) QuaternionCurves; + typedef UNITY_VECTOR(kMemAnimation, CompressedAnimationCurve) CompressedQuaternionCurves; + typedef UNITY_VECTOR(kMemAnimation, Vector3Curve) Vector3Curves; + typedef UNITY_VECTOR(kMemAnimation, FloatCurve) FloatCurves; + typedef UNITY_VECTOR(kMemAnimation, PPtrCurve) PPtrCurves; + typedef UNITY_VECTOR(kMemAnimation, AnimationEvent) Events; + + enum AnimationType + { + kLegacy = 1, + kGeneric = 2, + kHumanoid = 3 + }; + + + + REGISTER_DERIVED_CLASS (AnimationClip, Motion) + DECLARE_OBJECT_SERIALIZE (AnimationClip) + + static void InitializeClass (); + static void CleanupClass () { } + + AnimationClip (MemLabelId label, ObjectCreationMode mode); + // virtual ~AnimationClip(); declared-by-macro + + virtual void AwakeFromLoad(AwakeFromLoadMode mode); + virtual void CheckConsistency(); + + + /// Assigns curve to the curve defined by path, classID and attribute + /// If curve is null the exisiting curve will be removed. + void SetCurve (const std::string& path, int classID, MonoScriptPPtr script, const std::string& attribute, AnimationCurve* curve, bool syncEditorCurves); + bool GetCurve (const std::string& path, int classID, MonoScriptPPtr script, const std::string& attribute, AnimationCurve* outCurve); + + void ClearCurves (); + void EnsureQuaternionContinuity (); + + bool HasAnimationEvents (); + void FireAnimationEvents (float lastTime, float now, Unity::Component& source); + + #if UNITY_EDITOR + void SetEditorCurve (const std::string& path, int classID, MonoScriptPPtr script, const std::string& attribute, const AnimationCurve* curve, bool syncEditorCurves = true); + bool GetEditorCurve (const std::string& path, int classID, MonoScriptPPtr script, const std::string& attribute, AnimationCurve* outCurve); + FloatCurves& GetEditorCurvesSync(); + + void SetEditorPPtrCurve (const std::string& path, int classID, MonoScriptPPtr script, const std::string& attribute, PPtrKeyframes* keyframes); + bool GetEditorPPtrCurve (const std::string& path, int classID, MonoScriptPPtr script, const std::string& attribute, PPtrKeyframes* outKeyframes); + PPtrCurves& GetEditorPPtrCurves() { return m_PPtrCurves; } + + // Callback for telling animation window when an animclip got reloaded + typedef void OnAnimationClipAwake(AnimationClip* clip); + static void SetOnAnimationClipAwake (OnAnimationClipAwake *callback); + + void SyncEditorCurves(); + void SyncMuscleCurvesBackwardCompatibility(); + + void SetEvents (const AnimationEvent* events, int size, bool sort = false); + void ClearEvents (); + FloatCurves& GetEulerEditorCurves() { return m_EulerEditorCurves; } + virtual void CloneAdditionalEditorProperties (Object& src); + FloatCurves& GetEditorCurvesNoConversion () { return m_EditorCurves; } + + + const AnimationClipSettings& GetAnimationClipSettings() const { return m_AnimationClipSettings; } + void SetAnimationClipSettingsNoDirty (AnimationClipSettings &clipInfo); + void SetAnimationClipSettings (const AnimationClipSettings&clipInfo) { m_AnimationClipSettings = clipInfo; SetDirty(); } + + void GenerateMuscleClip(); + + void SetAnimationType (AnimationType type); + + + // overloads from Motion + virtual float GetAverageDuration(); + virtual float GetAverageAngularSpeed(); + virtual Vector3f GetAverageSpeed(); + virtual float GetApparentSpeed(); + + virtual bool ValidateIfRetargetable(bool showWarning = true); + virtual bool IsLooping(); + + #endif + + virtual bool IsAnimatorMotion()const; + + // Returns the smallest and largest keyframe time of any channel in the animation + // if no keyframes are contained make_pair (infinity, -infinity) is returned + std::pair<float, float> GetRange (); + + // Animation State support + typedef List< ListNode<AnimationState> > AnimationStateList; + typedef void DidModifyClipCallback(AnimationClip* clip, AnimationStateList& states); + + static void SetDidModifyClipCallback(DidModifyClipCallback* callback); + void AddAnimationState(ListNode<AnimationState>& node) { m_AnimationStates.push_back(node); } + + void SetSampleRate (float s); + float GetSampleRate () { return m_SampleRate; } + + void SetCompressionEnabled (bool s) { m_Compressed = s; } + bool GetCompressionEnabled () { return m_Compressed; } +#if UNITY_EDITOR + void SetUseHighQualityCurve (bool s) { m_UseHighQualityCurve = s; } + bool GetUseHighQualityCurve ()const { return m_UseHighQualityCurve; } +#endif + void SetWrapMode (int wrap) { m_WrapMode = wrap; SetDirty (); } + int GetWrapMode () { return m_WrapMode; } + + Events& GetEvents () { return m_Events; } + void AddRuntimeEvent (AnimationEvent& event); + + void AddRotationCurve (const AnimationCurveQuat& quat, const std::string& path); + void AddPositionCurve (const AnimationCurveVec3& quat, const std::string& path); + void AddScaleCurve (const AnimationCurveVec3& quat, const std::string& path); + void AddFloatCurve (const AnimationCurve& curve, const std::string& path, int classID, const std::string& attribute); + + QuaternionCurves& GetRotationCurves() { return m_RotationCurves; } + Vector3Curves& GetPositionCurves() { return m_PositionCurves; } + Vector3Curves& GetScaleCurves() { return m_ScaleCurves; } + FloatCurves& GetFloatCurves() { return m_FloatCurves; } + + const QuaternionCurves& GetRotationCurves() const { return m_RotationCurves; } + const Vector3Curves& GetPositionCurves() const { return m_PositionCurves; } + const Vector3Curves& GetScaleCurves() const { return m_ScaleCurves; } + const FloatCurves& GetFloatCurves() const { return m_FloatCurves; } + + void SetBounds(const AABB& bounds) { m_Bounds = bounds; SetDirty(); } + const AABB& GetBounds() const { return m_Bounds; } + + static void RevertAllPlaymodeAnimationEvents (); + + bool IsHumanMotion(); + + AnimationType GetAnimationType () const { return m_AnimationType; } + + + UnityEngine::Animation::AnimationClipBindingConstant* GetBindingConstant () { return &m_ClipBindingConstant; } + mecanim::animation::ClipMuscleConstant* GetRuntimeAsset(); + + void GetStats(AnimationClipStats& stats); + + void ClipWasModifiedAndUpdateMuscleRange (); + void UpdateMuscleClipRange (); + + +private: + void CompressCurves (CompressedQuaternionCurves& compressedRotationCurves); + void DecompressCurves (CompressedQuaternionCurves& compressedRotationCurves); + + void ClipWasModified (bool cleanupMecanimData = true); + + void ReloadEditorEulerCurves (const string& path); + void ReloadEditorQuaternionCurves (const string& path); + + void ConvertToNewCurveFormat (NewAnimationTrack& curves, int classID, const std::string& path); + void ConvertToNewCurveFormat (); + + void CleanupMecanimData(); + + mecanim::memory::ChainedAllocator m_ClipAllocator; + +private: + AnimationStateList m_AnimationStates; + + float m_SampleRate; + bool m_Compressed; + bool m_UseHighQualityCurve; + int m_WrapMode;///< enum { Default = 0, Once = 1, Loop = 2, PingPong = 4, ClampForever = 8 } + + QuaternionCurves m_RotationCurves; + Vector3Curves m_PositionCurves; + Vector3Curves m_ScaleCurves; + FloatCurves m_FloatCurves; + PPtrCurves m_PPtrCurves; + Events m_Events; + AnimationType m_AnimationType; + +#if UNITY_EDITOR + AnimationClipSettings m_AnimationClipSettings; +#endif//#if UNITY_EDITOR + + mecanim::animation::ClipMuscleConstant* m_MuscleClip; + mecanim::uint32_t m_MuscleClipSize; + UnityEngine::Animation::AnimationClipBindingConstant m_ClipBindingConstant; + + /// TODO: Serialiaze and do not compute it at all on startup + std::pair<float, float> m_CachedRange; + + AABB m_Bounds; + + #if UNITY_EDITOR + + // Keep a copy of events setup from edit mode so we can safely revert events after playmode + Events m_EditModeEvents; + FloatCurves m_EditorCurves; + FloatCurves m_EulerEditorCurves; + + struct ChildTrack + { + UnityStr path; + int classID; + PPtr<BaseAnimationTrack> track; + DECLARE_SERIALIZE (ChildTrack) + }; + + typedef vector_map<SInt32, PPtr<BaseAnimationTrack> > ClassIDToTrack; + typedef ClassIDToTrack::iterator iterator; + typedef std::vector<ChildTrack> ChildTracks; + typedef ChildTracks::iterator child_iterator; + + ClassIDToTrack m_ClassIDToTrack; + ChildTracks m_ChildTracks; + + friend class StripCurvesForMecanimClips; + + #endif + + friend class AnimationManager; +}; + +typedef std::vector<PPtr<AnimationClip> > AnimationClipVector; + +#endif |