Showing posts with label Editor. Show all posts
Showing posts with label Editor. Show all posts

Thursday, March 29, 2012

Let me debug in your GUI


Here's a script I made to be able to see debug stuff while testing a game outside of the editor i.e. webplayer. It adds a button on the top right corner to turn on/off the debug window.

Should be pretty easy to use, just put it on some gameobject, and alter the "maxlines" value to fit your need.

using UnityEngine;
using System.Collections;

public class MyLog : MonoBehaviour
{
    static string myLog;
    static Queue myLogQueue = new Queue();
    public string output = "";
    public string stack = "";
    private bool hidden = true;
    private Vector2 scrollPos;
    public int maxLines = 30;

    void OnEnable()
    {
        Application.RegisterLogCallback(HandleLog);
    }

    void OnDisable()
    {
        Application.RegisterLogCallback(null);
    }

    void HandleLog(string logString, string stackTrace, LogType type)
    {
        output = logString;
        stack = stackTrace;
        string newString = "\n [" + type + "] : " + output;
        myLogQueue.Enqueue(newString);
        if (type == LogType.Exception)
        {
            newString = "\n" + stackTrace;
            myLogQueue.Enqueue(newString);
        }

        while (myLogQueue.Count > maxLines)
        {
            myLogQueue.Dequeue();
        }

        myLog = string.Empty;
        foreach (string s in myLogQueue)
        {
            myLog += s;
        }
    }

    void OnGUI()
    {
        if (!hidden)
        {
            GUI.TextArea(new Rect(0, 0, Screen.width / 3, Screen.height), myLog);
            if (GUI.Button(new Rect(Screen.width - 100, 10, 80, 20), "Hide"))
            {
                hide(true);
            }
        }
        else
        {
            if (GUI.Button(new Rect(Screen.width - 100, 10, 80, 20), "Show"))
            {
                hide(false);
            }
        }
    }

    public void hide(bool shouldHide)
    {
        hidden = shouldHide;
    }
}

Hope you like it. If you make any improvements, please share.

Wednesday, February 15, 2012

Automatically locate all unused unity assets

Did you ever work on a unity project where either you or a co-worker did not uphold complete and total order with regards to cleaning up the project folder. If you're one of those rare specimens that has never experienced a touch of kaos, don't read on!

On the other hand if you, as I, from time to time postpones the cleanup to another day, I've made a handy little editorwindow that should make the cleanup process a lot less tedious.

Basically it reads from the editor log after you have build a project, and then compares the included assets with all assets in your project. If an asset exist that is not used in the final build it is listed. It is also clickable so you can easily find it.

The unused assets are organized in 3 folders. "editor", "plugins" and "some other folder". This is helpful for me, as there is a lot in the "editor" folder that I use, but that is not used in final build.

It also lists which .dll's are included in build. If you need it, fine. If not, just delete that part.

DISCLAIMER: It does not locate unused assets in the "Ressources" folder, since everything in there should by default be included in the build. It's a tool to help locate the unused, but should be used with a bit of common sense.

[***UPDATE 2014***] By popular demand a GREATLY improved version of this tool has been released on the Unity Asset Store for 10 bucks. This old version is not stable as of Unity 4.6b20 and will not be updated

Place the following in the "editor" folder:
 using UnityEngine;  
 using UnityEditor;  
 using System.Collections;  
 using System.Collections.Generic;  
   
 public class CleanUpWindow : EditorWindow  
 {  
   bool groupEnabled = false;  
   List<string> usedAssets = new List<string>();  
   List<string> includedDependencies = new List<string>();  
   private Vector2 scrollPos;  
   private List<Object> unUsed;  
   private Dictionary<string, List<Object>> unUsedArranged;  
   private bool needToBuild = false;  

// Add menu named "CleanUpWindow" to the Window menu  
   [MenuItem("Window/CleanUpWindow")]  
   static void Init()  
   {  
     // Get existing open window or if none, make a new one:  
     CleanUpWindow window = (CleanUpWindow)EditorWindow.GetWindow(typeof(CleanUpWindow));
window.Show();  
   }  
   
   void OnGUI()  
   {  
     if (needToBuild)  
     {  
       GUI.color = Color.red;  
       GUILayout.Label("Are you sure you remembered to build project? Because you really need to...", EditorStyles.boldLabel);  
     }  
     GUI.color = Color.white;  
   
     if (GUILayout.Button("Load EditorLog"))  
     {  
       loadEditorLog();  
     }  
   
       
     if(!needToBuild)  
     {  
       EditorGUILayout.BeginHorizontal();  
       EditorGUILayout.BeginVertical();  
       if (groupEnabled)  
       {  
         GUILayout.Label("DEPENDENCIES");  
         for (int i = 0; i < includedDependencies.Count; i++)  
         {  
           EditorGUILayout.LabelField(i.ToString(), includedDependencies[i]);  
         }  
       }  
       EditorGUILayout.EndVertical();  
       scrollPos = EditorGUILayout.BeginScrollView(scrollPos);  
       EditorGUILayout.BeginVertical();  
   
       if (groupEnabled)  
       {  
         if (unUsedArranged != null)  
         {  
           foreach (KeyValuePair<string, List<Object>> objList in unUsedArranged)  
           {  
             if (objList.Value.Count >= 1)  
             {  
               GUILayout.Label(objList.Key.ToUpper());  
               for (int i = 0; i < objList.Value.Count; i++)  
               {  
                 EditorGUILayout.ObjectField(objList.Value[i], typeof(Object), false);  
               }  
             }  
           }  
         }  
       }  
       EditorGUILayout.EndVertical();  
       EditorGUILayout.EndScrollView();  
       EditorGUILayout.EndHorizontal();  
     }  
       
   }  
   
   private void loadEditorLog()  
   {  
     UsedAssets.GetLists(ref usedAssets, ref includedDependencies);  
   
     if (usedAssets.Count == 0)  
     {  
       needToBuild = true;  
     }  
     else  
     {  
       compareAssetList(UsedAssets.GetAllAssets());  
       groupEnabled = true;  
       needToBuild = false;  
     }  
   }  
   
   private void compareAssetList(string[] assetList)  
   {  
       
     unUsed = new List<Object>();  
   
     unUsedArranged = new Dictionary<string, List<Object>>();  
     unUsedArranged.Add("plugins", new List<Object>());  
     unUsedArranged.Add("editor", new List<Object>());  
     unUsedArranged.Add("some other folder", new List<Object>());  
   
     for (int i = 0; i < assetList.Length; i++)  
     {   
       if(!usedAssets.Contains(assetList[i]))  
       {  
           
         Object objToFind = AssetDatabase.LoadAssetAtPath(assetList[i], typeof(Object));  
         unUsed.Add(objToFind);  
         if (objToFind != null)
         {
             unUsedArranged[getArrangedPos(objToFind)].Add(objToFind);  
         }
       }  
     }  
   }  
   
   private string getArrangedPos(Object value)  
   {  
     string path = AssetDatabase.GetAssetPath(value).ToLower();  
   
     if (path.Contains("/plugins/"))  
     {  
       return "plugins";  
     }  
     else if (path.Contains("/editor/"))  
     {  
       return "editor";  
     }  
     else  
     {  
       return "some other folder";  
     }  
   }  
 }  
