Beispiel #1
0
        //used Time.FixedDeltaTime instead of delta time (for important physics/gameplay things)
        public static IEnumerator DoLerpFixedTimeRoutine(Lerpable code, float time, bool reverse = false)
        {
            if (!reverse)
            {
                float timeElapsed = 0;
                while (timeElapsed < time)
                {
                    code(timeElapsed / time);
                    yield return(new WaitForFixedUpdate());

                    timeElapsed += Time.fixedDeltaTime;
                }
            }
            else
            {
                float timeRemaining = time;
                while (timeRemaining > 0)
                {
                    code(timeRemaining / time);
                    yield return(new WaitForFixedUpdate());

                    timeRemaining -= Time.fixedDeltaTime;
                }
            }

            code(reverse ? 0 : 1);
        }
Beispiel #2
0
        public static IEnumerator DoLerpUpdateTimeRoutine(Lerpable code, float time, bool reverse = false)
        {
            if (!reverse)
            {
                float timeElapsed = 0;
                while (timeElapsed < time)
                {
                    code(timeElapsed / time);
                    yield return(null);

                    timeElapsed += Time.deltaTime;
                }
            }
            else
            {
                float timeRemaining = time;
                while (timeRemaining > 0)
                {
                    code(timeRemaining / time);
                    yield return(null);

                    timeRemaining -= Time.deltaTime;
                }
            }
        }
Beispiel #3
0
    private static void LerpStep(Lerpable lerpable)
    {
        // position
        var distCovered = (Time.time - lerpable.StartTime) * lerpable.PositionSpeed;
        var fracJourney = distCovered / lerpable.JourneyLength;

        lerpable.InnerGameObject.transform.position = Vector3.Lerp(lerpable.StartPosition, lerpable.TargetPosition, fracJourney);
        // angle
        var angleCovered = (Time.time - lerpable.StartTime) * lerpable.AngleSpeed;
        var angleJourney = angleCovered / lerpable.AngleLength;

        lerpable.InnerGameObject.transform.eulerAngles = Vector3.Lerp(lerpable.StartAngle, lerpable.TargetAngle, angleJourney);
        // scale
        var scaleCovered = (Time.time - lerpable.StartTime) * lerpable.ScaleSpeed;
        var scaleJourney = scaleCovered / lerpable.ScaleLength;

        lerpable.InnerGameObject.transform.localScale = Vector3.Lerp(lerpable.StartScale, lerpable.TargetScale, scaleJourney);

        if (angleJourney > 1.0f &&
            lerpable.InnerGameObject.transform.position == lerpable.TargetPosition &&
            lerpable.InnerGameObject.transform.localScale == lerpable.TargetScale)
        {
            lerpable.Lerping = false;
        }
    }
    protected IEnumerator Lerperate(Lerpable lerpable)
    {
        while (lerpable.lerping)
        {
            lerpable.curve = curve;
            lerpable.Update();
            yield return(new WaitForSeconds(updateRate));
        }

        lerpable.SetToEnd();

        //if (!string.IsNullOrEmpty(lerpable.message))
        //    RoyalHerald.TriggerEvent(lerpable.message);
        if (lerpables != null)
        {
            lerpables.Remove(lerpable);
        }
    }
Beispiel #5
0
        //same, but run the lerp code independent of any timewarping
        public static IEnumerator DoLerpRealtimeRoutine(Lerpable code, float time, bool reverse = false)
        {
            float realStartTime = Time.realtimeSinceStartup;
            float realEndTime   = realStartTime + time;

            if (!reverse)
            {
                while (Time.realtimeSinceStartup < realEndTime)
                {
                    code((Time.realtimeSinceStartup - realStartTime) / time);
                    yield return(null);
                }
            }
            else
            {
                while (Time.realtimeSinceStartup < realEndTime)
                {
                    code((realEndTime - Time.realtimeSinceStartup) / time);
                    yield return(null);
                }
            }
        }
