CODEWITHSUNDEEP
unity-game-engine
Arnold
Arnold

Reputation: 59

UNITY | Update or InvokeRepeating?

I use many timers in my Unity project, they done like this:

void Update()
{
    timer -= Time.deltaTime;
    if(timer < 0)
    {
        DoSomething();
    }
}

And in every google link they looks like this. But today i found (im newbie) InvokeRepeating(); method.

So here is updated timer

int timer = 60; 

void Start()
{
    InvokeRepeating("Timer", 1f, 1f);
}

void Timer()
{
    timer -= 1;
}

So why people change timers in Update()?

And which method less inpact on performance?

Upvotes: 0

Views: 6920

Answers (2)

derHugo
derHugo

Reputation: 90679

Depends!

As usual in programming there are most of the time multiple valid solutions for a problem.

In my eyes the bigest difference is that InvokeRepeating is also working on inactive GameObjects or disabled Components while Update is only called while the object is active and the component enabled.

Note, however, that your current examples do different things. To make them equivalent it should look like either

void Start()
{
    timer = 1f;
}

void Update()
{
    timer -= Time.deltaTime;
    if(timer < 0)
    {
        timer = 1f;
        DoSomething();
    }
}

or

void Start()
{
    InvokeRepeating(nameof(DoSomething), 1f, 1f);
}

Btw: A third basically equivalent solution would be a Coroutine (which is basically a temporary Update method - in fact the MoveNext call gets executed right after the Update would)

// Yes, Start can be an IEnumertaor and is in this case internally implicitly started as Coroutine!
IEnumerator Start() 
{
    while(true)
    {
        yield return new WaitForSeconds(1f);

        DoSeomthing();
    }
}

As mentioned by Kuruchy: There is also a difference in behavior related to the timeScale.

  • Update: since it uses Time.deltaTime to decrease the timer it will be affected by the time scale

    → in order to avoid this you would need to use Time.unscaledDeltaTime instead. But afaik still if setting Time.timeScale = 0; then Update isn't called at all.

  • Coroutine: Similar to update the WaitForSeconds is also timeScale dependent.

    → in roder to avoid this you would need to use WaitForSecondsRealitme but afaik even then setting Time.timeScale = 0; would lead to the routine not getting called at all.

  • InvokeRepeating: Fromt he docs I can only see that

    This does not work if you set the time scale to 0.

    not sure how it reacts to the timescale though but I would actually guess the same. Though, here there is no real work around like for the other two.

Performance wise you most probably don't even have to care! I guess it would be over-optimizing.

However my guess would be that Update is actually slightly faster since there you already know the method reference while when using InvokeRepeating you are passing it as a string which is additionally error prone and means that internally Unity has to find that method first.

Upvotes: 4

Sygan
Sygan

Reputation: 74

Without going into too much detail is because of the performance.

The Update() method is invoked internally by Unity and they've done a pretty good job in optimizing it.

InvokeRepeating is much slower in comparison. First of all because the initial method invocation is using the Reflection to find the method you want to start and it's respective calls also take more time than Update. And you want to avoid using Reflection in your code as much as possible.

Here is nice, short article in which the tests were performed between these two methods - http://www.kittehface.com/2017/09/unity-performance-with-invokerepeating.html

Upvotes: 3

Related Questions