public override void CoreUpdate()
    {
        optimizedUnscaledDeltaTime = CoreTime.optimalUnscaledDeltaTime;
        trueDeltaTime     = CoreTime.trueUnscaledDeltaTime;
        previousDeltaTime = CoreTime.previousDeltaTime;
        slowdownType      = CoreTime.slowdownType;

        if (CoreTime.containsHeartbeatStutter)
        {
            stuttersCatched++;
            curFrames = 0;

            stutteredTimings.Add(new Vector2(CoreTime.previousDeltaTime, trueDeltaTime));
        }

        curFrames++;
        if (curFrames >= framesToClearStutters)
        {
            stuttersCatched = 0;
            stutteredTimings.Clear();
        }
    }
示例#2
0
    /// <summary>
    /// Should be called first.
    /// </summary>
    public override void CoreUpdate()
    {
        m_containsHeartbeatStutter = false;
        bool closeToTargetFramerate = false;
        bool isFramerateUncapped    = false;

        m_perfectDeltaTime = (float)QualitySettings.vSyncCount / (float)Screen.currentResolution.refreshRate;
        if (QualitySettings.vSyncCount == 0)
        {
            isFramerateUncapped = true;
        }

        m_trueUnscaledDeltaTime = Time.unscaledDeltaTime;
        m_trueDeltaTime         = m_trueUnscaledDeltaTime * timeScale;

        if (!isFramerateUncapped)
        {
            if (m_trueUnscaledDeltaTime > internal_previousDeltaTime * TIME_MULTIPLIER_HEARTBEATSTUTTER_DETECT_UPPER || m_trueUnscaledDeltaTime < internal_previousDeltaTime * TIME_MULTIPLIER_HEARTBEATSTUTTER_DETECT_LOWER)
            {
                m_containsHeartbeatStutter = true;
            }

            if (m_trueUnscaledDeltaTime > m_perfectDeltaTime * TIME_MULTIPLIER_FOR_STABILIZE_LOWER && m_trueUnscaledDeltaTime < m_perfectDeltaTime * TIME_MULTIPLIER_FOR_STABILIZE_UPPER)
            {
                closeToTargetFramerate = true;
            }

            //We have no stutter and no slowdown.
            if (!m_containsHeartbeatStutter && closeToTargetFramerate)
            {
                m_optimalDeltaTime         = m_perfectDeltaTime * m_timeScale;
                m_optimalUnscaledDeltaTime = m_perfectDeltaTime;
                m_slowdownType             = CoreTimeSlowdownTypeEnum.Perfect;
            }
            //We have slowdown
            else if (!m_containsHeartbeatStutter && !closeToTargetFramerate)
            {
                m_optimalDeltaTime         = m_trueDeltaTime;
                m_optimalUnscaledDeltaTime = m_trueUnscaledDeltaTime;
                m_slowdownType             = CoreTimeSlowdownTypeEnum.Slowdown;
            }
            //We have stutter
            else
            {
                m_optimalDeltaTime         = m_perfectDeltaTime * m_timeScale;
                m_optimalUnscaledDeltaTime = m_perfectDeltaTime;
                m_slowdownType             = CoreTimeSlowdownTypeEnum.Stutter;
            }
        }
        else
        {
            m_optimalDeltaTime         = m_trueDeltaTime;
            m_optimalUnscaledDeltaTime = m_trueUnscaledDeltaTime;
            m_slowdownType             = CoreTimeSlowdownTypeEnum.Uncapped;
        }

        if (m_timeSinceLastBreak > TIME_RESET_THRESHOLD)
        {
            m_timeSinceLastBreak -= TIME_RESET_THRESHOLD;
        }

        m_timeSinceLastBreak += m_optimalDeltaTime;
        m_time += m_optimalDeltaTime;

        m_previousDeltaTime        = internal_previousDeltaTime;
        internal_previousDeltaTime = m_trueUnscaledDeltaTime;
    }