How to find inactive objects using GameObject.Find(" ") in Unity3D?

Question

I needed to find inactive objects in Unity3D using C#.

I have 64 objects, and whenever I click a button then it activates / inactivates objects for the corresponding button at runtime. How can I find inactive objects at this time?

Answer 1

Returns object that is than matches by name

 public T GetComponentType<T>(string name, string parent) where T : Component
{
    T[] col = GameObject.Find(parent).GetComponentsInChildren<T>(true);
    foreach (var item in col)
    {
        if (item.name == name)
        {
//Found correct one
            return item;
        }
    }
//unable to find
    return null;
}

Answer 2

Since Unity 2020

For Unity 2023, see this answer: https://stackoverflow.com/a/77081397/2336212

In the years since this question was asked, Unity put in the exact thing you need. At least, the exact thing I needed. Posting here for future peoples.

To find an object of a certain type whether it's on an active or inactive GameObject, you can use FindObjectsOfType<T>(true)

Objects attached to inactive GameObjects are only included if inactiveObjects is set to true.

Therefore, just use it like you regularly would, but also pass in true.

The following code requires System.Linq:

SpriteRenderer[] onlyActive = GameObject.FindObjectsOfType<SpriteRenderer>();

SpriteRenderer[] activeAndInactive = GameObject.FindObjectsOfType<SpriteRenderer>(true);

// requires "using System.Linq;"
SpriteRenderer[] onlyInactive = GameObject.FindObjectsOfType<SpriteRenderer>(true).Where(sr => !sr.gameObject.activeInHierarchy).ToArray();

The first array includes only SpriteRenderers on active GameObjects, the second includes both those on active and inactive GameObjects, and the third uses System.Linq to only include those on inactive GameObjects.

Answer 3

Unity 2023

In Unity 2023, they changed how the find calls work, deprecating a lot of the old find functions. Here's the new stuff:

Find Only Active GameObjects:

SpriteRenderer[] onlyActive = FindObjectsByType<SpriteRenderer>(FindObjectsInactive.Exclude, FindObjectsSortMode.None);

Find Active and Inactive GameObjects:

SpriteRenderer[] activeAndInactive = FindObjectsByType<SpriteRenderer>(FindObjectsInactive.Include, FindObjectsSortMode.None);

Find Only Inactive GameObjects:

// requires "using System.Linq;"
SpriteRenderer[] onlyInactive = FindObjectsByType<SpriteRenderer>(FindObjectsInactive.Include, FindObjectsSortMode.None).Where(sr => !sr.gameObject.activeInHierarchy).ToArray();

Note: FindObjectsOfType<>() is now deprecated

Answer 4

See this answers for Unity 2020 and higher.

---

Before Unity 2020

Well, using GameObject.Find(...) will never return any inactive objects. As the documentation states:

This function only returns active gameobjects.

Even if you could, you'd want to keep these costly calls to a minimum.

There are "tricks" to finding inactive GameObjects, such as using a Resources.FindObjectsOfTypeAll(Type type) call (though that should be used with extreme caution).

But your best bet is writing your own management code. This can be a simple class holding a list of objects that you might want to find and use at some point. You can put your object into it on first load. Or perhaps add/remove them on becoming active or inactive. Whatever your particular scenario needs.

Answer 5

You can do this at runtime by having your inactive gameobject under an active parent object as previously mentioned; slightly different from what was mentioned, this is an approach I've used for activating/deactivating menus that should be inactive by default:

canvas = GameObject.FindGameObjectWithTag("GameMenu").GetComponentInChildren<Canvas>().gameObject;

Now you can change its activeSelf to toggle it in a method/event listener of your choice:

canvas.SetActive(!canvas.activeSelf);

Even while it is inactive, you can still use the tag property of it and use it for a filter, if getting multiple components of the same type. I haven't tested this using GetComponentsInChildren, but you could probably use a 'Single' linq query, and get the object by tag name which would require creating a tag for every gameobject you want to do this to.

Answer 6

For newer Unity versions this answer provides probably a better solution!

---

First of all

In general any usage of Find or it's variants should be avoided.

Actually they are never really required but only a "hot-fix" used to cover an implementation "laziness".

Usually from the beginning storing and passing on required references is always the better approach.