Beispiel #6
0
        //does a standard coroutine Lerp on a bit of code, from zero to one by default.
        /// <summary>
        /// Calls the code with the current progress over the specified time.
        /// </summary>
        /// <param name="code">The lerpable code to call.</param>
        /// <param name="time">The duration of the lerp.</param>
        /// <param name="callingScript">The <see cref="MonoBehaviour"/> to run the Coroutine on.</param>
        /// <param name="reverse">If <c>True</c>, calls the lerpable from 0 to 1 instead of 1 to zero.</param>
        /// <param name="mode">The time mode to run the Coroutine with.</param>
        /// <returns></returns>
        public static IEnumerator DoLerpRoutine(Lerpable code, float time, MonoBehaviour callingScript, bool reverse = false, Mode mode = Mode.UPDATE)
        {
            IEnumerator routine = null;

            switch (mode)
            {
            case Mode.UPDATE:
                routine = DoLerpUpdateTimeRoutine(code, time, reverse);
                break;

            case Mode.FIXEDUPDATE:
                routine = DoLerpFixedTimeRoutine(code, time, reverse);
                break;

            case Mode.REALTIME:
                routine = DoLerpRealtimeRoutine(code, time, reverse);
                break;
            }
            yield return(callingScript.StartCoroutine(routine));

            code(reverse ? 0 : 1);
        }
Beispiel #7
0
    /// <summary>
    /// Starts a lerp transition for a given game object
    /// </summary>
    /// <param name="gameObject">The game object to move</param>
    /// <param name="targetPosition">The target position of the game object, can be omitted if no transition required</param>
    /// <param name="targetRotation">The target rotation of the game object, can be omitted if no transition required</param>
    /// <param name="targetScale">The target scale of the game object, can be omitted if no transition required</param>
    public static void StartLerp(GameObject gameObject, Vector3 targetPosition = new Vector3(), Vector3 targetRotation = new Vector3(), Vector3 targetScale = new Vector3())
    {
        var lerpable = new Lerpable(gameObject);

        lerpable.StartPosition  = lerpable.InnerGameObject.transform.position;
        lerpable.TargetPosition = targetPosition;

        lerpable.StartAngle  = lerpable.InnerGameObject.transform.eulerAngles;
        lerpable.TargetAngle = targetRotation;

        lerpable.StartScale  = lerpable.InnerGameObject.transform.localScale;
        lerpable.TargetScale = targetScale;

        lerpable.StartTime = Time.time;

        lerpable.JourneyLength = Vector3.Distance(lerpable.StartPosition, lerpable.TargetPosition);
        lerpable.AngleLength   = Vector3.Distance(lerpable.StartAngle, lerpable.TargetAngle);
        lerpable.ScaleLength   = Vector3.Distance(lerpable.StartScale, lerpable.TargetScale);

        lerpable.Lerping = true;

        Lerpables.Add(lerpable);
    }
 /// <summary>
 /// Calls the code with the current progress over the specified time.
 /// </summary>
 /// <param name="code">The lerpable code to call.</param>
 /// <param name="time">The duration of the lerp.</param>
 /// <param name="callingScript">The <see cref="MonoBehaviour"/> to run the Coroutine on.</param>
 /// <param name="reverse">If <c>True</c>, calls the lerpable from 0 to 1 instead of 1 to zero.</param>
 /// <param name="mode">The time mode to run the Coroutine with.</param>
 /// <returns></returns>
 public static Coroutine DoLerp(Lerpable code, float time, MonoBehaviour callingScript, bool reverse = false, Mode mode = Mode.UPDATE)
 {
     return RunIfActiveAndEnabled(callingScript, Routines.DoLerpRoutine(code, time, callingScript, reverse, mode));
 }
 public static IEnumerator DoLerpUpdateTimeRoutine(Lerpable code, float time, bool reverse = false)
 {
     if (!reverse)
     {
         float timeElapsed = 0;
         while (timeElapsed < time)
         {
             code(timeElapsed / time);
             yield return null;
             timeElapsed += Time.deltaTime;
         }
     }
     else
     {
         float timeRemaining = time;
         while (timeRemaining > 0)
         {
             code(timeRemaining / time);
             yield return null;
             timeRemaining -= Time.deltaTime;
         }
     }
 }