You,ll need this too:
using UnityEngine;
using UnityEditor;
using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;

public class UsedAssets
{
    public static string[] GetAllAssets()
    {
        string[] tmpAssets1 = Directory.GetFiles(Application.dataPath, "*.*", SearchOption.AllDirectories);
        string[] tmpAssets2 = Array.FindAll(tmpAssets1, name => !name.EndsWith(".meta"));
        string[] allAssets;

        allAssets = Array.FindAll(tmpAssets2, name => !name.EndsWith(".unity"));

        for (int i = 0; i < allAssets.Length; i++)
        {
            allAssets[i] = allAssets[i].Substring(allAssets[i].IndexOf("/Assets") + 1);
            allAssets[i] = allAssets[i].Replace(@"\", "/");
        }

        return allAssets;
    }

    public static void GetLists(ref List<string> assetResult, ref List<string> dependencyResult)
    {
        assetResult.Clear();
        dependencyResult.Clear();

        string LocalAppData = string.Empty;
        string UnityEditorLogfile = string.Empty;

        if (Application.platform == RuntimePlatform.WindowsEditor)
        {
            LocalAppData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
            UnityEditorLogfile = LocalAppData + "\\Unity\\Editor\\Editor.log";
        }
        else if (Application.platform == RuntimePlatform.OSXEditor)
        {
            LocalAppData = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
            UnityEditorLogfile = LocalAppData + "/Library/Logs/Unity/Editor.log";
        }
        
        try
        {
            // Have to use FileStream to get around sharing violations!
            FileStream FS = new FileStream(UnityEditorLogfile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            StreamReader SR = new StreamReader(FS);

            
            string line;
            while (!SR.EndOfStream && !(line = SR.ReadLine()).Contains("Mono dependencies included in the build"));
            while (!SR.EndOfStream && (line = SR.ReadLine()) != "")
            {
                dependencyResult.Add(line);
            }
            while (!SR.EndOfStream && !(line = SR.ReadLine()).Contains("Used Assets,"));
            while (!SR.EndOfStream && (line = SR.ReadLine()) != "")
            {
               
                line = line.Substring(line.IndexOf("% ") + 2);
                assetResult.Add(line);
            }
        }
        catch (Exception E)
        {
            Debug.LogError("Error: " + E);
        }
    }
}
Note that script files might not be shown as unused since the unity build includes then.
Here's an example: Unity Package

Saturday, February 4, 2012

Batch replace gameobjects in Unity

When creating Harry the Fairy, we often found ourselves having to replace hundreds of prefab instances so I created this little script. It replaces a number of gameobjects with another and gives you the possibility to save all the transform values i.e. position, rotation and scale.

C# Script must be placed in "editor" folder.
using UnityEngine;
using UnityEditor;
using System.Collections;

public class ReplaceGameObjects : ScriptableWizard
{
    public bool copyValues = true;
    public GameObject NewType;
    public GameObject[] OldObjects;

    [MenuItem("Custom/Replace GameObjects")]


    static void CreateWizard()
    {
        ScriptableWizard.DisplayWizard("Replace GameObjects", typeof(ReplaceGameObjects), "Replace");
    }

    void OnWizardCreate()
    {
        foreach (GameObject go in OldObjects)
        {
            GameObject newObject;
            newObject = (GameObject)EditorUtility.InstantiatePrefab(NewType);
            newObject.transform.position = go.transform.position;
            newObject.transform.rotation = go.transform.rotation;
            newObject.transform.parent = go.transform.parent;

            DestroyImmediate(go);

        }

    }
}

Here's a visual walkthrough:

Go into Custom ->Replace Gameobjects


Select any number of gameobjects and drag them into "Old Objects".
Then, from the project pane, drag the gameobject that you want to replace with into "New Type".


Press "Replace"


Enjoy :)

/Kristian
And credits to Michael L. Croswell