Translating thousands of gameobjects

Unity Engine
1

I have written a script that spawns thousands of game objects at a specified frequency and translates them towards the player (they are destroyed after going into a destroy zone).

The code to translate objects is this:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ObjectMove : MonoBehaviour {

    public float speed= 20f;
    public bool rot;
    public float DegPerSecond;
    float dir = -1;

    // Use this for initialization
    void Start () {
       
    }
   
    // Update is called once per frame
    void Update () {
        transform.Translate (new Vector3 (0, 0, speed * dir * Time.deltaTime),Space.World);
        if (rot)
            transform.Rotate (0, Time.deltaTime*DegPerSecond, 0,Space.Self);
       
    }  
}

Now actually this script is attached to a prefab and my spawner script spawns thousands of prefabs in the scene. This means since the prefabs already have this code attached, the moment they are instantiated, they start moving towards the player.

The problem I am getting is high CPU usage by this script. I ran a deep profile and found that 70% of the CPU is utilized by this script. Also, time in ms used is pretty large (22 ms) by the update function of this script alone.

Is there any alternative to moving (translate and rotate) thousands of instantiated prefabs in the scene with less CPU overhead?

2

Yes, the best alternative is an instancing pool, which is similar to an object pool but does not have all of those game objects. With an instancing pool, you use an array of a custom struct to track where your objects would be if they were gameobjects, but you don’t have the overhead of gameobjects. Then you set up your instancing pool to translate your array of your struct into an arrary of Matrix4x4, so you can feed that information into the DrawMeshInstanced API method. That will reduce the draw calls to one call per DrawMeshInstanced call instead of one draw call per game object. This is how to handle all of the lasers in my space game.

3 Likes
3

I am not getting large draw calls, but the problem is with the script itself. This script is using most of the CPU and reducing performance, as the profiler suggests. I want to translate objects and translation alone is taking huge amount of CPU

4

Can you post a screenshot of a deep profile window?

5

Well how many thousands are you talking about? I’d guess that yes updating say 10,000 objects this way using the callback might well produce a performance impact. You can test using a manager. Kind of a one ring to rule them all.

A single manager receives the callback to its Update method and it in turn loops through all objects translating and rotating them as needed. Should be much faster.

But yeah best to probably post the profiler shots so people can see if they can solve it as is.

1 Like
6

The screenshot is uploaded here:

https://drive.google.com/file/d/0B1Fyh6B2M60zM1RkMTk3bWRKLU0/view

7

I think there was a unite video about teh cost of having many Transform into a scene, I bet the hit is from the transform.
I’ll post the video if I can track back the sequence.

8

at 28:40

9

Using an instancing pool like I described will drastically reduce your CPU and memory usage in addition to reducing draw calls. If you want to deliver hundreds of frames per second with thousands of projectiles onscreen, then you will eventually want to develop an instancing pool.

If you want to try to use a object pool instead of an instancing pool, there is one more trick you can try. Rename the Update function in the script that is attached to all of those gameobjects. For example, change Update to ManualUpdate. That way there is no calling overhead between the Unity engine and the C# code. Then after you have done that, add code to your object pool code to call the ManualUpdate in each of those gameobjects during the object pool’s Update function. NOTE: This will help reduce the CPU usage, but not nearly as much as an instancing pool will do.

Also, if you want to use an object pool, don’t destroy and recreate objects. Just disable/enable pooled objects. That will save you CPU time as well.

10

What do you see if you open “Transform.Rotate()” and “Transform.Translate()”? Their entries are “folded” in deep profile window screenshot, and their “self” entry is around 3.5%.

11

This video is also useful

12

Thanks :slight_smile:

1 Like
13

RE Optimizing the code you posted.

Having an Update override per object has overhead that becomes significant in the thousands, certainly on weaker platforms.

As @ShilohGames mentions: Cheaper if you store all objects in array or list (or child to some root object) and then enumerate all of them calling a DoUpdate func for each.

Also don’t do any new alloc within any per frame function scope if you can help it.

For temp vars that exist for life of function you can declare them at class scope, then at runtime they’re ready to use without any alloc. Also as were in single thread you can declare them static (one instance per process) to preserve mem.

        static Vector3 DoUpdate_v3 = new Vector3(0, 0, 0);
        void DoUpdate()
        {
            DoUpdate_v3.z = speed * dir * Time.deltaTime;
            transform.Translate(DoUpdate_v3, Space.World);
            if (rot)
            {
                transform.Rotate(0, Time.deltaTime * DegPerSecond, 0, Space.Self);
            }
        }

In this case don’t need vector though:

        void DoUpdate()
        {
            transform.Translate(0, 0, speed * dir * Time.deltaTime, Space.World);
            if (rot)
            {
                transform.Rotate(0, Time.deltaTime * DegPerSecond, 0, Space.Self);
            }
        }

