+Unity Runtime codeHEADmaster

1 files changed, 489 insertions, 0 deletions

diff --git a/Runtime/Input/TimeManager.cpp b/Runtime/Input/TimeManager.cpp
new file mode 100644
index 0000000..faadada
--- /dev/null
+++ b/Runtime/Input/TimeManager.cpp
@@ -0,0 +1,489 @@
+#include "UnityPrefix.h"
+#include "Configuration/UnityConfigure.h"
+#include "TimeManager.h"
+#include <limits>
+#include "Runtime/Serialize/TransferFunctions/SerializeTransfer.h"
+#include "Runtime/Math/FloatConversion.h"
+#include "Runtime/BaseClasses/ManagerContext.h"
+#include "Runtime/Utilities/Utility.h"
+#include "Runtime/BaseClasses/IsPlaying.h"
+#include "Runtime/Misc/BuildSettings.h"
+#include "Runtime/Misc/ReproductionLog.h"
+#include "Runtime/Threads/Thread.h"
+#if SUPPORT_REPRODUCE_LOG
+#include <fstream>
+#endif
+
+using namespace std;
+
+
+#define DEBUG_TIME_MANAGER 0
+
+
+const float kMaximumDeltaTime = 1.0F / 3.0F;
+const float kStartupDeltaTime = 0.02F;
+const float kNewDeltaTimeWeight = 0.2F; // for smoothing
+
+float CalcInvDeltaTime (float dt)
+{
+	if (dt > kMinimumDeltaTime)
+		return 1.0F / dt;
+	else
+		return 1.0F;
+}
+
+TimeManager::TimeHolder::TimeHolder()
+:	m_CurFrameTime(0)
+,	m_LastFrameTime(0)
+,	m_DeltaTime(0)
+,	m_SmoothDeltaTime(0)
+,	m_SmoothingWeight(0)
+,	m_InvDeltaTime(0)
+{
+}
+
+TimeManager::TimeManager (MemLabelId label, ObjectCreationMode mode)
+:	Super(label, mode)
+,	m_CullFrameCount(0)
+{
+	m_SetTimeManually = false;
+	m_UseFixedTimeStep = false;
+
+	m_FixedTime.m_SmoothDeltaTime = m_FixedTime.m_DeltaTime;
+
+	m_TimeScale = 1.0F;
+	m_FixedTime.m_DeltaTime = 0.02F;
+	m_MaximumTimestep = kMaximumDeltaTime;
+	m_LastSyncEnd = 0;
+	ResetTime ();
+}
+
+TimeManager::~TimeManager () {}
+
+inline void CalcSmoothDeltaTime (TimeManager::TimeHolder& time)
+{
+	// If existing weight is zero, don't take existing value into account
+	time.m_SmoothingWeight *= (1.0F - kNewDeltaTimeWeight);
+	time.m_SmoothingWeight += kNewDeltaTimeWeight;
+	// As confidence in smoothed value increases the divisor goes towards 1
+	float normalized = kNewDeltaTimeWeight / time.m_SmoothingWeight;
+	time.m_SmoothDeltaTime = Lerp (time.m_SmoothDeltaTime, time.m_DeltaTime, normalized);
+}
+
+void TimeManager::SetPause(bool pause)
+{
+	m_FirstFrameAfterPause = true;
+}
+
+void TimeManager::Sync (float framerate)
+{
+	double time = GetTimeSinceStartup ();
+	// wait for enough time to pass for the requested framerate
+	if (framerate > 0)
+	{
+		// Wait a bit less (0.1ms), to accomodate for small fluctuations (gives much better result in webplayers)
+		double frameTime = 1.0/(double)framerate - 0.0001;
+		if (!CompareApproximately(time, m_LastSyncEnd) && time - m_LastSyncEnd < frameTime)
+		{
+#if SUPPORT_THREADS
+			Thread::Sleep(frameTime - (time-m_LastSyncEnd));
+#endif
+			int i = 0;
+			double start = GetTimeSinceStartup();
+			// do the last adjustment with a busy wait
+			do
+			{
+				time = GetTimeSinceStartup();
+				if (++i >=  1000)
+				{
+					// When using PerfHUD ES together with the NVIDIA time extension
+					// the time might be stopped, thus causing a diff of 0.
+					if ((time - start) == 0)
+					{
+						m_LastSyncEnd = GetTimeSinceStartup ();
+						return;
+					}
+					// Need to reset "start" here just in case we started to
+					// busy wait and then the time was stopped while busy waiting
+					start = time;
+					i = 0;
+				}
+			}
+			while(time - m_LastSyncEnd < frameTime);
+			m_LastSyncEnd += frameTime;
+			return;
+		}
+	}
+	m_LastSyncEnd = GetTimeSinceStartup ();
+}
+
+void TimeManager::Update ()
+{
+	AssertIf (m_UseFixedTimeStep);
+	m_FrameCount++;
+	m_RenderFrameCount++;
+	if (m_SetTimeManually)
+		return;
+
+	// Capture framerate is always constant
+	if (m_CaptureFramerate > 0)
+	{
+		#if DEBUG_TIME_MANAGER
+		printf_console( "time: setting time using capture framerate of %i, timescale %f\n", m_CaptureFramerate, m_TimeScale );
+		#endif
+		SetTime (m_DynamicTime.m_CurFrameTime + 1.0F / (float)m_CaptureFramerate * m_TimeScale);
+		return;
+	}
+
+	// Don't do anything to delta time the first frame!
+	if (m_FirstFrameAfterReset)
+	{
+		m_FirstFrameAfterReset = false;
+		return;
+	}
+
+	// When coming out of a pause / startup / level load we don't want to have a spike in delta time.
+	// So just default to kStartupDeltaTime.
+	if (m_FirstFrameAfterPause)
+	{
+		m_FirstFrameAfterPause = false;
+		#if DEBUG_TIME_MANAGER
+		printf_console( "time: setting time first frame after pause\n" );
+		#endif
+		SetTime (m_DynamicTime.m_CurFrameTime + kStartupDeltaTime * m_TimeScale);
+		// This is not a real delta time so don't include in smoothed time
+		m_ActiveTime.m_SmoothingWeight = 0.0f;
+		m_DynamicTime.m_SmoothingWeight = 0.0f;
+		return;
+	}
+
+	double time = GetTimeSinceStartup () - m_ZeroTime;
+	m_RealtimeStartOfFrame = time;
+
+	// clamp the delta time in case a frame takes too long.
+	if (time - m_DynamicTime.m_CurFrameTime > m_MaximumTimestep)
+	{
+		#if DEBUG_TIME_MANAGER
+		printf_console( "time: maximum dt (was %f)\n", time - m_DynamicTime.m_CurFrameTime );
+		#endif
+		SetTime (m_DynamicTime.m_CurFrameTime + m_MaximumTimestep * m_TimeScale);
+		return;
+	}
+
+	// clamp the delta time in case a frame goes to fast! (prevent delta time being zero)
+	if (time - m_DynamicTime.m_CurFrameTime < kMinimumDeltaTime)
+	{
+		#if DEBUG_TIME_MANAGER
+		printf_console( "time: minimum dt (was %f)\n", time - m_DynamicTime.m_CurFrameTime );
+		#endif
+		SetTime (m_DynamicTime.m_CurFrameTime + kMinimumDeltaTime * m_TimeScale);
+		return;
+	}
+
+	// Handle time scale
+	if (!CompareApproximately (m_TimeScale, 1.0F))
+	{
+		#if DEBUG_TIME_MANAGER
+		printf_console( "time: time scale path, delta %f\n", time - m_DynamicTime.m_CurFrameTime );
+		#endif
+		float deltaTime = time - m_DynamicTime.m_CurFrameTime;
+		SetTime (m_DynamicTime.m_CurFrameTime + deltaTime * m_TimeScale);
+		return;
+	}
+
+	#if DEBUG_TIME_MANAGER
+	printf_console( "time: set to %f\n", time );
+	#endif
+	m_DynamicTime.m_LastFrameTime = m_DynamicTime.m_CurFrameTime;
+	m_DynamicTime.m_CurFrameTime = time;
+	m_DynamicTime.m_DeltaTime = m_DynamicTime.m_CurFrameTime - m_DynamicTime.m_LastFrameTime;
+	m_DynamicTime.m_InvDeltaTime = CalcInvDeltaTime(m_DynamicTime.m_DeltaTime);
+	CalcSmoothDeltaTime (m_DynamicTime);
+
+	m_ActiveTime = m_DynamicTime;
+}
+
+void TimeManager::SetDeltaTimeHack (float dt)
+{
+	m_ActiveTime.m_DeltaTime = max(dt, kMinimumDeltaTime);
+	m_ActiveTime.m_InvDeltaTime = CalcInvDeltaTime(m_ActiveTime.m_DeltaTime);
+}
+
+void TimeManager::SetTime (double time)
+{
+	AssertIf (m_UseFixedTimeStep);
+//	AssertIf (time - m_DynamicTime.m_CurFrameTime < kMinimumDeltaTime * 0.1F);
+
+	m_DynamicTime.m_LastFrameTime = m_DynamicTime.m_CurFrameTime;
+	m_DynamicTime.m_CurFrameTime = time;
+	m_DynamicTime.m_DeltaTime = m_DynamicTime.m_CurFrameTime - m_DynamicTime.m_LastFrameTime;
+
+	m_DynamicTime.m_InvDeltaTime = CalcInvDeltaTime(m_DynamicTime.m_DeltaTime);
+	CalcSmoothDeltaTime (m_DynamicTime);
+
+	m_ActiveTime = m_DynamicTime;
+
+	// Sync m_ZeroTime with timemanager time
+	m_ZeroTime = GetTimeSinceStartup () - m_DynamicTime.m_CurFrameTime;
+	#if DEBUG_TIME_MANAGER
+	printf_console( "time: set to %f, sync zero to %f\n", time, m_ZeroTime );
+	#endif
+}
+
+#if UNITY_EDITOR
+void TimeManager::NextFrameEditor () {
+	m_RenderFrameCount++;
+}
+#endif
+
+bool TimeManager::StepFixedTime ()
+{
+	if (m_FixedTime.m_CurFrameTime + m_FixedTime.m_DeltaTime > m_DynamicTime.m_CurFrameTime && !m_FirstFixedFrameAfterReset)
+	{
+		m_ActiveTime = m_DynamicTime;
+		m_UseFixedTimeStep = false;
+
+		return false;
+	}
+
+	m_FixedTime.m_LastFrameTime = m_FixedTime.m_CurFrameTime;
+	if (!m_FirstFixedFrameAfterReset)
+		m_FixedTime.m_CurFrameTime += m_FixedTime.m_DeltaTime;
+
+	m_ActiveTime = m_FixedTime;
+	m_UseFixedTimeStep = true;
+	m_FirstFixedFrameAfterReset = false;
+
+	return true;
+}
+
+void TimeManager::ResetTime ()
+{
+	AssertIf (m_UseFixedTimeStep);
+	m_DynamicTime.m_CurFrameTime = 0.0F;
+	m_DynamicTime.m_LastFrameTime = 0.0F;
+	if (IsWorldPlaying())
+	{
+		m_DynamicTime.m_DeltaTime = 0.02F;
+		m_DynamicTime.m_InvDeltaTime = 1.0F / m_DynamicTime.m_DeltaTime;
+	}
+	else
+	{
+		m_DynamicTime.m_DeltaTime = 0.0F;
+		m_DynamicTime.m_InvDeltaTime = 0.0F;
+	}
+	m_DynamicTime.m_SmoothDeltaTime = 0.0F;
+	m_DynamicTime.m_SmoothingWeight = 0.0F;
+
+	m_FixedTime.m_CurFrameTime = 0.0F;
+	m_FixedTime.m_LastFrameTime = 0.0F;
+	// Dont erase the fixed delta time
+	m_FixedTime.m_InvDeltaTime = 1.0F / m_FixedTime.m_DeltaTime;
+
+	m_ActiveTime = m_DynamicTime;
+
+	m_FirstFrameAfterReset = true;
+	m_FirstFrameAfterPause = true;
+	m_FirstFixedFrameAfterReset = true;
+
+	m_FrameCount = 0;
+	m_RenderFrameCount = 0;
+	m_ZeroTime = GetTimeSinceStartup ();
+	m_RealZeroTime = m_ZeroTime;
+	#if DEBUG_TIME_MANAGER
+	printf_console( "time: startup, zero time %f\n", m_RealZeroTime );
+	#endif
+	m_LevelLoadOffset = 0.0F;
+	m_CaptureFramerate = 0;
+	m_RealtimeStartOfFrame = 0.0;
+}
+
+template<class TransferFunction>
+void TimeManager::Transfer (TransferFunction& transfer)
+{
+	Super::Transfer (transfer);
+	transfer.Transfer (m_FixedTime.m_DeltaTime, "Fixed Timestep", kSimpleEditorMask);
+	transfer.Transfer (m_MaximumTimestep, "Maximum Allowed Timestep", kSimpleEditorMask);
+	transfer.Transfer (m_TimeScale, "m_TimeScale", kSimpleEditorMask);
+}
+
+void TimeManager::SetFixedDeltaTime (float fixedStep)
+{
+	fixedStep = clamp<float>(fixedStep, 0.0001F, 10.0F);
+	m_FixedTime.m_DeltaTime = fixedStep;
+	m_FixedTime.m_InvDeltaTime = 1.0F / m_FixedTime.m_DeltaTime;
+	m_FixedTime.m_SmoothDeltaTime = m_FixedTime.m_DeltaTime;
+
+	SetMaximumDeltaTime(m_MaximumTimestep);
+}
+
+void TimeManager::SetMaximumDeltaTime (float maxStep)
+{
+	m_MaximumTimestep = max<float>(maxStep, m_FixedTime.m_DeltaTime);
+}
+
+void TimeManager::AwakeFromLoad (AwakeFromLoadMode awakeMode)
+{
+	Super::AwakeFromLoad(awakeMode);
+
+	m_FixedTime.m_InvDeltaTime = 1.0F / m_FixedTime.m_DeltaTime;
+	m_FixedTime.m_SmoothDeltaTime = m_FixedTime.m_DeltaTime;
+}
+
+void TimeManager::CheckConsistency ()
+{
+	Super::CheckConsistency ();
+
+	m_FixedTime.m_DeltaTime = clamp<float>(m_FixedTime.m_DeltaTime, 0.0001F, 10.0F);
+	m_MaximumTimestep = max<float>(m_MaximumTimestep, m_FixedTime.m_DeltaTime);
+}
+
+void TimeManager::DidFinishLoadingLevel ()
+{
+	m_LevelLoadOffset = -m_DynamicTime.m_CurFrameTime;
+	// Trying to reconstruct what was intended here, this seems plausible:
+	m_FirstFrameAfterPause = m_FirstFrameAfterReset = true;
+}
+
+void TimeManager::SetTimeScale (float scale) {
+	bool outOfRange = scale <= 100.0f && scale >= 0.0f;
+	if (!IS_CONTENT_NEWER_OR_SAME(kUnityVersion4_2_a1))
+		outOfRange = scale < 100;
+	
+	if (outOfRange)
+	{
+		m_TimeScale = scale;
+		SetDirty ();
+	}
+	else
+	{
+		ErrorString ("Time.timeScale is out of range. Needs to be between 0 and 100.");
+	}
+}
+
+#if SUPPORT_REPRODUCE_LOG
+
+void TimeManager::ReadLog (std::ifstream& in)
+{
+	if (!CheckReproduceTag("Time", in))
+	{
+		FailReproduction("Error reading reproduce log");
+		return;
+	}
+
+	ReadFloat(in, m_DynamicTime.m_CurFrameTime);
+	ReadFloat(in, m_DynamicTime.m_LastFrameTime);
+	ReadFloat(in, m_DynamicTime.m_DeltaTime);
+	ReadFloat(in, m_DynamicTime.m_SmoothDeltaTime);
+	ReadFloat(in, m_DynamicTime.m_InvDeltaTime);
+	ReadFloat(in, m_RealtimeStartOfFrame);
+
+	m_ActiveTime = m_DynamicTime;
+}
+
+void TimeManager::WriteLog (std::ofstream& out)
+{
+	// In the web player WebScripting.cpp injects the first new line for the frame
+	#if !WEBPLUG
+	out << std::endl;
+	#endif
+
+	out << "Time" << std::endl;
+	WriteFloat(out, m_DynamicTime.m_CurFrameTime); out << " ";
+	WriteFloat(out, m_DynamicTime.m_LastFrameTime); out << " ";
+	WriteFloat(out, m_DynamicTime.m_DeltaTime); out << " ";
+	WriteFloat(out, m_DynamicTime.m_SmoothDeltaTime); out << " ";
+	WriteFloat(out, m_DynamicTime.m_InvDeltaTime); out << " ";
+	WriteFloat(out, m_RealtimeStartOfFrame); out << std::endl;
+
+	m_ActiveTime = m_DynamicTime;
+}
+
+double TimeManager::GetRealtime()
+{
+	#if SUPPORT_REPRODUCE_LOG
+
+	if (RunningReproduction() && (GetReproduceVersion() == 1 || GetReproduceVersion() == 2))
+	{
+		return m_RealtimeStartOfFrame;
+	}
+
+	if (GetReproduceMode() == kPlaybackReproduceLog)
+	{
+		std::ifstream& in = *GetReproduceInStream();
+
+		if (!CheckReproduceTag("RealTime", in))
+		{
+			ErrorString("Grabbing realtime but there are no realtime calls recorded");
+			return m_RealtimeStartOfFrame;
+		}
+
+		double realtime;
+		ReadBigFloat(in, realtime);
+
+		return realtime;
+	}
+	else if (RunningReproduction())
+	{
+		double realtime = GetTimeSinceStartup() - m_RealZeroTime;
+
+		std::ofstream& out = *GetReproduceOutStream();
+		out << "RealTime ";
+		WriteBigFloat(out, realtime);
+		out << std::endl;
+
+		return realtime;
+	}
+	#endif
+	double realtime = GetTimeSinceStartup() - m_RealZeroTime;
+	return realtime;
+}
+#else
+double TimeManager::GetRealtime()
+{
+	return GetTimeSinceStartup() - m_RealZeroTime;
+}
+#endif
+
+#if ENABLE_CLUSTER_SYNC
+template<class TransferFunc>
+void TimeManager::ClusterTransfer (TransferFunc& transfer)
+{
+    TRANSFER(m_DynamicTime.m_CurFrameTime);
+    TRANSFER(m_DynamicTime.m_LastFrameTime);
+    TRANSFER(m_DynamicTime.m_DeltaTime);
+    TRANSFER(m_DynamicTime.m_SmoothDeltaTime);
+    TRANSFER(m_DynamicTime.m_InvDeltaTime);
+    TRANSFER(m_RealtimeStartOfFrame);
+    TRANSFER(m_TimeScale);
+}
+#endif
+
+
+
+#if UNITY_ANDROID || UNITY_NACL
+#include <sys/time.h>
+
+inline double clock_gettime_to_double ()
+{
+	timespec time;
+	clock_gettime(CLOCK_MONOTONIC, &time);
+	return time.tv_sec + (double)time.tv_nsec * 0.000000001;
+}
+
+double TimeSinceStartupImpl ()
+{
+	static double sStartTime = 0;
+
+	if (sStartTime == 0)
+		sStartTime = clock_gettime_to_double ();
+
+	return clock_gettime_to_double () - sStartTime;
+}
+#endif
+
+
+IMPLEMENT_CLASS (TimeManager)
+IMPLEMENT_OBJECT_SERIALIZE (TimeManager)
+IMPLEMENT_CLUSTER_SERIALIZE(TimeManager)
+GET_MANAGER (TimeManager)