+Unity Runtime codeHEADmaster

1 files changed, 824 insertions, 0 deletions

diff --git a/Runtime/Animation/AnimationState.cpp b/Runtime/Animation/AnimationState.cpp
new file mode 100644
index 0000000..d5efe04
--- /dev/null
+++ b/Runtime/Animation/AnimationState.cpp
@@ -0,0 +1,824 @@
+#include "UnityPrefix.h"
+#include "AnimationState.h"
+#include "Runtime/Math/AnimationCurve.h"
+#include "AnimationClip.h"
+#include "AnimationEvent.h"
+#include "Runtime/Graphics/Transform.h"
+#include "Runtime/Input/TimeManager.h"
+#include "Runtime/Profiler/Profiler.h"
+#include "Runtime/Misc/BuildSettings.h"
+
+PROFILER_INFORMATION (gAddMixingTransform, "Animation.AddMixingTransform [Triggers RebuildInternalState]", kProfilerAnimation);
+PROFILER_INFORMATION (gRemoveMixingTransform, "Animation.RemoveMixingTransform [Triggers RebuildInternalState]", kProfilerAnimation);
+PROFILER_INFORMATION (gModifyAnimationClip, "Animation.ModifyAnimationClip [Triggers RebuildInternalState]", kProfilerAnimation);
+
+void AnimationState::InitializeClass ()
+{
+	AnimationClip::SetDidModifyClipCallback(DidModifyAnimationClip);
+}
+
+void AnimationState::CleanupClass ()
+{
+	AnimationClip::SetDidModifyClipCallback(NULL);
+}
+
+AnimationState::AnimationState ()
+: m_AnimationClipNode (this)
+{
+	// We use only 2 bits for m_AnimationEventState
+	// This assert guards against kAnimationEventStates running out of these bits
+	Assert(kAnimationEventState__Count <= 4);
+
+	m_Clip = NULL;
+	m_Curves = NULL;
+	m_IsClone = false;
+}
+
+AnimationState::~AnimationState ()
+{
+	m_Clip = NULL;
+	m_MixingTransforms.clear();
+	m_Name.clear();
+	CleanupCurves ();
+	m_AnimationClipNode.RemoveFromList();
+}
+
+void AnimationState::AllocateCurves(int count)
+{
+	AssertIf(m_Curves);
+	m_OwnsCurves = 1;
+
+	m_Curves = new AnimationCurveBase*[count];
+	for (int i=0;i<count;i++)
+		m_Curves[i] = NULL;
+}
+
+
+void AnimationState::SetClonedCurves(AnimationState& state)
+{
+	AssertIf(m_Curves);
+	m_OwnsCurves = 0;
+
+	m_Curves = state.m_Curves;
+//	m_CurvesCount = state.m_CurvesCount;
+}
+
+
+void AnimationState::CleanupCurves ()
+{
+	if (!m_OwnsCurves || m_Curves == NULL)
+	{
+		m_Curves = NULL;
+		return;
+	}
+
+	delete[] m_Curves;
+	m_Curves = NULL;
+}
+
+void AnimationState::SetWeightTarget (float target, float length, bool stopWhenFaded)
+{
+	// TODO : this m_WeightDelta approach doesn't work very well when length is 0
+	// Current approach might lead to precision problems.
+	// The blend should happen instantly, but with very small deltaTimes it might need several frames.
+
+	AssertFiniteParameter(target);
+
+	float newWeightDelta;
+	if (length > 0.001)
+		newWeightDelta = (target - m_Weight) / length;
+	else
+		newWeightDelta = (target - m_Weight) * 100000.0F;
+
+	// If the current weight delta is going to reach the target faster than the new one, don't update it!
+	bool ignoreWeightDelta = m_FadeBlend && CompareApproximately(m_WeightTarget, target, kReallySmallWeight) && Abs(m_WeightDelta) > Abs(newWeightDelta);
+	if (!ignoreWeightDelta)
+		m_WeightDelta = newWeightDelta;
+
+	// We need to make sure that the weight delta is never zero, otherwise the stop condition in UpdateAnimationState is never reached!
+	if (CompareApproximately(m_WeightDelta, 0.0F, kReallySmallWeight))
+		m_WeightDelta = 100000.0F;
+
+	m_WeightTarget = target;
+
+	m_FadeBlend = true;
+	m_StopWhenFadedOut = stopWhenFaded;
+	m_IsFadingOut = false;
+}
+
+void AnimationState::SetWeightTargetImmediate (float target, bool stopWhenFaded)
+{
+	AssertFiniteParameter(target);
+
+	m_Weight = target;
+	m_StopWhenFadedOut = stopWhenFaded;
+	m_FadeBlend = false;
+	m_IsFadingOut = false;
+}
+
+
+///@TODO: Doesn't using the stop time conflict with using stop time for something else, like when queueing?
+void AnimationState::SetupFadeout (float length)
+{
+	m_FadeOutLength = length;
+}
+
+/*
+void AnimationState::ApplyWeightDeltaFraction ()
+{
+
+}
+*/
+/*
+void AnimationState::Delay (float time)
+{
+
+}
+*/
+
+void AnimationState::SetTime (float time)
+{
+	AssertFiniteParameter(time);
+	m_Time = time;
+	m_WrappedTime = WrapTime(time, m_CachedRange, m_WrapMode);
+	DebugAssertIf(!IsFinite(m_Time) || !IsFinite(m_WrappedTime));
+	m_AnimationEventState = kAnimationEventState_Search; // Re-search for animation event index
+}
+
+float WrapTime (float curveT, const std::pair<float, float>& range, int m_WrapMode)
+{
+	float begTime = range.first;
+	float endTime = range.second;
+
+	if (curveT >= endTime)
+	{
+		if (m_WrapMode == kRepeat)
+			curveT = Repeat (curveT, begTime, endTime);
+		else if (m_WrapMode == kClamp || m_WrapMode == kClampForever)
+		{
+			curveT = endTime;
+		}
+		else if (m_WrapMode == kPingPong)
+			curveT = PingPong (curveT, begTime, endTime);
+	}
+	else if (curveT < begTime)
+	{
+		if (m_WrapMode == kRepeat)
+			curveT = Repeat (curveT, begTime, endTime);
+		if (m_WrapMode == kClamp || m_WrapMode == kClampForever)
+			curveT = begTime;
+		else if (m_WrapMode == kPingPong)
+			curveT = PingPong (curveT, begTime, endTime);
+	}
+	return curveT;
+}
+
+namespace
+{
+	// returns -1, 0, 1 depending on sign/value of v
+	int GetDirection(float v)
+	{
+		if (v == 0) return 0;
+		else return v > 0 ? 1 : -1;
+	}
+}
+
+void AnimationState::SetSpeed (float speed)
+{
+	// When reversing speed. Recalculate animation event index
+	if (m_AnimationEventState == kAnimationEventState_PausedOnEvent)
+	{
+		// Handling special case when speed=0 and m_AnimationEventIndex is valid,
+		// bug the event that m_AnimationEventIndex is pointing to has been triggered before pause,
+		// so wee need to trigger event on the left or on the right
+		Assert(GetDirection(m_Speed) == 0);
+
+		int newSpeedDirection = GetDirection(speed);
+		if (newSpeedDirection != 0)
+		{
+			// In PinPong mode event are sometimes executed in the oposite direction of speed
+			// so we need to reverse newSpeedDirection based on that
+			if (m_WrapMode == kPingPong)
+			{
+				const float begTime = m_CachedRange.first;
+				const float endTime = m_CachedRange.second;
+
+				// Get index of how many times we are playing this back and forth
+				const int newWrapIndex = FloorfToInt((m_Time - begTime) / (endTime - begTime));
+
+				// Switch going forward based on the PingPong direction
+				if (newWrapIndex % 2 != 0)
+					newSpeedDirection = -newSpeedDirection;
+			}
+
+			m_AnimationEventState = kAnimationEventState_HasEvent;
+			m_AnimationEventIndex += newSpeedDirection > 0 ? 1 : -1;
+		}
+	}
+	else
+	{
+		const int oldSpeedDirection = GetDirection(m_Speed);
+		const int newSpeedDirection = GetDirection(speed);
+
+		// TODO : if we want a minor optimization, we could not trigger search
+		// if state is paused and then resumed in same direction, but triggering
+		// search should work just fine as long as we're not on event
+		if (oldSpeedDirection != newSpeedDirection)
+			m_AnimationEventState = kAnimationEventState_Search;
+	}
+
+	m_SyncedSpeed = m_Speed = speed;
+	AssertFiniteParameter(speed);
+
+	if (UseUnity32AnimationFixes())
+		SetupStopTime();
+}
+
+// offsetTime - time from which newWrappedTime starts (from which newWrappedTime is wrapped)
+// it is used for recalculating m_Time when event modifies playback direction
+bool AnimationState::FireEvents (const float deltaTime, float newWrappedTime, bool forward, Unity::Component& animation, const float beginTime, const float offsetTime, const bool reverseOffsetTime)
+{
+	AnimationClip::Events& events = m_Clip->GetEvents();
+
+	// Find initial event
+	if (m_AnimationEventState == kAnimationEventState_Search)
+	{
+		const float oldWrappedTime = m_WrappedTime;
+
+		if (forward)
+		{
+			AssertIf(oldWrappedTime > newWrappedTime);
+
+			for (int i=0;i<events.size();i++)
+			{
+				if (events[i].time >= oldWrappedTime)
+				{
+					m_AnimationEventIndex = i;
+					m_AnimationEventState = kAnimationEventState_HasEvent;
+					break;
+				}
+			}
+		}
+		else
+		{
+			AssertIf(oldWrappedTime < newWrappedTime);
+
+			for (int i=events.size()-1;i>=0;i--)
+			{
+				if (events[i].time <= oldWrappedTime)
+				{
+					m_AnimationEventIndex = i;
+					m_AnimationEventState = kAnimationEventState_HasEvent;
+					break;
+				}
+			}
+		}
+
+		if (m_AnimationEventState == kAnimationEventState_Search)
+			m_AnimationEventState = kAnimationEventState_NotFound;
+	}
+
+	const float oldSyncedSpeed = m_SyncedSpeed;
+	const float oldWrappedTime = m_WrappedTime;
+
+	while (true)
+	{
+		if (m_AnimationEventIndex < 0 || m_AnimationEventIndex >= events.size())
+			break;
+
+		float eventTime = events[m_AnimationEventIndex].time;
+
+		if (forward && eventTime > newWrappedTime)
+			break;
+		if (!forward && eventTime < newWrappedTime)
+			break;
+
+		const int currentAnimationEventIndex = m_AnimationEventIndex;
+
+		FireEvent (events[m_AnimationEventIndex], this, animation);
+		DebugAssertIf(!IsFinite(m_Time));
+		DebugAssertIf(!IsFinite(m_WrappedTime));
+
+		if (m_AnimationEventState == kAnimationEventState_Search)
+		{
+			const int oldSpeedDirection = GetDirection(oldSyncedSpeed);
+			const int newSpeedDirection = GetDirection(m_SyncedSpeed);
+
+			// handling special case when speed direction was changed
+			// we want to continue time from eventTime and events from next event (we do not want to trigger this event immediately again)
+			if (oldSpeedDirection != newSpeedDirection)
+			{
+				// do not modify m_WrappedTime if it has been modified inside of event
+				if (m_WrappedTime == oldWrappedTime)
+				{
+					const float timeDelta = eventTime - beginTime;
+					float newTime = offsetTime + (reverseOffsetTime ? -timeDelta : timeDelta);
+					AssertMsg(Abs(newTime - m_Time) <= deltaTime + std::numeric_limits<float>::epsilon(), "Abs(%f - %f) <= %f\n%f <= %f\n%e <= 0", newTime, m_Time, deltaTime, Abs(newTime - m_Time), deltaTime, Abs(newTime - m_Time) - deltaTime);
+					m_Time = newTime;
+
+					m_WrappedTime = eventTime;
+
+					if (newSpeedDirection == 0)
+					{
+						// if time is paused we need to continue from "right" or "left" event
+						// after time is unpaused, but we will know next event only when time is unpaused,
+						// so we set AnimationEventState to PausedOnEvent.
+						// We can just set state to Searh, because it would find and trigger same event
+						m_AnimationEventIndex = currentAnimationEventIndex;
+						m_AnimationEventState = kAnimationEventState_PausedOnEvent;
+					}
+					else
+					{
+						// if time is reversed we need to continue from "right" or "left" event
+						m_AnimationEventIndex = currentAnimationEventIndex + (!forward ? 1 : -1);
+						m_AnimationEventState = kAnimationEventState_HasEvent;
+					}
+				}
+			}
+
+			DebugAssertIf(!IsFinite(m_Time) || !IsFinite(m_WrappedTime));
+			return false;
+		}
+
+		if (forward)
+			m_AnimationEventIndex++;
+		else
+			m_AnimationEventIndex--;
+	}
+
+	return true;
+}
+
+
+bool AnimationState::UpdateAnimationState (double globalTime, Unity::Component& animationComponent)
+{
+	DebugAssertIf(!IsFinite(m_Time) || !IsFinite(m_WrappedTime));
+
+	// Update time
+	const float deltaTime = globalTime - m_LastGlobalTime;
+	m_LastGlobalTime = globalTime;
+
+	//deltaTime = 0.166667f;
+
+	//LogString(Format("globalTime: %f; deltaTime: %f; m_Time: %f", globalTime, deltaTime, m_Time));
+
+	float syncedSpeedDeltaTime = deltaTime * m_SyncedSpeed;
+	// Do not trigger events if time is stopped
+	if (syncedSpeedDeltaTime != 0)
+	{
+		double lastTime = m_Time;
+		m_Time += syncedSpeedDeltaTime;
+		// if syncedSpeedDeltaTime is big it might cross whole loop,
+		// so we would have to fire all events in that loop, but we ignore cases like this for now...
+		float newWrappedTime = m_WrappedTime + syncedSpeedDeltaTime;
+		const float oldWrappedTime = m_WrappedTime;
+
+
+		/// Wrap time and Fire Animation Events
+		float begTime = m_CachedRange.first;
+		float endTime = m_CachedRange.second;
+
+		const bool forward = m_SyncedSpeed >= 0.0F;
+
+		///@TODO: How should repeat behave when the first key is not at zero???
+		/// - Animations should always start playback at zero and also go back to zero, regardless of where the first frame is. (Rune)
+		///@TODO: How do we stop the animation when we play backwards?
+		/// - The animation should stop when it has reached zero. See functional test AnimationOnceSamplesAtEndAndResetsTimeAndGetsDisabled (Rune)
+		///@TODO: Repeat currently doesnt start at the first key frame it might enter anywhere depending on begin / end Time (Repeat (m_Time, begTime, endTime);)
+		/// - The animation should not go back to the exact start of the range when looping, but rather subtract the range length. (Rune)
+		/// - However, the range should always start at zero, not at the first key. (Rune)
+
+		// Repeat
+		if (m_WrapMode == kRepeat)
+		{
+			// Reached end of time range - wrap around and fire animation events
+			if (newWrappedTime >= endTime)
+			{
+				newWrappedTime = RepeatD (m_Time, begTime, endTime);
+				if (m_HasAnimationEvent)
+				{
+					float offsetTime = m_Time - (newWrappedTime - begTime) - (endTime - begTime);
+					if (FireEvents (deltaTime, endTime, forward, animationComponent, begTime, offsetTime, false))
+					{
+						offsetTime += (endTime - begTime);
+						m_AnimationEventIndex = 0;
+						m_AnimationEventState = kAnimationEventState_HasEvent;
+						FireEvents (deltaTime, newWrappedTime, forward, animationComponent, begTime, offsetTime, false);
+					}
+				}
+			}
+			else if (newWrappedTime < begTime)
+			{
+				newWrappedTime = RepeatD (m_Time, begTime, endTime);
+				if (m_HasAnimationEvent)
+				{
+					float offsetTime = m_Time + (endTime - newWrappedTime);
+					if (FireEvents (deltaTime, begTime, forward, animationComponent, begTime, offsetTime, false))
+					{
+						offsetTime -= (endTime - begTime);
+						m_AnimationEventIndex = m_Clip->GetEvents().size() - 1;
+						m_AnimationEventState = kAnimationEventState_HasEvent;
+						FireEvents (deltaTime, newWrappedTime, forward, animationComponent, begTime, offsetTime, false);
+					}
+				}
+			}
+			// Inside of begin / end time range ->  Fire animation event only
+			else if (m_HasAnimationEvent)
+			{
+				const float offsetTime = m_Time - (newWrappedTime - begTime);
+				FireEvents (deltaTime, newWrappedTime, forward, animationComponent, begTime, offsetTime, false);
+			}
+
+
+			// It's important to used RepeatD, because we get an assert otherwise (for exmaple: 1.9999999 double is rounded to 2.0f, which results in 0 when wrapped)
+			DebugAssertIf(m_WrappedTime == oldWrappedTime && !CompareApproximately(newWrappedTime, RepeatD (m_Time, begTime, endTime), 0.01F));
+		}
+		// Clamp
+		else if (m_WrapMode == kClamp || m_WrapMode == kClampForever)
+		{
+			if (m_Time < begTime)
+				newWrappedTime = begTime;
+			else if (m_Time > endTime)
+				newWrappedTime = endTime;
+			else
+				newWrappedTime = m_Time;
+
+			if (m_HasAnimationEvent)
+			{
+				FireEvents (deltaTime, m_Time, forward, animationComponent, begTime, begTime, false);
+			}
+		}
+		// Default
+		else if (m_WrapMode == kDefaultWrapMode)
+		{
+			if (m_HasAnimationEvent)
+			{
+				FireEvents (deltaTime, newWrappedTime, forward, animationComponent, begTime, begTime, false);
+			}
+		}
+		// Ping Pong
+		else if (m_WrapMode == kPingPong)
+		{
+			newWrappedTime = PingPong(m_Time, begTime, endTime);
+
+			if (m_HasAnimationEvent)
+			{
+				const AnimationClip::Events& events = m_Clip->GetEvents();
+
+				AssertIf(Abs(endTime - begTime) < std::numeric_limits<float>::epsilon());
+
+				// Get index of how many times we are playing this back and forth
+				int wrapIndex = FloorfToInt((lastTime - begTime) / (endTime - begTime));
+				int newWrapIndex = FloorfToInt((m_Time - begTime) / (endTime - begTime));
+
+				bool forwardPlayback = m_SyncedSpeed >= 0.0F;
+
+				// Switch going forward based on the pingpong direction
+				if (newWrapIndex % 2 != 0)
+					forwardPlayback = !forwardPlayback;
+
+				// Inside of begin / end boundary
+				if (wrapIndex == newWrapIndex)
+				{
+					const float offsetTime = m_Time - (newWrappedTime - begTime);
+					FireEvents (deltaTime, newWrappedTime, forwardPlayback, animationComponent, begTime, offsetTime, false);
+				}
+				// Crossing boundary
+				else
+				{
+					if (forwardPlayback)
+					{
+						float offsetTime = forward ?
+							m_Time - (newWrappedTime - begTime) :
+							m_Time + (newWrappedTime - begTime);
+						if (FireEvents (deltaTime, begTime, false, animationComponent, begTime, offsetTime, forward))
+						{
+							// if event is right at the begin time - we want to play it once, otherwise twice
+							// we might get m_AnimationEventIndex=events.size() in this statement, but that's acceptable situation
+							// it indicates that there are no events until we reverse the time
+							m_AnimationEventIndex = (events.front().time == begTime ? 1 : 0);
+							m_AnimationEventState = kAnimationEventState_HasEvent;
+							// Events should never be searched in next call of FireEvents
+							FireEvents (deltaTime, newWrappedTime, true, animationComponent, endTime, offsetTime, !forward);
+						}
+					}
+					else
+					{
+						float offsetTime = forward ?
+							m_Time - (endTime - newWrappedTime) :
+							m_Time + (endTime - newWrappedTime);
+						if (FireEvents (deltaTime, endTime, true, animationComponent, endTime, offsetTime, !forward))
+						{
+							// if event is right at the end time - we want to play it once, otherwise twice
+							// we might get m_AnimationEventIndex=-1 in this statement, but that's acceptable situation
+							// it indicates that there are no events until we reverse the time
+							m_AnimationEventIndex = events.size() - (events.back().time == endTime ? 2 : 1);
+							m_AnimationEventState = kAnimationEventState_HasEvent;
+							// Events should never be searched in next call of FireEvents
+							FireEvents (deltaTime, newWrappedTime, false, animationComponent, begTime, offsetTime, forward);
+						}
+					}
+				}
+			}
+		}
+		else
+			ErrorString("Unknown wrapMode");
+
+		DebugAssertIf(!IsFinite(newWrappedTime));
+
+		// do not set m_WrappedTime if it was altered in one of events
+		if (m_WrappedTime == oldWrappedTime)
+			m_WrappedTime = newWrappedTime;
+		DebugAssertIf(!IsFinite(m_Time) || !IsFinite(m_WrappedTime));
+	}
+
+	return UseUnity32AnimationFixes() ? UpdateFading(deltaTime) : UpdateFading_Before32(deltaTime);
+}
+
+// This is for backwards compatibility. If you need to make changes,
+// then make them in UpdateFading which is used with Unity 3.2 and later content
+bool AnimationState::UpdateFading_Before32(float deltaTime)
+{
+	// We are now fading out!
+	if (m_Time > m_StopTime - m_FadeOutLength && !m_IsFadingOut)
+	{
+		SetWeightTarget(0.0F, m_FadeOutLength, true);
+		m_IsFadingOut = true;
+
+		///@TODO: Apply fractional delta based on current time!
+		//		A fadeout should have been started at m_StopTime - m_FadeOutLength but we exceeded it by some time
+		//		We should apply the fraction by what we exceeded it to the weight!
+		//		ApplyWeightDeltaFraction(m_Time - m_FadeOutLength);
+	}
+
+	bool didStopAtEnd = false;
+	// Update blend target
+	if (m_FadeBlend)
+		didStopAtEnd = UpdateBlendingWeight(deltaTime, false);
+
+	return didStopAtEnd;
+}
+
+bool AnimationState::UpdateFading(float deltaTime)
+{
+	bool didStopAtEnd = false;
+
+	// We are now fading out!
+	if (!m_IsFadingOut && UseStopTime())
+	{
+		Assert(m_FadeOutLength >= 0);
+
+		const bool forward = m_Speed >= 0;
+		const float dt = forward ? m_Time - (m_StopTime - m_FadeOutLength) : (m_StopTime + m_FadeOutLength) - m_Time;
+		if (dt > 0)
+		{
+			SetWeightTarget(0.0F, m_FadeOutLength, true);
+			m_IsFadingOut = true;
+
+			if (UseUnity35AnimationFixes())
+			{
+				// Applying fractional delta based on current time!
+				// A fadeout has been started at m_StopTime - m_FadeOutLength but we exceeded it by some time,
+				// so we need to apply delta on m_Weight
+				didStopAtEnd = UpdateBlendingWeight(dt, m_FadeOutLength == 0);
+			}
+		}
+	}
+
+	// Update blend target
+	if (m_FadeBlend)
+		didStopAtEnd = UpdateBlendingWeight(deltaTime, false);
+
+	return didStopAtEnd;
+}
+
+bool AnimationState::UpdateBlendingWeight(const float deltaTime, const bool instantBlend)
+{
+	bool didStopAtEnd = false;
+
+	m_Weight += deltaTime * m_WeightDelta;
+
+	// Stop blending and clamp when we reach the target
+	if (instantBlend ||
+		(m_WeightDelta > 0.0F && m_Weight > m_WeightTarget) ||
+		(m_WeightDelta <= 0.0F && m_Weight < m_WeightTarget))
+	{
+		m_Weight = m_WeightTarget;
+		m_FadeBlend = 0;
+		m_IsFadingOut = 0;
+		if (m_StopWhenFadedOut)
+		{
+			m_UnstoppedLastWrappedTime = m_WrappedTime;
+			Stop();
+			didStopAtEnd = true;
+		}
+	}
+	else
+	{
+		#if !UNITY_RELEASE
+		AssertMsg((m_WrapMode != kDefaultWrapMode && m_WrapMode != kClamp) || m_Time < GetLength() + 0.05F, "Time is out of range: %f < %f", m_Time, GetLength());
+		#endif
+	}
+
+	return didStopAtEnd;
+}
+
+void AnimationState::DidModifyAnimationClip (AnimationClip* clip, AnimationStateList& states)
+{
+	AnimationStateList::iterator i;
+	for (i=states.begin();i!=states.end();i++)
+	{
+		AnimationState& state = **i;
+		if (clip == NULL)
+		{
+			state.m_Clip = NULL;
+			state.m_HasAnimationEvent = 0;
+		}
+		else
+		{
+			AssertIf (state.m_Clip != clip);
+			state.m_CachedRange = state.m_Clip->GetRange();
+			AssertIf(!IsFinite(state.m_CachedRange.first) || !IsFinite(state.m_CachedRange.second));
+			state.m_HasAnimationEvent = !state.m_Clip->GetEvents().empty();
+		}
+
+		PROFILER_AUTO(gModifyAnimationClip, NULL)
+
+		state.m_DirtyMask |= kRebindDirtyMask;
+	}
+
+	if (clip == NULL)
+		states.clear();
+}
+
+///@TODO: Import pipeline should allow reimporting clips while in playmode. For this we just need to make them reuse the animation clip asset
+///       and call DidChangeClip
+
+void AnimationState::Init(const UnityStr& name, AnimationClip* clip, double globalTime, int wrap, bool isClone )
+{
+	AssertIf (m_Clip);
+	AssertIf (m_Curves);
+	AssertIf (m_AnimationClipNode.IsInList());
+
+	m_IsClone = isClone;
+	m_Clip = clip;
+	m_HasAnimationEvent = 0;
+	if (m_Clip)
+	{
+		m_CachedRange = m_Clip->GetRange();
+		AssertIf(!IsFinite(m_CachedRange.first) || !IsFinite(m_CachedRange.second));
+		m_Clip->AddAnimationState(m_AnimationClipNode);
+		m_Name = name;
+		m_HasAnimationEvent = !m_Clip->GetEvents().empty();
+	}
+
+	m_BlendMode = kBlend;
+	m_Weight = 0.0F;
+	m_FadeBlend = 0;
+	m_StopWhenFadedOut = 0;
+	m_IsFadingOut = 0;
+	m_AutoCleanup = 0;
+	m_ShouldCleanup = 0;
+	m_FadeOutLength = 0.0F;
+	m_WrappedTime = 0.0F;
+	m_AnimationEventIndex = -1;
+	m_AnimationEventState = kAnimationEventState_Search;
+	m_Time = 0;
+//	m_WeightDelta = 0.0F;
+//	m_UnstoppedLastWeight = 0.0F;
+//	m_UnstoppedLastWrappedTime = 0.0F;
+//	m_WeightTarget = 1.0F;
+//	m_WeightDelta = 0.0F;
+	m_LastGlobalTime = globalTime;
+
+	m_Layer = 0;
+	m_SyncedSpeed = m_Speed = 1.0F;
+	m_Enabled = false;
+
+	SetWrapMode(wrap);
+	SetTime(0.0F);
+
+//	m_GlobalStopTime = std::numeric_limits<float>::infinity();
+
+	m_DirtyMask = kRebindDirtyMask | kLayersDirtyMask;
+}
+
+void AnimationState::SetupStopTime()
+{
+	bool forward = UseUnity32AnimationFixes() ? m_Speed >= 0 : true;
+
+	m_StopTime = UseStopTime() ?
+		(forward ? m_CachedRange.second : m_CachedRange.first) :
+		(forward ? std::numeric_limits<float>::infinity() : -std::numeric_limits<float>::infinity());
+}
+
+void AnimationState::SetWrapMode (int wrap)
+{
+	m_WrapMode = wrap;
+
+	// we need to update m_WrappedTime, because we can set time first and then wrap mode
+	m_WrappedTime = WrapTime(m_Time, m_CachedRange, m_WrapMode);
+	DebugAssertIf(!IsFinite(m_Time) || !IsFinite(m_WrappedTime));
+
+	SetupStopTime();
+}
+
+void AnimationState::SetEnabled (bool enabled)
+{
+	if (enabled && !m_Enabled)
+		m_LastGlobalTime = GetCurTime();
+	m_Enabled = enabled;
+}
+
+void AnimationState::AddMixingTransform(Transform& transform, bool recursive)
+{
+	m_MixingTransforms.insert(std::make_pair(PPtr<Transform> (&transform), recursive));
+	m_DirtyMask |= kRebindDirtyMask;
+
+	PROFILER_AUTO(gAddMixingTransform, NULL)
+}
+
+void AnimationState::RemoveMixingTransform(Transform& transform)
+{
+	MixingTransforms::iterator it = m_MixingTransforms.find(PPtr<Transform>(&transform));
+	if (it != m_MixingTransforms.end())
+		m_MixingTransforms.erase(it);
+	else
+	{
+		ErrorStringMsg("RemoveMixingTransform couldn't find transform '%s' in a list of mixing transforms. "
+			"You can only remove transforms that have been added through AddMixingTransform", transform.GetName());
+	}
+	m_DirtyMask |= kRebindDirtyMask;
+
+	PROFILER_AUTO(gRemoveMixingTransform, NULL)
+}
+
+
+// TODO : this looks a bit expensive: it's iterating hierarchy every time
+bool AnimationState::ShouldMixTransform (Transform& transform)
+{
+	if (m_MixingTransforms.empty())
+		return true;
+
+	for (MixingTransforms::iterator i=m_MixingTransforms.begin();i != m_MixingTransforms.end();i++)
+	{
+		if (i->second)
+		{
+			Transform* root = i->first;
+			if (root && IsChildOrSameTransform(transform, *root))
+				return true;
+		}
+		else
+		{
+			if (i->first == PPtr<Transform> (&transform))
+				return true;
+		}
+	}
+
+	return false;
+}
+
+void AnimationState::Stop ()
+{
+	if ( m_Enabled && m_AutoCleanup )
+		m_ShouldCleanup = true;
+
+	m_Enabled = false;
+	SetTime(0.0F);
+	m_FadeBlend = 0;
+	m_StopWhenFadedOut = 0;
+}
+
+void AnimationState::SetupUnstoppedState()
+{
+	std::swap(m_WrappedTime, m_UnstoppedLastWrappedTime);
+	m_UnstoppedLastWeight = m_Weight;
+	// HACK: VERY ugly way of making sure the last frame of an animation gets accounted into the final position. was 1.0f but this
+	// gave problems when crossfading since the state that should no longer contribute, suddently had a weight of 1 for one frame
+	// We need to redo some of the logic in here at some point
+	m_Weight = kReallySmallWeight*1.001f;
+	m_Enabled = true;
+}
+
+void AnimationState::CleanupUnstoppedState()
+{
+	std::swap(m_WrappedTime, m_UnstoppedLastWrappedTime);
+	m_Weight = m_UnstoppedLastWeight;
+	m_Enabled = false;
+}
+
+bool AnimationState::UseUnity32AnimationFixes()
+{
+	return IS_CONTENT_NEWER_OR_SAME(kUnityVersion3_2_a1);
+}
+
+bool AnimationState::UseUnity34AnimationFixes()
+{
+	return IS_CONTENT_NEWER_OR_SAME(kUnityVersion3_4_a1);
+}
+
+bool AnimationState::UseUnity35AnimationFixes()
+{
+	return IS_CONTENT_NEWER_OR_SAME(kUnityVersion3_5_a1);
+}
+