Especially in your case you seem to have a fix amount of objects so you could probably already reference them all in a certain "manager" component and store them in a list or array (them you can get a reference by index) or even a Dictionary<string, GameObject> (then you can also get the according reference by name - you can find an example below).

---

Workarounds

There are alternative solutions (FindObjectsWithTag, FindObjectsOfType) but it will always be quite expensive (though most of the Find variants are expensive anyway).

You could e.g. also "manually" iterate through all objects in the scene using Scene.GetRootGameObjects

Returns all the root game objects in the Scene.

And then search through them until you find your object. This way you get also inactive GameObject.

public static GameObject Find(string search)
{
    var scene = SceneManager.GetActiveScene();
    var sceneRoots = scene.GetRootGameObjects();

    GameObject result = null;
    foreach(var root in sceneRoots)
    {
        if(root.name.Equals(search)) return root;

        result = FindRecursive(root, search);

        if(result) break;
    }

    return result;
}

private static GameObject FindRecursive(GameObject obj, string search)
{
    GameObject result = null;
    foreach(Transform child in obj.transform)
    {
        if(child.name.Equals(search)) return child.gameObject;

        result = FindRecursive (child.gameObject, search);

        if(result) break;
    }

    return result;
}

But ofcourse this should be strongly avoided and the usage of such deep searches reduced to a minimum!

---

What I would do

Another way - in my eyes the best approach here - could be to have a certain component attached to all your objects and actually store all the references once as said before in a dictionary like e.g.

public class FindAble : MonoBehaviour
{
    private static readonly Dictionary<string, GameObject> _findAbles = new Dictionary<string, GameObject>();

    public static GameObject Find(string search)
    {
        if(!_findAbles.ContainsKey(search)) return null;

        return _findAbles[search];
    }

    private IEnumerator Start()
    {
        // Wait one frame
        // This makes it possible to spawn this object and 
        // assign it a different name before it registers
        // itself in the dictionary
        yield return null;

        if(_findAbles.ContainsKey(name))
        {
            Debug.LogError($"Another object with name /"{name}/" is already registered!", this);
            yield break;
        }

        _findAbles.Add(name, gameObject);
    }

    private void OnDestroy ()
    {
        if(_findAbles.ContainsKey(name))
        {
            _findAbles.Remove(name);
        }

        // Optionally clean up and remove entries that are invalid
        _findAbles = _findAbles.Where(kvp => kvp.Value).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
    }
}

and then use it like

var obj = FindAble.Find("SomeName");
if(obj)
{
    // ...
}

Also for this the component would need to be enabled at least once so Start is called.

Again an alternative would be to have instead a

public void Initialize(string newName)
{
    if(_findAbles.ContainsKey(name))
    {
        Debug.LogError($"Another object with name /"{name}/" is already registered!", this);
        return;
    }

    name = newName;

    _findAbles.Add(name, gameObject);
}

which you could call also after e.g. spawning an inactive object.

Answer 7

You can use Predicates. Just get the gameObjects and check them whith a Predicate as below:

public List<GameObject> FindInactiveGameObjects()
{
    GameObject[] all = GameObject.FindObjectsOfType<GameObject> ();//Get all of them in the scene
    List<GameObject> objs = new List<GameObject> ();
    foreach(GameObject obj in all) //Create a list 
    {
        objs.Add(obj);
    }
    Predicate inactiveFinder = new Predicate((GameObject go) => {return !go.activeInHierarchy;});//Create the Finder
    List<GameObject> results = objs.FindAll (inactiveFinder);//And find inactive ones
    return results;
}

and don't forget using System; using System.Collections.Generic;

Answer 8

If you have parent object (just empty object that plays role of a folder) you can find active and inactive objects like this:

this.playButton = MainMenuItems.transform.Find("PlayButton").gameObject;

MainMenuItems - is your parent object.

Please note that Find() is slow method, so consider using references to objects or organize Dictionary collections with gameobjects you need access very often

Good luck!

Answer 9

Although its not the correct answer, but this is what I did in my case.
1) Attach a script to (inactive) game objects and instead of setting then inactive keep it active.
2) Position them out of the scene somewhere.
3) Set a flag in the script which says inactive.
4) In Update() check for this inactive flag and skip function calls if false.
5) When needed the object, position it at the proper place and set the flag active.

It will be a bit of a performance issue but that's the only workaround I could think of so far.