diff options
Diffstat (limited to 'Runtime/Animation/Animation.cpp')
| -rw-r--r-- | Runtime/Animation/Animation.cpp | 2373 |
1 files changed, 2373 insertions, 0 deletions
diff --git a/Runtime/Animation/Animation.cpp b/Runtime/Animation/Animation.cpp new file mode 100644 index 0000000..a2d7cda --- /dev/null +++ b/Runtime/Animation/Animation.cpp @@ -0,0 +1,2373 @@ +#include "UnityPrefix.h" +#include "Animation.h" +#include "AnimationManager.h" +#include "AnimationClip.h" +#include "AnimationClipUtility.h" +#include "Runtime/Serialize/TransferFunctions/SerializeTransfer.h" +#include "Runtime/Serialize/TransferFunctions/TransferNameConversions.h" +#include "Runtime/BaseClasses/IsPlaying.h" +#include "Runtime/Utilities/Utility.h" +#include "AnimationBinder.h" +#include "NewAnimationTrack.h" +#include "AnimationState.h" +#include "Runtime/Input/TimeManager.h" +#include "Runtime/Graphics/Transform.h" +#include "Runtime/Profiler/Profiler.h" +#include "Runtime/Shaders/Material.h" +#include "AnimationCurveUtility.h" +#include "Runtime/Serialize/TransferUtility.h" +#include "Runtime/Mono/MonoScript.h" +#include "Runtime/Filters/Renderer.h" +#include "Runtime/Utilities/dense_hash_map.h" +#include "Runtime/Utilities/Prefetch.h" +#include "Runtime/Math/Rect.h" +#include "Runtime/Animation/AnimationUtility.h" +#include "Runtime/BaseClasses/EventIDs.h" + +using std::make_pair; +using std::max; + +PROFILER_INFORMATION (gBuildAnimationState, "Animation.RebuildInternalState", kProfilerAnimation); +PROFILER_INFORMATION (gUpdateAnimation, "Animation.Update", kProfilerAnimation); +PROFILER_INFORMATION (gSampleAnimation, "Animation.Sample", kProfilerAnimation); +PROFILER_WARNING (gDidDestroyObjectNotification, "Animation.DestroyAnimationClip [Triggers RebuildInternalState]", kProfilerAnimation); +PROFILER_WARNING (gAddClip, "Animation.AddClip [Triggers RebuildInternalState]", kProfilerAnimation); +PROFILER_WARNING (gRemoveClip, "Animation.RemoveClip [Triggers RebuildInternalState]", kProfilerAnimation); +PROFILER_WARNING (gCloneAnimationState, "Animation.Clone [Triggers RebuildInternalState]", kProfilerAnimation); +PROFILER_WARNING (gAnimationDeactivate, "Animation.Deactivate [Triggers RebuildInternalState]", kProfilerAnimation); +PROFILER_INFORMATION (gValidate, "ValidateBoundCurves", kProfilerAnimation); + +inline int CombineWrapMode (int clipWrapMode, int animationWrapMode) +{ + if (clipWrapMode != 0) + return clipWrapMode; + else + return animationWrapMode; +} + +Animation::Animation (MemLabelId label, ObjectCreationMode mode) +: Super(label, mode) +, m_AnimationManagerNode(this) +, m_ActiveAnimationStatesSize(0) +, m_CullingType(kCulling_AlwaysAnimate) +, m_BoundCurves (label) +{ + m_WrapMode = 0; + + m_PlayAutomatically = true; + m_AnimatePhysics = false; + m_DirtyMask = 0; + m_Visible = false; + memset (m_ActiveAnimationStates, 0, sizeof(m_ActiveAnimationStates)); +} + +Animation::~Animation () +{ + ClearContainedRenderers (); + ReleaseAnimationStates (); + CleanupBoundCurves(); +} + + +void Animation::AwakeFromLoad (AwakeFromLoadMode awakeMode) +{ + Super::AwakeFromLoad (awakeMode); + +#if UNITY_EDITOR + LoadOldAnimations(); +#endif + + // We don't know what kind of culling we used before, so we clear all culling related data + ClearContainedRenderers(); + + CheckIsCullingBasedOnBoundsDeprecated(); + + if (m_CullingType == kCulling_BasedOnRenderers && !m_AnimationStates.empty()) + RecomputeContainedRenderers (); + + if (m_PlayAutomatically && (awakeMode & (kDidLoadFromDisk | kInstantiateOrCreateFromCodeAwakeFromLoad | kActivateAwakeFromLoad)) && IsActive () && IsWorldPlaying()) + Play (kStopAll); +} + +void Animation::Deactivate (DeactivateOperation operation) +{ + if (operation != kDeprecatedDeactivateToggleForLevelLoad) + { + PROFILER_AUTO(gAnimationDeactivate, this) + //ReleaseAnimationStates (); + Stop(); + CleanupBoundCurves(); + } +} + +AnimationClip* Animation::GetClipWithNameSerialized (const std::string& name) +{ + for (Animations::iterator i=m_Animations.begin();i != m_Animations.end();i++) + { + AnimationClip* clip = *i; + if (clip && clip->GetName() == name) + return clip; + } + return NULL; +} + +void Animation::SetClip (PPtr<AnimationClip> anim) +{ + m_Animation = anim; + + SetDirty (); +} + +void Animation::SetClips (const Animations& anims) +{ + m_Animations = anims; + + CheckIsCullingBasedOnBoundsDeprecated(); + + SetDirty (); +} + +bool Animation::IsPlayingLayer (int layer) +{ + if (m_AnimationStates.empty ()) + return false; + + for (iterator i=begin();i != end();i++) + { + AnimationState& state = **i; + if (state.GetLayer() == layer && state.GetEnabled()) + return true; + } + + return false; +} + + +bool Animation::IsPlaying () +{ + if (m_AnimationStates.empty ()) + return false; + + for (iterator i=begin();i != end();i++) + { + AnimationState& state = **i; + if (state.GetEnabled()) + return true; + } + + return false; +} + +bool Animation::IsPlaying (const string& clip) +{ + AnimationState* state = GetState(clip); + + if ( state && state->GetEnabled() ) + return true; + else // check for clones + { + for ( int s = 0; s < m_AnimationStates.size(); s++ ) + { + AnimationState* st = m_AnimationStates[s]; + + if ( st->IsClone() + && st->GetParentName() == clip + && st->GetEnabled() ) + return true; + } + } + + return false; +} + + + +void Animation::Stop () +{ + for (iterator i=begin();i != end();i++) + { + (**i).Stop(); + } + + // Remove all queued animations. + m_Queued.clear(); +} + +void Animation::Stop( const string& name ) +{ + for ( int s = 0; s < m_AnimationStates.size(); s++ ) + { + AnimationState* state = m_AnimationStates[s]; + + bool stopState = false; + if ( state->IsClone() && state->GetParentName() == name ) + stopState = true; + else if ( !state->IsClone() && state->GetName() == name ) + stopState = true; + + if ( stopState ) + Stop( *state ); + } + + // Remove any queued animations that were cloned from the named state. + QueuedAnimations::iterator q, qnext; + for (q=m_Queued.begin();q != m_Queued.end();q=qnext) + { + qnext = q; + + if ( q->state->GetParentName() != name ) + qnext++; + else + m_Queued.erase( q ); + } + +} + +void Animation::Stop (AnimationState& state) +{ + state.Stop(); +} + +void Animation::Rewind () +{ + for (iterator i=begin();i != end();i++) + { + Rewind(**i); + } +} + +void Animation::Rewind (const string& name) +{ + if (!m_AnimationStates.empty()) + { + AnimationState* state = GetState(name); + if (state) + Rewind(*state); + } +} + +void Animation::Rewind (AnimationState& state) +{ + state.SetTime(0.0F); +} + +void Animation::SetWrapMode (int mode) +{ + m_WrapMode = mode; + for (iterator i=begin ();i != end ();i++) + { + AnimationState& state = **i; + state.SetWrapMode(mode); + } + SetDirty(); +} + +#if UNITY_EDITOR +/// Deprecated with 1.5 +void Animation::LoadOldAnimations () +{ + // Load old animations into new animation array + for (OldAnimations::iterator i=m_OldAnimations.begin ();i != m_OldAnimations.end ();i++) + { + AnimationClip* clip = i->second; + if (clip) + { + AddClip (*clip, i->first, INT_MIN, INT_MAX, false); + } + } + m_OldAnimations.clear(); + + + // Make sure we have the default animation in the animations list + AnimationClip* defaultAnim = m_Animation; + if (defaultAnim) + { + for (Animations::iterator i=m_Animations.begin();i!=m_Animations.end();i++) + { + if (*i == m_Animation) + return; + } + + AddClip (*defaultAnim, defaultAnim->GetName(), INT_MIN, INT_MAX, false); + } +} +#endif + +IMPLEMENT_CLASS_HAS_INIT (Animation) +IMPLEMENT_OBJECT_SERIALIZE (Animation) +///////////////////*************************** + +void Animation::AddToManager () +{ + // This method is named AddToManager, but it is used to remove from manager too... + m_AnimationManagerNode.RemoveFromList(); + if (IsWorldPlaying()) + { + if (GetEnabled() && (m_Visible || m_CullingType == kCulling_AlwaysAnimate) && IsActive() && !m_AnimationStates.empty()) + { + if (!m_AnimatePhysics) + GetAnimationManager().AddDynamic(m_AnimationManagerNode); + else + GetAnimationManager().AddFixed(m_AnimationManagerNode); + } + } + else + { + // Insert all in edit mode - for sampling animation with the timeline + if (IsActive()) + GetAnimationManager().AddDynamic(m_AnimationManagerNode); + } +} + +void Animation::RemoveFromManager () +{ + m_AnimationManagerNode.RemoveFromList(); +} + +void Animation::SetAnimatePhysics (bool anim) +{ + m_AnimatePhysics = anim; + SetDirty(); + if (m_AnimationManagerNode.IsInList()) + { + m_AnimationManagerNode.RemoveFromList(); + if (!m_AnimatePhysics) + GetAnimationManager().AddDynamic(m_AnimationManagerNode); + else + GetAnimationManager().AddFixed(m_AnimationManagerNode); + } +} + +#define ScriptErrorStringObject ErrorStringObject + +const char* kAnimationNotFoundError = +"The animation state %s could not be played because it couldn't be found!\n" +"Please attach an animation clip with the name '%s' or call this function only for existing animations."; +#define CANT_PLAY_ERROR { ScriptErrorStringObject(Format(kAnimationNotFoundError, name.c_str(), name.c_str()), this); } + + +const char* kWrongStateError = +"The animation state %s could not be played because it is not attached to the animation component!\n" +"You have to provide an animation state that is attached to the same animation component."; +#define WRONG_STATE_ERROR(x) { ScriptErrorStringObject(Format(kWrongStateError, x.GetName().c_str()), this); } + + +bool Animation::Play(const std::string& name, int playMode) +{ + // Deprecated support for play with queueing + if (playMode == kPlayQueuedDeprecated) + { + QueueCrossFade(name, 0.0F, CompleteOthers, kStopSameLayer); + return true; + } + + CrossFade(name, 0.0F, playMode); + return true; +} + +void Animation::Play(AnimationState& fadeIn, int playMode) +{ + // Deprecated support for play with queueing + if (playMode == kPlayQueuedDeprecated) + { + QueueCrossFade(fadeIn, 0.0F, CompleteOthers, kStopSameLayer); + return; + } + + CrossFade(fadeIn, 0.0F, playMode, true); + return; +} + + +bool Animation::Play (int mode) +{ + AnimationClip* clip = m_Animation; + if (clip) + { + AnimationState* state = GetState(clip); + if (state) + { + Play(*state, mode); + return true; + } + else + { + LogStringObject("Default clip could not be found in attached animations list.", this); + return false; + } + } + else + return false; +} + +void Animation::Blend(const std::string& name, float targetWeight, float time) { + AnimationState* state = GetState(name); + if (state) + Blend(*state, targetWeight, time); + else + CANT_PLAY_ERROR +} + +void Animation::CrossFade(const std::string& name, float time, int mode) { + AnimationState* state = GetState(name); + if (state) + CrossFade(*state, time, mode, true); + else + CANT_PLAY_ERROR +} + +AnimationState* Animation::QueueCrossFade(const std::string& name, float time, int queue, int mode) { + AnimationState* state = GetState(name); + if (state) + return QueueCrossFade(*state, time, queue, mode); + else + { + CANT_PLAY_ERROR + return NULL; + } +} + +/// - Should Blend and CrossFade Rewind animations before fading in? +/// - Should CrossFade Rewind animations after they are faded out? + +void Animation::Blend(AnimationState& playState, float targetWeight, float time) +{ + bool found = false; + for (iterator i=begin();i!=end();i++) + { + AnimationState& state = **i; + + if (&playState == &state) + { + state.SetEnabled(true); + state.SetWeightTarget(targetWeight, time, false); + state.SetupFadeout(time); + found = true; + } + } + if (!found) + WRONG_STATE_ERROR(playState) +} + +void Animation::CrossFade(AnimationState& playState, float time, int mode, bool clearQueuedAnimations ) +{ + bool found = false; + for (iterator i=begin();i!=end();i++) + { + AnimationState& state = **i; + + // Don't touch animations in other layers! + if ((mode & kStopAll) == 0 && state.GetLayer() != playState.GetLayer()) + continue; + + if (&playState == &state) + { + state.SetEnabled(true); + if (time > kReallySmallFadeTime) + state.SetWeightTarget(1.0F, time, false); + else + { + state.SetWeightTargetImmediate(1.0F, false); + } + + state.SetupFadeout(time); + found = true; + } + else + { + if (time > kReallySmallFadeTime) + state.SetWeightTarget(0.0F, time, true); + else + { + state.Stop(); + state.SetWeight(0.0F); + } + } + } + + if ( clearQueuedAnimations ) + { + // Clear out queued animations on the same channel as the state + // we are cross fading to or all queued animations if we are + // stopping all. + + // Fixed bug: https://fogbugz.unity3d.com/default.asp?470484, on metro std vector are somehow implemented differently + // If you remove an element from the list, you have to reinitialize all the iterators, to fix the problem, I removed iterators at all + for (int i = 0; i < m_Queued.size();) + { + if ( !(mode & kStopAll) && m_Queued[i].state->GetLayer() != playState.GetLayer() ) + { + i++; + continue; + } + + m_Queued[i].state->Stop(); + m_Queued[i].state->ForceAutoCleanup(); + m_Queued.erase(m_Queued.begin() + i); + } + } + + if ( !found ) + WRONG_STATE_ERROR(playState) +} + +AnimationState* Animation::QueueCrossFade(AnimationState& originalState, float time, int queueMode, int mode) +{ + AnimationState* cloned = CloneAnimation(&originalState); + if (!cloned) + { + WRONG_STATE_ERROR(originalState) + return NULL; + } + + AnimationState& playState = *cloned; + playState.SetAutoCleanup(); + + // Queue the animation for real! + if (queueMode == CompleteOthers) + { + QueuedAnimation queue; + queue.mode = mode; + queue.queue = queueMode; + queue.fadeTime = time; + queue.state = &playState; + m_Queued.push_back(queue); + return &playState; + } + else + { + CrossFade(playState, time, mode, true); + return &playState; + } +} + +/// * All animation states have an array with pointers to the curves used when sampling. (AnimationState.m_Curves) +/// The index in the AnimationState.m_Curves is the same as the BoundCurves index. +/// If a curve is not available or excluded because of mixing the pointer is NULL. + +void InsertAnimationClipCurveIDs(AnimationBinder::CurveIDLookup& curveIDLookup, AnimationClip& clip) +{ + AnimationClip::QuaternionCurves& rot = clip.GetRotationCurves(); + AnimationClip::Vector3Curves& pos = clip.GetPositionCurves(); + AnimationClip::Vector3Curves& scale = clip.GetScaleCurves(); + AnimationClip::FloatCurves& floats = clip.GetFloatCurves(); + CurveID curveID; + + for (AnimationClip::QuaternionCurves::iterator i=rot.begin();i != rot.end();i++) + { + AnimationClip::QuaternionCurve& element = *i; + + curveID = CurveID (element.path.c_str(), ClassID(Transform), NULL, "m_LocalRotation", element.hash); + if (element.hash == 0) + { + curveID.CalculateHash(); + element.hash = curveID.hash; + } + + AnimationBinder::InsertCurveIDIntoLookup(curveIDLookup, curveID); + } + + for (AnimationClip::Vector3Curves::iterator i=pos.begin();i != pos.end();i++) + { + AnimationClip::Vector3Curve& element = *i; + + curveID = CurveID (element.path.c_str(), ClassID(Transform), NULL, "m_LocalPosition", element.hash); + if (element.hash == 0) + { + curveID.CalculateHash(); + element.hash = curveID.hash; + } + AnimationBinder::InsertCurveIDIntoLookup(curveIDLookup, curveID); + } + + for (AnimationClip::Vector3Curves::iterator i=scale.begin();i != scale.end();i++) + { + AnimationClip::Vector3Curve& element = *i; + + curveID = CurveID (element.path.c_str(), ClassID(Transform), NULL, "m_LocalScale", element.hash); + if (element.hash == 0) + { + curveID.CalculateHash(); + element.hash = curveID.hash; + } + + + AnimationBinder::InsertCurveIDIntoLookup(curveIDLookup, curveID); + } + + for (AnimationClip::FloatCurves::iterator i=floats.begin();i != floats.end();i++) + { + AnimationClip::FloatCurve& element = *i; + curveID = CurveID (element.path.c_str(), element.classID, element.script, element.attribute.c_str(), element.hash); + if (element.hash == 0) + { + curveID.CalculateHash(); + element.hash = curveID.hash; + } + + AnimationBinder::InsertCurveIDIntoLookup(curveIDLookup, curveID); + } +} + +static bool IsMixedIn (const Animation::BoundCurves& boundCurves, int index, AnimationState& state) +{ + // We only mix transform animation + if (boundCurves[index].targetType == kBindTransformRotation || boundCurves[index].targetType == kBindTransformPosition || boundCurves[index].targetType == kBindTransformScale) + { + DebugAssertIf(dynamic_pptr_cast<Transform*> (boundCurves[index].targetObject) == NULL); + Transform* transform = static_cast<Transform*> (boundCurves[index].targetObject); + + return state.ShouldMixTransform(*transform); + } + return true; +} + + +static void AssignBoundCurve (const AnimationBinder::CurveIDLookup& curveIDLookup, const CurveID& curveID, AnimationCurveBase* curve, const Animation::BoundCurves& boundCurves, AnimationState& state) +{ + AnimationBinder::CurveIDLookup::const_iterator found; + found = curveIDLookup.find(curveID); + if (found == curveIDLookup.end()) + return; + + if (!IsMixedIn (boundCurves, found->second, state)) + return; + + AnimationState::Curves curves = state.GetCurves(); + curves[found->second] = curve; +} + +static void CalculateAnimationClipCurves (const AnimationBinder::CurveIDLookup& curveIDLookup, AnimationClip& clip, const Animation::BoundCurves& boundCurves, AnimationState& state) +{ + AnimationClip::QuaternionCurves& rot = clip.GetRotationCurves(); + AnimationClip::Vector3Curves& pos = clip.GetPositionCurves(); + AnimationClip::Vector3Curves& scale = clip.GetScaleCurves(); + AnimationClip::FloatCurves& floats = clip.GetFloatCurves(); + + CurveID curveID; + + for (AnimationClip::QuaternionCurves::iterator i=rot.begin();i != rot.end();i++) + { + if (!i->curve.IsValid ()) + continue; + AssertIf(i->hash == 0); + curveID = CurveID (i->path.c_str(), ClassID(Transform), NULL, "m_LocalRotation", i->hash); + AssignBoundCurve(curveIDLookup, curveID, (AnimationCurveBase*)&i->curve, boundCurves, state); + } + + for (AnimationClip::Vector3Curves::iterator i=pos.begin();i != pos.end();i++) + { + if (!i->curve.IsValid ()) + continue; + + AssertIf(i->hash == 0); + curveID = CurveID (i->path.c_str(), ClassID(Transform), NULL, "m_LocalPosition", i->hash); + AssignBoundCurve(curveIDLookup, curveID, (AnimationCurveBase*)&i->curve, boundCurves, state); + } + + for (AnimationClip::Vector3Curves::iterator i=scale.begin();i != scale.end();i++) + { + if (!i->curve.IsValid ()) + continue; + + AssertIf(i->hash == 0); + curveID = CurveID (i->path.c_str(), ClassID(Transform), NULL, "m_LocalScale", i->hash); + AssignBoundCurve(curveIDLookup, curveID, (AnimationCurveBase*)&i->curve, boundCurves, state); + } + + for (AnimationClip::FloatCurves::iterator i=floats.begin();i != floats.end();i++) + { + if (!i->curve.IsValid ()) + continue; + + AssertIf(i->hash == 0); + curveID = CurveID (i->path.c_str(), i->classID, i->script, i->attribute.c_str(), i->hash); + AssignBoundCurve(curveIDLookup, curveID, (AnimationCurveBase*)&i->curve, boundCurves, state); + } +} + +void Animation::ValidateBoundCurves () +{ + PROFILER_AUTO(gValidate, this); + BoundCurves::const_iterator end = m_BoundCurves.end(); + for (BoundCurves::const_iterator i=m_BoundCurves.begin(); i != end; ++i) + { + const BoundCurveDeprecated& bound = *i; + +#if 0 + // We are accessing potentially deleted memory and validating it if the instanceID matches. + // This is unsafe, but will work in almost all cases. ValidateBoundCurves does not trigger in normal circumstances. + // Yet we have to pay a large cost for the safety provided... This seems not fair. + if (bound.targetObject->GetInstanceID () != bound.targetInstanceID) +#else + if (Object::IDToPointer(bound.targetInstanceID) != bound.targetObject) +#endif + { + PROFILER_AUTO(gDidDestroyObjectNotification, this); + CleanupBoundCurves (); + return; + } + } +} + +void Animation::CleanupBoundCurves () +{ + if (m_BoundCurves.empty ()) + { + return; + } + + m_BoundCurves.clear(); + m_DirtyMask |= kRebindDirtyMask; +} + + +void Animation::RebuildStateForEverything () +{ + PROFILER_AUTO(gBuildAnimationState, this) + + //@TODO: we should make sure that the curves are aligned for better cache utilization + // -> Simply modify curveIDLookup::iterator->second to be in the right cache order, after building the curveIDLookup! + // Possibly caching is already pretty good if the first curve contains all curves! + + AnimationBinder::CurveIDLookup curveIDLookup; + AnimationBinder::InitCurveIDLookup(curveIDLookup); + + /// Build curveIDLookup + /// * walk through all animation states and insert the curve into curveIDLookup + /// * curveCount gets increased when we encounter a new curve + CurveID curveID ("", 0, NULL, "", 0); + AnimationState* state; + AnimationBinder::CurveIDLookup::iterator found; + + string attribute; + + Transform* transform = QueryComponent (Transform); + + if (transform) + { + for (int s=0;s<m_AnimationStates.size();s++) + { + state = m_AnimationStates[s]; + AnimationClip* clip = state->m_Clip; + if (clip == NULL) + continue; + + InsertAnimationClipCurveIDs(curveIDLookup, *clip); + } + + // Bind the global curves. + GetAnimationBinder().BindCurves(curveIDLookup, *transform, m_BoundCurves, m_CachedAffectedSendToRootTransform, m_CachedTransformMessageMask); + + // This will compact any curves that couldn't be bound + // - Faster at runtime (Can remove some ifs) + // - Slower at load time + AnimationBinder::RemoveUnboundCurves(curveIDLookup, m_BoundCurves); + + + /// * Build state.m_Curves arrays + /// - We go through all curves in the every state/clip look it up in the curve map + for (int s=0;s<m_AnimationStates.size();s++) + { + state = m_AnimationStates[s]; + // Initialize all states to have no curves assigned + // Those that aren't used or excluded for mixing will remain null after this loop + state->CleanupCurves(); + state->AllocateCurves(curveIDLookup.size()); + + AnimationClip* clip = state->m_Clip; + if (clip == NULL) + continue; + + CalculateAnimationClipCurves(curveIDLookup, *clip, m_BoundCurves, *state); + } + } + + // Force Bound curves mask recalculation + m_ActiveAnimationStatesSize = 0; + + m_DirtyMask &= ~kRebindDirtyMask; +} + +inline float InverseWeight(float weight) +{ + return weight > kReallySmallWeight ? (1.0F / weight) : 0.0F; +} + +/*** This calculates the blend weights for one curve. + +Weights are distributed so that the top layer gets everything. +If it doesn't use the full weight then the next layer gets to distribute the remaining +weights and so on. Once all weights are used by the top layers, +no weights will be available for lower layers anymore +We use fair weighting, which means if a lower layer wants 80% and 50% have already been used up, the layer will NOT use up all weights. +instead it will take up 80% of the 50%. + +Example: +a upper body which is affected by wave, walk and idle +a lower body which is affected by only walk and idle + +weight name layer lower upper + 20% wave 2 0% 20% + 50% walk 1 50% 40% + 100% idle 0 50% 40% + +- Blend weights can change per animated value because of mixing. + Even without mixing, sometimes a curve is just not defined. Still you want the blend weights to add up to 1. + Most of the time weights are similar between curves. So there is a lot of caching one can do. +*/ + +// We use fair weighting, which means if a lower layer wants 80% and 50% have already been used up, the layer will NOT use up all weights. +// Instead it will take up 80% of the 50%. +#define FAIR_DISTRIBUTION 1 + +template<bool optimize32States> +void CalculateWeights( AnimationState** states, int stateCount, int curveIndex, OUTPUT_OPTIONAL float* outWeights, int mask ) +{ + Assert( outWeights != NULL ); + + // state index -> layer index + int* layerIndices; + ALLOC_TEMP(layerIndices, int, stateCount); + // summed weights for each layer - we'll never have more layers than affectors + float* layerSummedWeights; + ALLOC_TEMP(layerSummedWeights, float, stateCount); + + const AnimationState* state = states[0]; + int prevLayer = state->GetLayer(); + int layerIndex = 0; + + // Clear summed layer weights + for( int i = 0; i < stateCount; ++i ) + layerSummedWeights[i] = 0.0F; + + // sum weights for each layer + UInt32 stateBit = 1; + for( int i = 0; i < stateCount; ++i ) + { + if (optimize32States) + { + if (mask & stateBit) + { + state = states[i]; + + AssertIf( prevLayer < state->GetLayer()); // Algorithm requires sorted states by layer + + if( prevLayer != state->GetLayer() ) + ++layerIndex; + + layerSummedWeights[layerIndex] += state->GetWeight(); + layerIndices[i] = layerIndex; + outWeights[i] = state->GetWeight(); + } + else + { + outWeights[i] = 0.0F; + layerIndices[i] = 0; + } + } + else + { + state = states[i]; + if (state->ShouldUse() && state->GetCurves()[curveIndex] != NULL && state->GetBlendMode() == AnimationState::kBlend) + { + AssertIf( prevLayer < state->GetLayer()); // Algorithm requires sorted states by layer + + if( prevLayer != state->GetLayer() ) + ++layerIndex; + + layerSummedWeights[layerIndex] += state->GetWeight(); + layerIndices[i] = layerIndex; + outWeights[i] = state->GetWeight(); + } + else + { + outWeights[i] = 0.0F; + layerIndices[i] = 0; + } + } + stateBit <<= 1; + prevLayer = states[i]->GetLayer(); + } + int layerCount = layerIndex + 1; + + // Distribute weights so that the top layers get everything up to 1. + // If they use less, the remainder goes to the lower layers. + float* layerInvSummedWeights; + ALLOC_TEMP(layerInvSummedWeights, float, stateCount); + float remainderWeight = 1.0F; + for( int i = 0; i < layerCount; ++i ) + { + float layerWeight = max(1.0F, layerSummedWeights[i]); + + layerInvSummedWeights[i] = InverseWeight(layerWeight) * remainderWeight; + + #if FAIR_DISTRIBUTION + remainderWeight -= layerSummedWeights[i] * remainderWeight; + #else + remainderWeight -= layerSummedWeights[i]; + #endif + + remainderWeight = max(0.0F, remainderWeight); + } + + // - Apply the layer inverse weights + // - Normalize the weights once again, just in case + + // @TODO: Renormalization is only necessary if the remainderWeight is larger than zero as far as i can see + float summedWeight = 0.0F; + for( int i = 0; i < stateCount; ++i ) + { + outWeights[i] *= layerInvSummedWeights[layerIndices[i]]; + summedWeight += outWeights[i]; + } + + summedWeight = InverseWeight(summedWeight); + for( int i = 0; i < stateCount; ++i ) + outWeights[i] *= summedWeight; +} + +void Animation::SampleDefaultClip (double time) +{ + AnimationClip* clip = m_Animation; + if (!clip) + return; + + SampleAnimation(GetGameObject(), *clip, time, CombineWrapMode(clip->GetWrapMode(), m_WrapMode)); +} + +// Calculates a bitmask for every bound curve, containing which curve state affects it. +// - The recalculation is only necessary if a state got enabled or disabled (Either through manually disabling it or through a too low blend weight) +bool Animation::RebuildBoundStateMask() +{ + int activeStateCount = 0; + bool requireRebuild = false; + int s; + for (s=0;s<m_AnimationStates.size() && activeStateCount < 32;s++) + { + AnimationState& state = *m_AnimationStates[s]; + if (state.ShouldUse() && state.GetBlendMode() == AnimationState::kBlend) + { + requireRebuild |= m_ActiveAnimationStates[activeStateCount] != &state; + m_ActiveAnimationStates[activeStateCount] = &state; + DebugAssertIf(activeStateCount != 0 && m_ActiveAnimationStates[activeStateCount-1]->GetLayer() < m_ActiveAnimationStates[activeStateCount]->GetLayer()); + activeStateCount++; + } + } + + // Too many active animation states + if (s != m_AnimationStates.size()) + return false; + + requireRebuild |= activeStateCount != m_ActiveAnimationStatesSize; + // early out if nothing in which animations are currently playing has changed. + if (!requireRebuild) + return true; + + m_ActiveAnimationStatesSize = activeStateCount; + + for (int i=0;i<m_BoundCurves.size();i++) + { + m_BoundCurves[i].affectedStateMask = 0; + for (int s=0;s<m_ActiveAnimationStatesSize;s++) + { + AnimationState& state = *m_ActiveAnimationStates[s]; + if (state.m_Curves[i]) + m_BoundCurves[i].affectedStateMask |= 1 << s; + } + } + + return true; +} + +inline void AwakeAndDirty (Object* o) +{ + if (o) + { + o->AwakeFromLoad(kDefaultAwakeFromLoad); + o->SetDirty(); + } +} + +static void UpdateLastNonTransformObject(Object*& lastNonTransformObject, Object* const targetObject) +{ + if (lastNonTransformObject != targetObject) + { + AwakeAndDirty(lastNonTransformObject); + lastNonTransformObject = targetObject; + } +} + +// Optimized for 32 animation states +void Animation::BlendOptimized() +{ + AssertIf(m_BoundCurves.empty()); + + ///@TODO: Keep a cache for all curves and pass it into animationcurve.Evaluate. + // So that many characters dont kill the cache of shared animation curves. + + int curveCount = m_BoundCurves.size(); + + AnimationState** activeStates = m_ActiveAnimationStates; + int stateSize = m_ActiveAnimationStatesSize; + float* weights; + ALLOC_TEMP(weights, float, stateSize); + + float weight; + const AnimationState* state; + + Object* lastNonTransformObject = NULL; + UInt32 lastAffectedStateMask = m_BoundCurves[0].affectedStateMask; + CalculateWeights<true>(activeStates, stateSize, 0, weights, lastAffectedStateMask); + BoundCurveDeprecated* boundCurves = &m_BoundCurves[0]; + + for( int c = 0; c < curveCount; ++c ) + { + BoundCurveDeprecated& bind = boundCurves[c]; + + // Only recalculate weights if the state mask changes! + // This happens very rarely. (If you dont use mixing it never happens) + if (lastAffectedStateMask != bind.affectedStateMask) + { + lastAffectedStateMask = bind.affectedStateMask; + CalculateWeights<true>(activeStates, stateSize, c, weights, lastAffectedStateMask); + } + + if (lastAffectedStateMask == 0) + continue; + + const UInt32 targetType = bind.targetType; + + // Sample quaternion + if (targetType == kBindTransformRotation) + { + Prefetch(bind.targetPtr); + Quaternionf& result = *(Quaternionf*)bind.targetPtr; + result.Set(0,0,0,0); + UInt32 stateBit = 1; + for (int i=0;i<stateSize;i++) + { + if (lastAffectedStateMask & stateBit) + { + state = activeStates[i]; + const AnimationCurveQuat* quatCurve = reinterpret_cast<AnimationCurveQuat*>(state->GetCurves()[c]); + + Quaternionf sample = quatCurve->EvaluateClamp(state->m_WrappedTime); + DebugAssertIf(!IsFinite(sample)); + + /// Not necessary because we make sure when sampling that our curves are sampled and almost normalized + /// @todo: If people animate inside unity this might be a problem. + /// Hopefully no one does that in combination with blending. + // sample = NormalizeFastEpsilonZero(sample); + result += Sign(Dot (sample, result)) * sample * weights[i]; + } + stateBit <<= 1; + } + + result = NormalizeSafe(result); + DebugAssertIf(!IsFinite(result)); + } + // Sample vector 3 + else if (targetType == kBindTransformPosition) + { + Vector3f result = Vector3f(0.0F, 0.0F, 0.0F); + UInt32 stateBit = 1; + for (int i=0;i<stateSize;i++) + { + if (lastAffectedStateMask & stateBit) + { + state = activeStates[i]; + const AnimationCurveVec3* vec3Curve = reinterpret_cast<AnimationCurveVec3*>(state->GetCurves()[c]); + + Vector3f sample = vec3Curve->EvaluateClamp(state->m_WrappedTime); + weight = weights[i]; + result += sample * weight; + } + stateBit <<= 1; + } + + DebugAssertIf(!IsFinite(result)); + *reinterpret_cast<Vector3f*>(bind.targetPtr) = result; + } + else if (targetType == kBindTransformScale) + { + Vector3f result = Vector3f(0.0F, 0.0F, 0.0F); + UInt32 stateBit = 1; + for (int i=0;i<stateSize;i++) + { + if (lastAffectedStateMask & stateBit) + { + state = activeStates[i]; + const AnimationCurveVec3* vec3Curve = reinterpret_cast<AnimationCurveVec3*>(state->GetCurves()[c]); + + Vector3f sample = vec3Curve->EvaluateClamp(state->m_WrappedTime); + weight = weights[i]; + result += sample * weight; + } + stateBit <<= 1; + } + + DebugAssertIf(!IsFinite(result)); + *reinterpret_cast<Vector3f*>(bind.targetPtr) = result; + Transform* targetTransform = reinterpret_cast<Transform*> (bind.targetObject); + targetTransform->RecalculateTransformType (); + } + // Sample float + else if (targetType > kUnbound) + { + float result = 0.0F; + UInt32 stateBit = 1; + for (int i=0;i<stateSize;i++) + { + if (lastAffectedStateMask & stateBit) + { + state = activeStates[i]; + const AnimationCurve* floatCurve = reinterpret_cast<AnimationCurve*>(state->GetCurves()[c]); + + float sample = floatCurve->EvaluateClamp(state->m_WrappedTime); + weight = weights[i]; + result += sample * weight; + } + stateBit <<= 1; + } + + DebugAssertIf(!IsFinite(result)); + + AnimationBinder::SetFloatValue(bind, result); + + if (AnimationBinder::ShouldAwakeGeneric (bind)) + UpdateLastNonTransformObject(lastNonTransformObject, bind.targetObject); + + } + else + { + #if COMPACT_UNBOUND_CURVES + AssertString("Unbound curves should be compacted!"); + #endif + continue; + } + + } + + AwakeAndDirty(lastNonTransformObject); +} + + +// Unlimited amount of animation states +void Animation::BlendGeneric() +{ + AssertIf(m_BoundCurves.empty()); + + ///@TODO: Keep a cache for all curves and pass it into animationcurve.Evaluate. + // So that many characters dont kill the cache of shared animation curves. + + int curveCount = m_BoundCurves.size(); + + int stateSize = m_AnimationStates.size(); + float* weights; + ALLOC_TEMP(weights, float, stateSize); + + float weight; + const AnimationState* state; + + Object* lastNonTransformObject = NULL; + for( int c = 0; c < curveCount; ++c ) + { + BoundCurveDeprecated& bind = m_BoundCurves[c]; + + CalculateWeights<false>(&m_AnimationStates[0], stateSize, c, weights, 0); + + bool didSample = false; + + int targetType = bind.targetType; + + // Sample quaternion + if (targetType == kBindTransformRotation) + { + Quaternionf result = Quaternionf(0.0F, 0.0F, 0.0F, 0.0F); + + for (int i=0;i<stateSize;i++) + { + state = m_AnimationStates[i]; + const AnimationCurveQuat* quatCurve = reinterpret_cast<AnimationCurveQuat*>(state->GetCurves()[c]); + if (quatCurve && weights[i] > kReallySmallWeight) + { + Quaternionf sample = quatCurve->EvaluateClamp(state->m_WrappedTime); + + /// Not necessary because we make sure when sampling that our curves are sampled and almost normalized + /// @todo: If people animate inside unity this might be a problem. + /// Hopefully no one does that in combination with blending. + + // sample = NormalizeFastEpsilonZero(sample); + weight = weights[i]; + if (Dot (sample, result) < 0.0F) + weight = -weight; + result += sample * weight; + didSample = true; + } + } + + result = NormalizeSafe(result); + DebugAssertIf(!IsFinite(result)); + if (didSample) + *reinterpret_cast<Quaternionf*>(bind.targetPtr) = result; + } + // Sample vector 3 + else if (targetType == kBindTransformPosition) + { + Vector3f result = Vector3f(0.0F, 0.0F, 0.0F); + for (int i=0;i<stateSize;i++) + { + state = m_AnimationStates[i]; + const AnimationCurveVec3* vec3Curve = reinterpret_cast<AnimationCurveVec3*>(state->GetCurves()[c]); + if (vec3Curve && weights[i] > kReallySmallWeight) + { + Vector3f sample = vec3Curve->EvaluateClamp(state->m_WrappedTime); + weight = weights[i]; + result += sample * weight; + didSample = true; + } + } + + DebugAssertIf(!IsFinite(result)); + if (didSample) + { + *reinterpret_cast<Vector3f*>(bind.targetPtr) = result; + } + } + // Sample vector 3 + else if (targetType == kBindTransformScale) + { + Vector3f result = Vector3f(0.0F, 0.0F, 0.0F); + for (int i=0;i<stateSize;i++) + { + state = m_AnimationStates[i]; + const AnimationCurveVec3* vec3Curve = reinterpret_cast<AnimationCurveVec3*>(state->GetCurves()[c]); + if (vec3Curve && weights[i] > kReallySmallWeight) + { + Vector3f sample = vec3Curve->EvaluateClamp(state->m_WrappedTime); + weight = weights[i]; + result += sample * weight; + didSample = true; + } + } + + DebugAssertIf(!IsFinite(result)); + + if (didSample) + { + *reinterpret_cast<Vector3f*>(bind.targetPtr) = result; + Transform* targetTransform = reinterpret_cast<Transform*> (bind.targetObject); + targetTransform->RecalculateTransformType (); + } + } + // Sample float + else if (targetType > kUnbound) + { + float result = 0.0F; + for (int i=0;i<stateSize;i++) + { + state = m_AnimationStates[i]; + const AnimationCurve* floatCurve = reinterpret_cast<AnimationCurve*>(state->GetCurves()[c]); + if (floatCurve && weights[i] > kReallySmallWeight) + { + float sample = floatCurve->EvaluateClamp(state->m_WrappedTime); + weight = weights[i]; + result += sample * weight; + didSample = true; + } + } + + DebugAssertIf(!IsFinite(result)); + + if (didSample) + { + AnimationBinder::SetFloatValue(bind, result); + + if (AnimationBinder::ShouldAwakeGeneric (bind)) + UpdateLastNonTransformObject(lastNonTransformObject, bind.targetObject); + } + } + else + { + #if COMPACT_UNBOUND_CURVES + AssertString("Unbound curves should be compacted!"); + #endif + continue; + } + + } + + AwakeAndDirty(lastNonTransformObject); +} + +void Animation::BlendAdditive() +{ + AssertIf(m_BoundCurves.empty()); + int stateSize = m_AnimationStates.size(); + AnimationState* state; + + AnimationState** activeStates; + ALLOC_TEMP(activeStates, AnimationState*, stateSize); + int activeStateSize = 0; + + ///@TODO: We can also compare if the current time matches the first frame, then the animation has no effect! + for (int i=0;i<stateSize;i++) + { + state = m_AnimationStates[i]; + if (state->GetBlendMode() == AnimationState::kAdditive && state->ShouldUse ()) + { + activeStates[activeStateSize] = state; + activeStateSize++; + } + } + // early out if we have no additive animations playing + if (activeStateSize == 0) + return; + + int curveCount = m_BoundCurves.size(); + BoundCurveDeprecated* boundCurves = &m_BoundCurves[0]; +// float* weights; +// ALLOC_TEMP(weights, float, stateSize, kMemAnimation); +// float* time; +// ALLOC_TEMP(time, float, stateSize, kMemAnimation); + + float weight; + + Object* lastNonTransformObject = NULL; + for( int c = 0; c < curveCount; ++c ) + { + BoundCurveDeprecated& bind = boundCurves[c]; + + bool didSample = false; + + int targetType = bind.targetType; + + // Sample quaternion + if (targetType == kBindTransformRotation) + { + Quaternionf result = *reinterpret_cast<Quaternionf*>(bind.targetPtr); + + for (int i=0;i<activeStateSize;i++) + { + state = activeStates[i]; + weight = clamp01 (state->GetWeight()); + const AnimationCurveQuat* quatCurve = reinterpret_cast<AnimationCurveQuat*>(state->GetCurves()[c]); + if (quatCurve) + { + Quaternionf sample = Inverse(quatCurve->GetKey(0).value) * quatCurve->EvaluateClamp(state->m_WrappedTime); + sample = Lerp(Quaternionf::identity(), sample, weight); + result *= sample; + didSample = true; + } + } + + result = NormalizeSafe(result); + DebugAssertIf(!IsFinite(result)); + if (didSample) + *reinterpret_cast<Quaternionf*>(bind.targetPtr) = result; + } + // Sample vector 3 + else if (targetType == kBindTransformPosition) + { + Vector3f result = *reinterpret_cast<Vector3f*>(bind.targetPtr); + + for (int i=0;i<activeStateSize;i++) + { + state = activeStates[i]; + weight = clamp01 (state->GetWeight()); + const AnimationCurveVec3* vec3Curve = reinterpret_cast<AnimationCurveVec3*>(state->GetCurves()[c]); + + if (vec3Curve) + { + Vector3f sample = vec3Curve->EvaluateClamp(state->m_WrappedTime) - vec3Curve->GetKey(0).value; + result += sample * weight; + didSample = true; + } + } + DebugAssertIf(!IsFinite(result)); + if (didSample) + *reinterpret_cast<Vector3f*>(bind.targetPtr) = result; + } + // Sample vector 3 + else if (targetType == kBindTransformScale) + { + Vector3f result = *reinterpret_cast<Vector3f*>(bind.targetPtr); + + for (int i=0;i<activeStateSize;i++) + { + state = activeStates[i]; + weight = clamp01 (state->GetWeight()); + const AnimationCurveVec3* vec3Curve = reinterpret_cast<AnimationCurveVec3*>(state->GetCurves()[c]); + + if (vec3Curve) + { + Vector3f sample = vec3Curve->EvaluateClamp(state->m_WrappedTime) - vec3Curve->GetKey(0).value; + result += sample * weight; + didSample = true; + } + } + DebugAssertIf(!IsFinite(result)); + if (didSample) + { + *reinterpret_cast<Vector3f*>(bind.targetPtr) = result; + Transform* targetTransform = reinterpret_cast<Transform*> (bind.targetObject); + targetTransform->RecalculateTransformType (); + } + } + } + + AwakeAndDirty(lastNonTransformObject); +} + +inline Animation::CullingType RemapDeprecatedCullingType (Animation::CullingType type) +{ + if (type == Animation::kDeprecatedCulling_BasedOnClipBounds || type == Animation::kDeprecatedCulling_BasedOnUserBounds) + return Animation::kCulling_BasedOnRenderers; + else + return type; +} + +void Animation::SetCullingType(CullingType type) +{ + type = RemapDeprecatedCullingType(type); + + CheckIsCullingBasedOnBoundsDeprecated (); + + // Clearing culling related data + if (m_CullingType == kCulling_BasedOnRenderers) + { + ClearContainedRenderers(); + } + else if (m_CullingType == kCulling_AlwaysAnimate) + RemoveFromManager(); + + m_CullingType = type; + + // Building new culling data + if (m_CullingType == kCulling_BasedOnRenderers && !m_AnimationStates.empty()) + RecomputeContainedRenderers (); + else if (m_CullingType == kCulling_AlwaysAnimate && !m_AnimationManagerNode.IsInList()) + AddToManager(); + + SetDirty(); +} + +void Animation::RemoveContainedRenderer (Renderer* renderer) +{ + ContainedRenderers::iterator end = m_ContainedRenderers.end(); + for (ContainedRenderers::iterator i = m_ContainedRenderers.begin();i != end;++i) + { + Renderer* cur = *i; + if (cur == renderer) + { + *i = m_ContainedRenderers.back(); + m_ContainedRenderers.resize(m_ContainedRenderers.size() - 1); + return; + } + } +} + +static void AnimationVisibilityCallback (void* userData, void* senderUserData, int visibilityEvent) +{ + Animation& animation = *reinterpret_cast<Animation*> (userData); + + if (visibilityEvent == kBecameVisibleEvent) + animation.SetVisibleRenderers(true); + else if (visibilityEvent == kBecameInvisibleEvent) + animation.CheckRendererVisibleState (); + else if (visibilityEvent == kWillDestroyEvent) + { + animation.RemoveContainedRenderer(reinterpret_cast<Renderer*> (senderUserData)); + + animation.CheckRendererVisibleState (); + } +} + +void Animation::ClearContainedRenderers () +{ + ContainedRenderers::iterator end = m_ContainedRenderers.end(); + for (ContainedRenderers::iterator i = m_ContainedRenderers.begin();i != end;++i) + { + Renderer* renderer = *i; + renderer->RemoveEvent(AnimationVisibilityCallback, this); + } + m_ContainedRenderers.clear(); +} + +void Animation::RecomputeContainedRenderers () +{ + Assert(m_CullingType == kCulling_BasedOnRenderers); + + ClearContainedRenderers (); + + Transform& transform = GetComponent (Transform); + RecomputeContainedRenderersRecurse(transform); + + Assert(m_CullingType == kCulling_BasedOnRenderers); + + CheckRendererVisibleState (); +} + +void Animation::CheckRendererVisibleState () +{ + Assert(m_CullingType == kCulling_BasedOnRenderers); + + ContainedRenderers::iterator end = m_ContainedRenderers.end(); + for (ContainedRenderers::iterator i = m_ContainedRenderers.begin();i != end;++i) + { + Renderer* renderer = *i; + Assert(renderer->HasEvent(AnimationVisibilityCallback, this)); + if (renderer->IsVisibleInScene()) + { + SetVisibleRenderers(true); + return; + } + } + + SetVisibleRenderers(false); +} + +void Animation::SetVisibleInternal(bool visible) +{ + Assert(m_CullingType != kCulling_AlwaysAnimate); + m_Visible = visible; + + if (IsWorldPlaying()) + { + const bool wasAttached = m_AnimationManagerNode.IsInList(); + // Method is called AddToManager, but it does removal too... + AddToManager(); + + // Culling is after AnimationManager Update, + // so when we pop into visibility we should make sure we are rendering the right frame! + if (m_AnimationManagerNode.IsInList() && wasAttached == false) + UpdateAnimation(GetCurTime()); + } +} + + +void Animation::SetVisibleRenderers(bool visible) +{ + //LogString(Format("SetVisibleRenderers %d %s", visible ? 1 : 0, GetGameObject().GetName())); + + Assert(m_CullingType == kCulling_BasedOnRenderers); + SetVisibleInternal(visible); +} + +void Animation::SetVisibleBounds(bool visible) +{ + //LogString(Format("SetVisibleBounds %d %s", visible ? 1 : 0, GetGameObject().GetName())); + + CheckIsCullingBasedOnBoundsDeprecated (); + SetVisibleInternal(visible); +} + +///@TODO: We must ensure that there are not two animation components in a hierarchy!!!. Otherwise SetAnimationPtr will break! + +void Animation::RecomputeContainedRenderersRecurse (Transform& transform) +{ + Renderer* renderer = transform.QueryComponent(Renderer); + if (renderer) + { + m_ContainedRenderers.push_back(renderer); + renderer->AddEvent(AnimationVisibilityCallback, this); + } + Transform::iterator end = transform.end(); + for (Transform::iterator i = transform.begin();i != end;++i) + { + RecomputeContainedRenderersRecurse(**i); + } +} + +void Animation::SendTransformChangedToCachedTransform() +{ + int physicsMask = m_AnimatePhysics ? Transform::kAnimatePhysics : 0; + int size = m_CachedAffectedSendToRootTransform.size(); + for (int i=0;i<size;i++) + { + m_CachedAffectedSendToRootTransform[i]->SendTransformChanged(m_CachedTransformMessageMask | physicsMask); + } +} + +void Animation::SyncLayerTime (int layer) +{ + float normalizedSpeed = 0.0F; + float normalizedTime = 0.0F; + float summedLayerWeight = 0.0F; + + for (AnimationStates::iterator i=m_AnimationStates.begin();i!=m_AnimationStates.end();i++) + { + AnimationState& state = **i; + if (state.GetLayer() != layer || !state.GetEnabled()) + continue; + + float weight = max(state.GetWeight(), 0.0F); + normalizedSpeed += state.GetNormalizedSpeed() * weight; + normalizedTime += state.GetNormalizedTime() * weight; + summedLayerWeight += weight; + } + + if (summedLayerWeight > kReallySmallWeight) + { + normalizedSpeed = normalizedSpeed / summedLayerWeight; + normalizedTime = normalizedTime / summedLayerWeight; + + for (AnimationStates::iterator i=m_AnimationStates.begin();i!=m_AnimationStates.end();i++) + { + AnimationState& state = **i; + if (state.GetLayer() != layer || !state.GetEnabled()) + continue; + + state.SetNormalizedSyncedSpeed(normalizedSpeed); + state.SetNormalizedTime(normalizedTime); + } + } +} + +void Animation::Sample () +{ + bool needsUpdate = false; + + // Update animation state + for (int i=0;i<m_AnimationStates.size();i++) + { + AnimationState& state = *m_AnimationStates[i]; + + // Do we actually use any of the animation states? + if (state.ShouldUse()) + needsUpdate = true; + + m_DirtyMask |= state.GetDirtyMask(); + state.ClearDirtyMask(); + } + + if (needsUpdate) + SampleInternal(); +} + +void Animation::SampleInternal() +{ + PROFILER_AUTO(gSampleAnimation, this) + + ValidateBoundCurves (); + + if (m_DirtyMask != 0) + { + if (m_DirtyMask & kRebindDirtyMask) + RebuildStateForEverything(); + + if (m_DirtyMask & kLayersDirtyMask) + SortAnimationStates(); + } + + AssertIf(m_DirtyMask != 0); + + if (!m_BoundCurves.empty()) + { + if (RebuildBoundStateMask()) + { + if (m_ActiveAnimationStatesSize != 0) + BlendOptimized(); + } + else + { + /// More than 32 animation states active at the same time! + /// @TODO: 3.0 take this out. Possibly sort animation states by maximum weight. + /// Or maybe supporting more than 32 states at once is really pointless + BlendGeneric(); + } + + BlendAdditive(); + + SendTransformChangedToCachedTransform(); + } +} + +void Animation::UpdateAnimation (double time) +{ + if (AnimationState::UseUnity32AnimationFixes()) + UpdateAnimationInternal(time); + else + UpdateAnimationInternal_Before32(time); +} + +// Calculates remaining play-times for all animations and for specified layer +static void GetQueueTimes(const Animation::AnimationStates& states, const int targetLayer, float& allQueueTime, float& layerQueueTime) +{ + allQueueTime = 0; + layerQueueTime = 0; + + for (Animation::AnimationStates::const_iterator it = states.begin(), end = states.end(); it != end; ++it) + { + const AnimationState& state = **it; + + if (state.GetEnabled()) + { + const int layer = state.GetLayer(); + + const int wrapMode = state.GetWrapMode(); + if (wrapMode != kDefaultWrapMode && wrapMode != kClamp) + { + // for "infinite" animations (Loop, Repeat, ClampForever) we mark layer as "occupied" + allQueueTime = std::numeric_limits<float>::infinity(); + if (layer == targetLayer) + layerQueueTime = std::numeric_limits<float>::infinity(); + } + else + { + const float dt = state.GetLength() - state.GetTime(); + Assert(dt >= 0); + + allQueueTime = std::max(allQueueTime, dt); + if (layer == targetLayer) + layerQueueTime = std::max(layerQueueTime, dt); + } + } + } +} + +// This function starts Queued animations (if it's already time to start). +// We always blend animations based on QueuedAnimation::fadeTime, i.e. it doesn't +// matter if currently playing animation(s) will finish in shorter time we will blend +// in the new one in QueuedAnimation::fadeTime. We leave up to a user to specify +// sufficient blend times. +void Animation::UpdateQueuedAnimations(bool& needsUpdate) +{ + int lastLayer = -1; + float allQueueTime, lastLayerQueueTime; + allQueueTime = lastLayerQueueTime = -1; + + // Update queued animations + for (QueuedAnimations::iterator q = m_Queued.begin(); q != m_Queued.end(); ) + { + const QueuedAnimation& qa = *q; + const float fadeTime = qa.fadeTime; + + const int layer = qa.state->GetLayer(); + + bool startNow = false; + if (qa.mode == kStopAll) + { + // queuing after all animations + + if (allQueueTime < 0) + { + // allQueueTime must to be recalculated + GetQueueTimes(m_AnimationStates, layer, allQueueTime, lastLayerQueueTime); + lastLayer = layer; + } + + startNow = fadeTime >= allQueueTime; + } + else + { + // queuing after animations in specific layer + + if (lastLayer != layer || lastLayerQueueTime < 0) + { + // lastLayerQueueTime must to be recalculated + GetQueueTimes(m_AnimationStates, layer, allQueueTime, lastLayerQueueTime); + lastLayer = layer; + } + + startNow = fadeTime >= lastLayerQueueTime; + } + + if (startNow) + { + // This crossfade logic is framerate specific. We know when this animation had + // to be started, so in theory we should advance time and blending value (and execute events), + // but we don't do that because it would be an over-complication. + AnimationState& state = *qa.state; + + CrossFade(state, fadeTime, qa.mode, false); + q = m_Queued.erase(q); + needsUpdate = true; + + Assert(state.GetEnabled()); + // we need to recalculate queue times, because we just started an animation + allQueueTime = lastLayerQueueTime = -1; + } + else + ++q; + } +} + +void Animation::UpdateQueuedAnimations_Before34(bool& needsUpdate) +{ + // Update queued animations + for (QueuedAnimations::iterator q = m_Queued.begin(); q != m_Queued.end(); ) + { + const QueuedAnimation& qa = *q; + if ((qa.mode == kStopAll && !IsPlaying()) || (qa.mode != kStopAll && !IsPlayingLayer(qa.state->GetLayer()))) + { + CrossFade(*qa.state, qa.fadeTime, qa.mode, false); + q = m_Queued.erase(q); + needsUpdate = true; + } + else + ++q; + } +} + +void Animation::UpdateAnimationInternal(double time) +{ + PROFILER_AUTO(gUpdateAnimation, this) + + bool needsUpdate = false; + + // Sync animations + for (SyncedLayers::iterator sync=m_SyncedLayers.begin();sync != m_SyncedLayers.end();sync++) + SyncLayerTime(*sync); + + int stoppedAnimationCount = 0; + AnimationState** stoppedAnimations = NULL; + ALLOC_TEMP(stoppedAnimations, AnimationState*, m_AnimationStates.size()); + + // Update animation state + for (int i=0;i<m_AnimationStates.size();) + { + AnimationState& state = *m_AnimationStates[i]; + + // Update state + if (state.GetEnabled()) + { + if (state.UpdateAnimationState(time, *this)) + { + if (!state.ShouldAutoCleanupNow()) + stoppedAnimations[stoppedAnimationCount++] = &state; + } + } + + // Do we actually use any of the animation states? + if (state.ShouldUse()) + needsUpdate = true; + + m_DirtyMask |= state.GetDirtyMask(); + state.ClearDirtyMask(); + + // Cleanup queued animations that have finished playing + if (state.ShouldAutoCleanupNow()) + { + delete &state; + m_DirtyMask |= kLayersDirtyMask; + m_AnimationStates.erase(m_AnimationStates.begin() + i); + m_ActiveAnimationStatesSize = 0; + } + else + { + i++; + } + } + + if (AnimationState::UseUnity34AnimationFixes()) + UpdateQueuedAnimations(needsUpdate); + else + UpdateQueuedAnimations_Before34(needsUpdate); + + if (stoppedAnimationCount > 0) + { + for (int i = 0; i < stoppedAnimationCount; ++i) + stoppedAnimations[i]->SetupUnstoppedState(); + + needsUpdate = true; + } + + // Only do blending if it is really necessary + if (needsUpdate) + { + SampleInternal(); + } + + for (int i = 0; i < stoppedAnimationCount; ++i) + stoppedAnimations[i]->CleanupUnstoppedState(); +} + +// This is for backwards compatibility. If you need to make changes, +// then make them in UpdateAnimationInternal which is used with Unity 3.2 and later content +void Animation::UpdateAnimationInternal_Before32(double time) +{ + PROFILER_AUTO(gUpdateAnimation, this) + + bool needsUpdate = false; + int activeLastStateCount = 0; + + // Sync animations + for (SyncedLayers::iterator sync=m_SyncedLayers.begin();sync != m_SyncedLayers.end();sync++) + SyncLayerTime(*sync); + + AnimationState* stoppedAnimation = NULL; + + // Update animation state + for (int i=0;i<m_AnimationStates.size();) + { + AnimationState& state = *m_AnimationStates[i]; + + if (state.ShouldUse()) + activeLastStateCount++; + + // Update state + if (state.GetEnabled()) + { + if (state.UpdateAnimationState(time, *this)) + { + if (!state.ShouldAutoCleanupNow()) + stoppedAnimation = &state; + } + } + + // Do we actually use any of the animation states? + if (state.ShouldUse()) + needsUpdate = true; + + m_DirtyMask |= state.GetDirtyMask(); + state.ClearDirtyMask(); + + // Cleanup queued animations that have finished playing + if (state.ShouldAutoCleanupNow()) + { + delete &state; + m_DirtyMask |= kLayersDirtyMask; + m_AnimationStates.erase(m_AnimationStates.begin() + i); + m_ActiveAnimationStatesSize = 0; + } + else + { + i++; + } + } + + UpdateQueuedAnimations_Before34(needsUpdate); + + bool revertWrappedTimeToBeforeStop = false; + if (activeLastStateCount == 1 && needsUpdate == false && stoppedAnimation) + { + stoppedAnimation->SetupUnstoppedState(); + revertWrappedTimeToBeforeStop = true; + } + + // Only do blending if it is really necessary + if (needsUpdate) + { + SampleInternal(); + } + + if (revertWrappedTimeToBeforeStop) + stoppedAnimation->CleanupUnstoppedState(); +} + + +struct GreaterLayer : std::binary_function<AnimationState*, AnimationState*, std::size_t> +{ + bool operator () (AnimationState* lhs, AnimationState* rhs) const + { + if (lhs->GetLayer() != rhs->GetLayer()) + return lhs->GetLayer() > rhs->GetLayer(); + else + return lhs->GetName() > rhs->GetName(); + } +}; + +void Animation::SortAnimationStates () +{ + sort(m_AnimationStates.begin(), m_AnimationStates.end(), GreaterLayer()); + m_DirtyMask &= ~kLayersDirtyMask; + m_ActiveAnimationStatesSize = 0; +} + +void Animation::ReleaseAnimationStates () +{ + for (AnimationStates::iterator i=m_AnimationStates.begin();i!=m_AnimationStates.end();i++) + { + delete *i; + } + m_AnimationStates.clear(); +} + +AnimationClip* Animation::GetClipLegacyWarning (AnimationClip* clip) +{ + if (clip == NULL) + return NULL; + else + { + if (clip->GetAnimationType () == AnimationClip::kLegacy) + return clip; + else + { + WarningStringObject(Format("The AnimationClip '%s' used by the Animation component '%s' must be marked as Legacy.", clip->GetName(), GetName()), clip); + return NULL; + } + } +} + + +void Animation::BuildAnimationStates() +{ + if (!m_AnimationStates.empty()) + return; + if (m_Animations.empty ()) + return; + + PROFILER_AUTO(gBuildAnimationState, this) + + ReleaseAnimationStates(); + + m_AnimationStates.reserve(m_Animations.size()); + + double time = GetCurTime(); + for (int i=0;i<m_Animations.size();i++) + { + AnimationClip* clip = GetClipLegacyWarning(m_Animations[i]); + if (clip != NULL) + { + m_AnimationStates.push_back(new AnimationState()); + m_AnimationStates.back()->Init(clip->GetName(), clip, time, CombineWrapMode(clip->GetWrapMode(), m_WrapMode)); + } + } + + if (m_CullingType == kCulling_BasedOnRenderers) + RecomputeContainedRenderers(); + + m_DirtyMask |= kRebindDirtyMask; + + AddToManager(); +} + +AnimationState* Animation::CloneAnimation (AnimationState* state) +{ + // The animation state needs to be attached to this animation + if (GetState(state) == NULL) + return NULL; + + PROFILER_AUTO(gCloneAnimationState, this) + + // Clone the state and reference all it's bound curves + AnimationState* clone = new AnimationState(); + clone->Init( state->GetName() + " - Queued Clone", state->GetClip(), GetCurTime(), state->GetWrapMode(), true ); + clone->SetParentName( state->GetName() ); + clone->SetLayer(state->GetLayer()); + clone->SetClonedCurves(*state); + clone->ClearDirtyMask(); + m_AnimationStates.push_back(clone); + + m_DirtyMask |= kLayersDirtyMask; + return clone; +} + +void Animation::AddClip (AnimationClip& clip, const std::string& newName, int firstFrame, int lastFrame, bool loop) +{ + PROFILER_AUTO (gAddClip, this) + + if (GetClipLegacyWarning (&clip) == NULL) + return; + + AnimationClip* newClip = &clip; + // Do we really need to create a duplicate clip? + if (loop || firstFrame != INT_MIN || lastFrame != INT_MAX || newName != clip.GetName()) + { + newClip = NEW_OBJECT (AnimationClip); + + CopySerialized(clip, *newClip); + newClip->SetName(newName.c_str()); + + if (loop || firstFrame != INT_MIN || lastFrame != INT_MAX) + { + // [case 504486] need to clear curve because function ClipAnimation() will add all these clipped curves from source clip. + newClip->ClearCurves(); + ClipAnimation(clip, *newClip, FrameToTime(firstFrame, clip.GetSampleRate()), FrameToTime(lastFrame, clip.GetSampleRate()), loop); + } + } + + + // Replace clips with duplicate names + Animations::iterator i; + for (i=m_Animations.begin();i != m_Animations.end();i++) + { + AnimationClip* cur = *i; + if (cur && cur->GetName() == newName) + break; + } + if (i == m_Animations.end()) + m_Animations.push_back(newClip); + else + *i = newClip; + + if (!m_AnimationStates.empty()) + { + m_DirtyMask |= kRebindDirtyMask; + + // Remove states with duplicate names + for (AnimationStates::iterator s=begin();s != end();s++) + { + if ((**s).GetName() == newName) + { + delete *s; + m_AnimationStates.erase(s); + break; + } + } + + m_AnimationStates.push_back(new AnimationState()); + m_AnimationStates.back()->Init(newName, newClip, GetCurTime(), CombineWrapMode(newClip->GetWrapMode(), m_WrapMode)); + } + + CheckIsCullingBasedOnBoundsDeprecated(); + + SetDirty(); +} + +void Animation::AddClip (AnimationClip& clip) +{ + AddClip(clip, clip.GetName(), std::numeric_limits<int>::min(), std::numeric_limits<int>::max(), false); +} + +void Animation::RemoveClip (AnimationClip& clip) +{ + PROFILER_AUTO(gRemoveClip, this) + + // Find the clip to remove + // We might have the same clip multiple times in the animation list. + // We are removing elements, so we iterate over it backwards. + { + bool found = false; + int i = m_Animations.size(); + while (i--) + { + AnimationClip* cur = m_Animations[i]; + if (cur && cur == &clip) + { + found = true; + Animations::iterator j = m_Animations.begin() + i; + m_Animations.erase(j); + } + } + if (!found) + { + AssertStringObject (Format ("Unable to remove Animation Clip '%s' - clip not found in animation list", clip.GetName()), this); + return; + } + } + + { + // Find the animation state(s) to remove + // We are removing elements, so we iterate over it backwards. + int i = m_AnimationStates.size(); + while (i--) + { + if (m_AnimationStates[i]->m_Clip == &clip) + { + delete m_AnimationStates[i]; + iterator j = m_AnimationStates.begin() + i; + m_AnimationStates.erase(j); + } + } + } + + CheckIsCullingBasedOnBoundsDeprecated (); + + m_DirtyMask |= kRebindDirtyMask; +} + +void Animation::RemoveClip (const std::string &clipName) +{ + PROFILER_AUTO(gRemoveClip, this) + + // Find the clip to remove + // We might have the same clip multiple times in the animation list. + // We are removing elements, so we iterate over it backwards. + { + bool found = false; + int i = m_Animations.size(); + while (i--) + { + AnimationClip* cur = m_Animations[i]; + if (cur && cur->GetName() == clipName) + { + found = true; + Animations::iterator j = m_Animations.begin() + i; + m_Animations.erase(j); + } + } + if (!found) + { + AssertStringObject (Format ("Unable to remove Animation Clip '%s' - clip not found in animation list", clipName.c_str()), this); + return; + } + } + + { + // Find the animation state(s) to remove + // We are removing elements, so we iterate over it backwards. + int i = m_AnimationStates.size(); + while (i--) + { + AnimationState *cur = m_AnimationStates[i]; + if (cur && cur->GetName() == clipName) + { + delete cur; + iterator j = m_AnimationStates.begin() + i; + m_AnimationStates.erase(j); + } + } + } + + CheckIsCullingBasedOnBoundsDeprecated(); + + m_DirtyMask |= kRebindDirtyMask; +} + +int Animation::GetClipCount () const { + return m_Animations.size (); +} + +AnimationState* Animation::GetState(const string& name) +{ + BuildAnimationStates(); + + for (AnimationStates::iterator i=m_AnimationStates.begin();i!=m_AnimationStates.end();i++) + { + AnimationState& state = **i; + if (state.m_Name == name) + return &state; + } + return NULL; +} + +AnimationState* Animation::GetState(AnimationClip* clip) +{ + BuildAnimationStates(); + for (iterator i=begin();i != end();i++) + { + + if ((**i).GetClip() == clip) + return *i; + } + return NULL; +} + +AnimationState* Animation::GetState(AnimationState* state) +{ + BuildAnimationStates(); + for (iterator i=begin();i != end();i++) + { + if (*i == state) + return state; + } + return NULL; +} + +void Animation::InitializeClass () +{ + AnimationState::InitializeClass(); + AnimationManager::InitializeClass(); + + RegisterAllowNameConversion("Animation", "m_PlayFixedFrameRate", "m_AnimatePhysics"); + RegisterAllowNameConversion("Animation", "m_AnimateIfVisible", "m_AnimateOnlyIfVisible"); +} + +void Animation::CleanupClass () +{ + AnimationState::CleanupClass(); + AnimationManager::CleanupClass(); +} + + +template<class TransferFunction> +void Animation::Transfer (TransferFunction& transfer) +{ + Super::Transfer (transfer); + + transfer.SetVersion (3); + +#if UNITY_EDITOR + if (transfer.IsOldVersion(1)) + { + TRANSFER_SIMPLE (m_Animation); + transfer.Transfer (m_OldAnimations, "m_Animations"); + TRANSFER_SIMPLE (m_WrapMode); + TRANSFER_SIMPLE (m_PlayAutomatically); + transfer.Transfer (m_AnimatePhysics, "m_PlayFixedFrameRate"); + return; + } +#endif + + + TRANSFER_SIMPLE (m_Animation); + TRANSFER_SIMPLE (m_Animations); + + // Hide the wrapmode in the inspector if the user has not changed it already... We are in the process of deprecating it +#if UNITY_EDITOR + bool hide = (transfer.GetFlags () & kSerializeForInspector) != 0 && (transfer.GetFlags () & kSerializeDebugProperties) == 0 && m_WrapMode == 0; + transfer.Transfer (m_WrapMode, "m_WrapMode", hide ? kHideInEditorMask : kNoTransferFlags); +#else + transfer.Transfer (m_WrapMode, "m_WrapMode", kNoTransferFlags); +#endif + + // In Unity 3.4 we switched to the m_CullingType enum. Previously we serialized animateOnlyIfVisible. + if (transfer.IsOldVersion(2)) + { + bool animateOnlyIfVisible = false; + transfer.Transfer(animateOnlyIfVisible, "m_AnimateOnlyIfVisible"); + m_CullingType = animateOnlyIfVisible ? kCulling_BasedOnRenderers : kCulling_AlwaysAnimate; + } + + TRANSFER_SIMPLE (m_PlayAutomatically); + TRANSFER (m_AnimatePhysics); + + transfer.Align(); + + // We hide these two fields here, because they are displayed by custom inspector (AnimationEditor) + TRANSFER_ENUM(m_CullingType); + if (transfer.IsReading()) + m_CullingType = RemapDeprecatedCullingType(m_CullingType); + + + TRANSFER_DEBUG(m_AnimationStates); +} + +/* + + TODO: + + * Allow for reimport animations while in playmode! + +- Make a list of all mesh users and invalidate them when the mesh changes! +- implement all missing functions +- Implement mixing properly (Based on which curves have changed) +- support delay cross fade (Starts time advancing only when the animation has faded in completely ) +- Don't always add animation component to all game objects! But what if people want to animate a prefab??? + +- Make the animation system store amount of loops and not one huge float for time? +- Keep a cache for all curves and pass it into animationcurve.Evaluate. + So that many characters dont kill the cache of shared animation curves. + + - automatically Reduce curves that dont affect anything! + 1. If all animation clips change that curve to the same value and all curves dont actually modify the value! + 2. The current state when loaded is the same as in all curves + 3. Only do it for animation clips that got imported from a fbx file + - Unity made animations are more likely to be modified by scripting as well + so it should not play any tricks on the user + 4. Have an option to turn the optimization off. eg someone wants to do IK etc. + +--- +- Handle bake simulation better when using clipped animations! +- auto cleanup of queued animations +- search for !IsWorldPlaying () those are hacks to get the timeline working +- timeline doesnt work anymore! + + - Store optimized animation curves in animation clip instead of animation state. + - CRASHBUG: Check when animated objects are removed -> rebuild + - CRASHBUG: Check when animations change -> rebuild + +- Remove normalize fast before blending, not necessary for sampled animations! + But what about unity made animations? + + +///@TODO: EXPOSE AnimationState too!(cspreprocess fucks up at the moment) +- implement manual clipping of animations from scripts +- Handle stopping and fading out of animations! +- Add named clip will fail when called at runtime + +*/ + |