Beispiel #10
0
 //does a standard coroutine Lerp on a bit of code, from zero to one by default.
 /// <summary>
 /// Calls the code with the current progress over the specified time.
 /// </summary>
 /// <param name="code">The lerpable code to call.</param>
 /// <param name="time">The duration of the lerp.</param>
 /// <param name="callingScript">The <see cref="MonoBehaviour"/> to run the Coroutine on.</param>
 /// <param name="reverse">If <c>True</c>, calls the lerpable from 0 to 1 instead of 1 to zero.</param>
 /// <param name="mode">The time mode to run the Coroutine with.</param>
 /// <returns></returns>
 public static IEnumerator DoLerpRoutine(Lerpable code, float time, MonoBehaviour callingScript, bool reverse = false, Mode mode = Mode.UPDATE)
 {
     IEnumerator routine = null;
     switch (mode)
     {
         case Mode.UPDATE:
             routine = DoLerpUpdateTimeRoutine(code, time, reverse);
             break;
         case Mode.FIXEDUPDATE:
             routine = DoLerpFixedTimeRoutine(code, time, reverse);
             break;
         case Mode.REALTIME:
             routine = DoLerpRealtimeRoutine(code, time, reverse);
             break;
     }
     yield return callingScript.StartCoroutine(routine);
     code(reverse?0:1);
 }
Beispiel #11
0
 //same, but run the lerp code independent of any timewarping
 public static IEnumerator DoLerpRealtimeRoutine(Lerpable code, float time, bool reverse = false)
 {
     float realStartTime = Time.realtimeSinceStartup;
     float realEndTime = realStartTime + time;
     if (!reverse)
     {
         while (Time.realtimeSinceStartup < realEndTime)
         {
             code((Time.realtimeSinceStartup - realStartTime) / time);
             yield return null;
         }
     }
     else
     {
         while (Time.realtimeSinceStartup < realEndTime)
         {
             code((realEndTime - Time.realtimeSinceStartup) / time);
             yield return null;
         }
     }
 }
Beispiel #12
0
        //used Time.FixedDeltaTime instead of delta time (for important physics/gameplay things)
        public static IEnumerator DoLerpFixedTimeRoutine(Lerpable code, float time, bool reverse = false)
        {
            if (!reverse)
            {
                float timeElapsed = 0;
                while (timeElapsed < time)
                {
                    code(timeElapsed / time);
                    yield return new WaitForFixedUpdate();
                    timeElapsed += Time.fixedDeltaTime;
                }
            }
            else
            {
                float timeRemaining = time;
                while (timeRemaining > 0)
                {
                    code(timeRemaining / time);
                    yield return new WaitForFixedUpdate();
                    timeRemaining -= Time.fixedDeltaTime;
                }
            }

            code(reverse ? 0 : 1);
        }
Beispiel #13
0
 /// <summary>
 /// Calls the code with the current progress over the specified time.
 /// </summary>
 /// <param name="code">The lerpable code to call.</param>
 /// <param name="time">The duration of the lerp.</param>
 /// <param name="callingScript">The <see cref="MonoBehaviour"/> to run the Coroutine on.</param>
 /// <param name="reverse">If <c>True</c>, calls the lerpable from 0 to 1 instead of 1 to zero.</param>
 /// <param name="mode">The time mode to run the Coroutine with.</param>
 /// <returns></returns>
 public static Coroutine DoLerp(Lerpable code, float time, MonoBehaviour callingScript, bool reverse = false, Mode mode = Mode.UPDATE)
 {
     return(RunIfActiveAndEnabled(callingScript, Routines.DoLerpRoutine(code, time, callingScript, reverse, mode)));
 }
Beispiel #14
0
 /// <summary>
 /// Gets a mobility related value
 /// </summary>
 /// <param name="l">lerpable data</param>
 /// <returns>The resulting value, adjusted for mobility</returns>
 public float GetLerpValue(Lerpable l)
 {
     return(Config.Lerpables[l].Apply(this.Mobility / 100));
 }