port from perforce

aiwaz/Aiwaz/AnimationManager/AnimationManager.cpp

@@ -0,0 +1,162 @@
+#include "stdafx.h"
+#include "ITimeline.h"
+#include "AnimationManager.h"
+
+
+AnimationManager::AnimationManager(IEngine& argEngine)
+	: m_Engine(argEngine)
+	, m_PreviousDemoTime(0.0)
+	, m_PreviousRealTime(0.0)
+{
+}
+
+
+AnimationManager::~AnimationManager()
+{
+}
+
+
+void AnimationManager::AddDemoTimeAnimation(double argBeginTime, double argEndTime, IAnimateable* argValue, unsigned int argUserData)
+{
+	m_ForwardSortedAnimations[r_AnimationInterval(argBeginTime, argEndTime)].push_back(std::make_pair(argValue, argUserData));
+	m_BackwardSortedAnimations[r_AnimationInterval(argBeginTime, argEndTime)].push_back(std::make_pair(argValue, argUserData));
+}
+
+
+void AnimationManager::AddRealTimeAnimation(double argBeginTime, double argEndTime, IAnimateable* argValue, unsigned int argUserData)
+{
+	m_RealTimeAnimations[r_AnimationInterval(argBeginTime, argEndTime)].push_back(std::make_pair(argValue, argUserData));
+}
+
+
+void AnimationManager::AddDemoTimeEvent(double argTime, IEvent* argValue, unsigned int argUserData)
+{
+	m_DemoTimeEvents[argTime].push_back(std::make_pair(argValue, argUserData));
+}
+
+
+void AnimationManager::AddRealTimeEvent(double argTime, IEvent* argValue, unsigned int argUserData)
+{
+	m_RealTimeEvents[argTime].push_back(std::make_pair(argValue, argUserData));
+}
+
+
+void AnimationManager::Animate()
+{
+	ITimeline& timeline = m_Engine.get_Timeline();
+	double ld_DemoTime = timeline.get_DemoTime();
+	double ld_RealTime = timeline.get_RealTime();
+	
+	// Gather all active animations, they are the ones that started before now and end after now.
+	// Do this for both the demo time and real time.
+	std::vector<std::pair<IAnimateable*, unsigned int> > lk_ActiveAnimations;
+	std::vector<double> lk_AnimationTimes;
+
+	// Demo time animations: Demo time can go backwards, so search from both directions
+	if (timeline.get_SpeedAndDirection() > 0)
+	{
+		tk_ForwardAnims::iterator lk_Iter = m_ForwardSortedAnimations.begin();
+		for (; lk_Iter != m_ForwardSortedAnimations.end(); ++lk_Iter)
+		{
+			if (lk_Iter->first.m_Begin <= ld_DemoTime && lk_Iter->first.m_End >= ld_DemoTime)
+			{
+				std::vector<std::pair<IAnimateable*, unsigned int> >::iterator lk_AnimIter = lk_Iter->second.begin();
+				for (; lk_AnimIter != lk_Iter->second.end(); ++lk_AnimIter)
+				{
+					lk_ActiveAnimations.push_back(*lk_AnimIter);
+					lk_AnimationTimes.push_back((ld_DemoTime - lk_Iter->first.m_Begin) / (lk_Iter->first.m_End - lk_Iter->first.m_Begin));
+				}
+			}
+
+			if (lk_Iter->first.m_Begin > ld_DemoTime)
+				break;
+		}
+	}
+	else if (timeline.get_SpeedAndDirection() < 0)
+	{
+		tk_BackwardAnims::iterator lk_Iter = m_BackwardSortedAnimations.begin();
+		for (; lk_Iter != m_BackwardSortedAnimations.end(); ++lk_Iter)
+		{
+			if (lk_Iter->first.m_End >= ld_DemoTime && lk_Iter->first.m_Begin <= ld_DemoTime)
+			{
+				std::vector<std::pair<IAnimateable*, unsigned int> >::iterator lk_AnimIter = lk_Iter->second.begin();
+				for (; lk_AnimIter != lk_Iter->second.end(); ++lk_AnimIter)
+				{
+					lk_ActiveAnimations.push_back(*lk_AnimIter);
+					lk_AnimationTimes.push_back((ld_DemoTime - lk_Iter->first.m_Begin) / (lk_Iter->first.m_End - lk_Iter->first.m_Begin));
+				}
+			}
+
+			if (lk_Iter->first.m_End < ld_DemoTime)
+				break;
+		}
+	}
+
+	// Real time animations: The time that we know doesn't allow us to travel to the past, so just check into the future:
+	{
+		tk_ForwardAnims::iterator lk_Iter = m_RealTimeAnimations.begin();
+		for (; lk_Iter != m_RealTimeAnimations.end(); ++lk_Iter)
+		{
+			if (lk_Iter->first.m_Begin <= ld_RealTime && lk_Iter->first.m_End >= ld_RealTime)
+			{
+				std::vector<std::pair<IAnimateable*, unsigned int> >::iterator lk_AnimIter = lk_Iter->second.begin();
+				for (; lk_AnimIter != lk_Iter->second.end(); ++lk_AnimIter)
+				{
+					lk_ActiveAnimations.push_back(*lk_AnimIter);
+					lk_AnimationTimes.push_back((ld_RealTime - lk_Iter->first.m_End) / (lk_Iter->first.m_Begin - lk_Iter->first.m_End));
+				}
+			}
+
+			if (lk_Iter->first.m_Begin > ld_RealTime)
+				break;
+		}
+	}
+
+	// Now that we know what animations correspond to this time, animate them!
+	std::vector<std::pair<IAnimateable*, unsigned int> >::iterator lk_AnimIter = lk_ActiveAnimations.begin();
+	std::vector<double>::iterator lk_TimeIter = lk_AnimationTimes.begin();
+	for (; lk_AnimIter != lk_ActiveAnimations.end(); ++lk_AnimIter, ++lk_TimeIter)
+	{
+		IAnimateable* lr_Animateable_ = lk_AnimIter->first;
+		lr_Animateable_->OnAnimate(*lk_TimeIter, lk_AnimIter->second);
+	}
+
+	// Fire all events that happened since last time:
+	tk_Events::iterator lk_EventIter = m_DemoTimeEvents.begin();
+	for (; lk_EventIter != m_DemoTimeEvents.end(); ++lk_EventIter)
+	{
+		double ld_Time = lk_EventIter->first;
+
+		std::vector<std::pair<IEvent*, unsigned int> >::iterator lk_EventVecIter = lk_EventIter->second.begin();
+		for (; lk_EventVecIter != lk_EventIter->second.end(); ++lk_EventVecIter)
+		{
+			IEvent* lr_Event_ = lk_EventVecIter->first;
+			unsigned int lui_UserData = lk_EventVecIter->second;
+			if (((timeline.get_SpeedAndDirection() > 0) && (ld_Time >= m_PreviousDemoTime && ld_Time <= ld_DemoTime)) ||
+				((timeline.get_SpeedAndDirection() < 0) && (ld_Time <= m_PreviousDemoTime && ld_Time >= ld_DemoTime)))
+			{
+				lr_Event_->OnEvent(lui_UserData);
+			}
+		}
+	}
+
+	lk_EventIter = m_RealTimeEvents.begin();
+	for (; lk_EventIter != m_RealTimeEvents.end(); ++lk_EventIter)
+	{
+		double ld_Time = lk_EventIter->first;
+
+		std::vector<std::pair<IEvent*, unsigned int> >::iterator lk_EventVecIter = lk_EventIter->second.begin();
+		for (; lk_EventVecIter != lk_EventIter->second.end(); ++lk_EventVecIter)
+		{
+			IEvent* lr_Event_ = lk_EventVecIter->first;
+			unsigned int lui_UserData = lk_EventVecIter->second;
+			if (ld_Time >= m_PreviousRealTime && ld_Time <= ld_RealTime)
+			{
+				lr_Event_->OnEvent(lui_UserData);
+			}
+		}
+	}
+
+	m_PreviousDemoTime = ld_DemoTime;
+	m_PreviousRealTime = ld_RealTime;
+}