GameObject.Find() work on inactive objects

The solution only works if you don't rely on transform.root anywhere in your game. It also doesn't work if you need to find objects that are children of objects that don't get destroyed on load.

Add a GameObject that is the root of all GameObjects in your scene. Then instead of

 FindObjectsOfType() 

use

 GetComponentsInChildren( typeof(Transform), true );

That should return all transforms of all GameObjects in the scene as they are all a child of the scene root, active or not.

If you can't or don't want to create a scene root object then you'll need to make an array of all the root objects in your scene and all GetCompoenentsInChildren() on all of them separately.

Here's how you do it.

Resources.FindObjectsOfTypeAll(typeof(GameObject)) as GameObject[];

Note this can also return prefabs not just object instances in the scene so be careful when using it at edit time.

This is kind of gross, but it works well:

     public static List<GameObject> GetAllObjectsInScene(bool bOnlyRoot)
     {
         GameObject[] pAllObjects = (GameObject[])Resources.FindObjectsOfTypeAll(typeof(GameObject));
 
         List<GameObject> pReturn = new List<GameObject>();
 
         foreach (GameObject pObject in pAllObjects)
         {
             if (bOnlyRoot)
             {
                 if (pObject.transform.parent != null)
                 {
                     continue;
                 }
             }
 
             if (pObject.hideFlags == HideFlags.NotEditable || pObject.hideFlags == HideFlags.HideAndDontSave)
             {
                 continue;
             }
 
             if (Application.isEditor)
             {
                 string sAssetPath = AssetDatabase.GetAssetPath(pObject.transform.root.gameObject);
                 if (!string.IsNullOrEmpty(sAssetPath))
                 {
                     continue;
                 }
             }
             
 
             pReturn.Add(pObject);
         }
 
         return pReturn;
     }

There are at very least 4 options: `GetChild`, `GetComponentsInChildren`, `FindObjectsOfType` and `FindGameObjectsWithTag`. We could also use some variations that won't bring an array, for instance. Listed below in no particular order.

1. GetChild a method of Transform, it still works even today on Unity4, and it's still not in the Docs for whatever reason. It will bring the child be it active or not. Probably the cheapest to use, since we have to use in each immediate parent we want to get the inactive GameObject. It will just be a pain to code and maintain.

2. GetComponentsInChildren needs to have a root object. We could set up the scene with just 1 main root here. Very simple to use, but also very heavy. Apply this in the root object:

     foreach (Transform child in GetComponentsInChildren(true))`
   
   

3. FindObjectsOfType doesn't need a root object. Docs say it won't return inactive objects, but it does. Since it's the heaviest listed here and highly unadvised to use, we could do something like:

     foreach ( GameObject root in GameObject.FindObjectsOfType(typeof(GameObject)) ) {
            if (root.transform.parent == null) { // game object with no parent
                // here, iterate through each `root` child using your prefered method
                // or simply remove the 'if' above
            }
        }
   
   

4. FindGameObjectsWithTag my favourite one, way faster and simpler than all others, but we can't add more than 1 tag per object so it may be prohibitive if we already use tag for something else. It also needs no root, use it from anywhere:

     foreach ( GameObject obj in GameObject.FindGameObjectsWithTag("tag") )
   
   
   

^{Disclaimer: @bdawson actually gave the same solution about FindObjectsOfType and @Antony scratched it, twice. None were specific enough.}

Things that can find inactive gameObjects :

transform.Find() or transform.FindChild()

transform.GetComponentsInChildren(true)

Resources.FindObjectsOfTypeAll()

For more detail you can refer to http://www.unityrealm.com/how-to-find-inactive-gameobject-in-unity/