I struggle on mobile VR to have alot of stuff happening and holding 60FPS, one trick I also use is modulo clocking. Simple case: on odd frames clock odd array indexes, even frames clock even. This gives a 30Hz clock rate, which is acceptable for alot of stuff even if it’s visibly moving or animated.

Also when you clock like this you can have your DoUpdate func return a bool, if false it means I don’t need clocking again and the clock manager can remove it from the list. Useful for things you want to keep pooled quietly when not being used. Yes this can be done with co routines, but again; they have noticeable overhead and GC alloc.

To implement a clock manager I would advise making all your scripts inherit MY_MonoBehavior, where MY_MonoBehavior is your own wrapper around (inherits) MonoBehavior to which you add a virtual function “DoUpdate”. You override that DoUpdate in the final use case derived class. This way you can keep references to all active clockables in a List<MY_MonoBehavior> and call all their DoUpdates quickly.

1 Like
14

Unity Blog Have a look at this article which talks about the benefits of a manager vs having tons of objects all calling update on their own.

1 Like
15

@ShilohGames Thanks for posting the instanced pool solution. I’m curious about how you manage projectiles which are not in use… since they’re in an array, are you still iterating over non-active projectiles but not doing any logic in the manual update through a bool check? Thanks.

16

In a standard object pool, the pooled objects are disabled when they are not in use. In an instanced pool, there are no objects to disable. There is an array of a custom struct that holds the information about where the projectiles are, which direction they are moving, whether the projectile is active, etc. But the array of the custom struct is not tied to any individual game objects in the scene. The array is literally just data, and the instanced pool class has to act on that data every frame (move stuff, check for collisions, etc) and then pass the information into an array of Matrix4x4 to send into the DrawMeshInstanced API method every frame.

For example, here is a code snippet from a singleton class that manages one type of instanced pool. The complete class has another couple hundred lines of code. I am posting this snippet to help explain the data model within the class.

    public struct LaserProjectile
    {
        public Vector3 currentPosition;
        public Vector3 oldPosition;
        public Quaternion rotation;
        public Vector3 movementVector;
        public bool active;
        public GameObject FiredBy;
        public float timeToExpire;
    } // end struct

    private LaserProjectile[] ProjectileArray;
    private int projectileArraySize = 1500;

    private bool boolReceiveShadows = false;
    private MaterialPropertyBlock materialProperty;
    private Matrix4x4[] MatrixArray;
    private int matrixSize = 500;

The Update function in the instanced pool handles the changes to data and populating and submitting the draw information through DrawMeshInstanced. In the code example I posted above, the projectile array is longer than the Matrix4x4 array, so the Update function needs to do multiple submissions to the drawing API. For performance reasons, the same Matix4x4 array is re-used each time. Only items marked as active in the projectile array are submitted to the drawing API.

Each type of projectile gets its own instanced pool, so things like damage per projectile and linear speed are defined at the class level instead of per projectile. In my current game, there are dozens of instanced pools set up this way and then attached to a single object in the scene.

And there is a public function called FireWeapon that lets ships and turrets add another projectile to the array. The added projectile is placed in the first inactive item within the custom struct array (ProjectileArray in my case).

3 Likes
17

@ShilohGames Thanks for the detailed explanation. I don’t think I would have ever conceived of pooling a lot of projectiles in this way, so I appreciate you sharing this.

18

this.transform actually calls GetComponent() so you could also store your own transform in a script variable at Start() and use it in your Update()

19

Nope. It doesn’t call GetComponent() at all. It does ask for the transform from the c++ engine, though, so caching it is faster. Decompiled, it looks like this:

public extern Transform transform
{
    [GeneratedByOldBindingsGenerator]
    [MethodImpl(MethodImplOptions.InternalCall)]
    get;
}

A final optimization: from 5.6 and forward, Unity’s got a Transform.SetPositionAndRotation method. It’s faster than setting the position and rotation at the same time, as both of those triggers a re-caluclation of the same Matix4x4 . Of course, if you’re doing the smart thing @ShilohGames is recommending, it won’t be relevant.

1 Like
20

Thank you @ShilohGames ,
Discovered DrawMeshInstanced and now understand the concept of using it thanks to your post.

I will try throwing some stuff around on mobile using this, see how it goes, I’m guessing for small things it’s going to be fast, bigger things may cause lots of overdraw because no Z sorting:

Wonder if the Matrix4x4[ ] can be managed in script to reduce overdraw and do frustum culling. I’m guessing instance render order is up from [0] through the array?

EDIT: Disputed Space is EPIC! DrawMeshInstaced is giving you a crazy amount of weapon action!!:sunglasses: