Tile Editor for Unity: Part II

As I mentioned before, for those who only want to use the editor, as soon as the Asset is available in the Unity Asset Store, you will be able to download it for free and use it.

This is the second part of a series of posts about a small tile editor I’m creating for Unity. If you haven’t read the first part yet, you can check it out here.

The whole explanation is divided in the following parts:

  1. Editor Window Creation
  2. Saving Status
  3. Menus
  4. Game Objects Actions: Create, Delete, Edit
  5. Layers
  6. Grid
  7. Snapping
  8. Transformations
  9. Snapping: Extended

This week we are going to cover point number 3: menus.


This section includes the concept of game object menu, which is an abstraction of a group of game objects (represented by prefabs) that are loaded inside a menu for the user to dynamically create instances of them in the editor.

As you can see in the picture above, this section was called “Game Objects” and represents a list of menus used to add new prefabs to the editor. It’s possible to add different menus, each one with a set of prefabs to add to the scene, it’s also possible to customize the menu a little to better organize the elements inside of it and remove it if necessary.

In the previous post, we created the main class file for out extension “LevelCreatorEditor”, which handles how the menus are created, all the operations for each menu and general operations as well. As we mentioned before, all the menus are rendered inside the method “OnGUI” and for this new section we added the “BuildMenuObjects” method.

  1. List menus;
  2. EditorObjectsMenu objMenu;
  4. void OnGUI()
  5. {
  6.    if (menus == null)
  7.       menus = new List();
  8.    //Header
  9.    BuildMenuHeader();
  10.   //Objects
  11.   BuildMenuObjects();
  12. }
  14. void BuildMenuObjects()
  15. {
  16.    int curSel;
  17.    List removedMenus;
  19.    //If the group is empty, we disable this section
  20.    EditorGUI.BeginDisabledGroup(layers.Count <= 0);
  21.    //You can change the label if you want
  22.    GUILayout.Label("GAME OBJECTS", EditorStyles.boldLabel);
  23.    //Add menu button
  24.    if (GUILayout.Button("Add Menu"))
  25.       menus.Add(new EditorObjectsMenu());
  26.    removedMenus = new List();
  27.    //GUILayout.BeginVertical();
  28.    gameobjectsScrollPos = GUILayout.BeginScrollView(gameobjectsScrollPos, false, true);
  29.    //Menus
  30.    foreach (EditorObjectsMenu m in menus)
  31.    {
  32.       //Title
  33.       GUILayout.Label("Menu: " + m.folder, EditorStyles.boldLabel);
  34.       //Columns
  35.       m.columns = EditorGUILayout.IntField("Columns", m.columns);
  36.       //Folder's location
  37.       EditorGUILayout.BeginHorizontal();
  38.       m.folder = EditorGUILayout.TextField("Folder Name", m.folder);
  39.       if (GUILayout.Button("Load"))
  40.          m.LoadPrefabs();
  41.       EditorGUILayout.EndHorizontal();
  42.       //Load elements
  43.       if (m.tiles != null && m.tiles.Length >= 0 && m.columns >= 0)
  44.       {
  45.          curSel = GUILayout.SelectionGrid(m.selGridInt, m.tiles, m.columns, GUILayout.Width(position.width - 20),GUILayout.Height(100));
  46.          if (curSel != m.selGridInt)
  47.          {
  48.             m.selGridInt = curSel;
  49.             objMenu = m;
  50.             DeactivateMenus();
  51.          }
  52.       }
  54.       //Remove menu
  55.       if (GUILayout.Button("Remove"))
  56.          removedMenus.Add(m);
  57.    }
  58.    GUILayout.EndScrollView();
  59.    EditorGUI.EndDisabledGroup();
  61.    //Clean menus
  62.    foreach (EditorObjectsMenu m in removedMenus)
  63.       menus.Remove(m);
  64. }
  66. void DeactivateMenus()
  67. {
  68.    foreach (EditorObjectsMenu m in menus)
  69.    {
  70.       if (objMenu == null)
  71.          m.selGridInt = -1;
  72.       else
  73.       {
  74.          if (objMenu != m)
  75.             m.selGridInt = -1;
  76.       }
  77.    }
  78. }

Menus are logically represented using a List of “EditorObjectsMenu” which is a new class that has handles all the functionality inside a menu: loading new prefabs and converting them into usable icons, serializing the data to store changes for future use, etc.

  1. public class EditorObjectsMenu
  2. {
  3.    //Default folder that appears in the folder field
  4.    public const string DEFAULT_FOLDER = "Tiles";
  5.    //This will change depending on the folder's name
  6.    public string name;
  7.    //Folder's name
  8.    public string folder;
  9.    //Selected element
  10.    public int selGridInt;
  11.    //To organize the elements graphically, number of columns
  12.    public int columns;
  13.    //Textures of each prefab (from SpriteRenderer)
  14.    public Texture[] tiles;
  15.    //Prefabs that represent game objects
  16.    public Object[] prefabs;
  18.    public EditorObjectsMenu()
  19.    {
  20.       selGridInt = -1;
  21.       name = DEFAULT_FOLDER;
  22.       folder = DEFAULT_FOLDER;
  23.       columns = 3;
  24.    }
  26.    /// Load all the prefabs in folder "folder"
  27.    public void LoadPrefabs()
  28.    {
  29.       GameObject obj;
  30.       prefabs = Resources.LoadAll(folder, typeof(Object));
  31.       tiles = new Texture[prefabs.Length];
  32.       for (int i = 0; i &lt; prefabs.Length; i++)
  33.       {
  34.          obj = ((GameObject)prefabs[i]);
  36.          if (obj.GetComponent().sprite == null)
  37.          {
  38.             for (int j = 0; j &lt; obj.transform.childCount; j++)
  39.             {
  40.                if (obj.transform.GetChild(j).GetComponent().sprite != null)
  41.                {
  42.                   tiles[i] = obj.transform.GetChild(j).GetComponent().sprite.texture;
  43.                   break;
  44.                }
  45.             }
  46.          }
  47.          else
  48.             tiles[i] = obj.GetComponent().sprite.texture;
  49.       }
  50.    }
  52.    /// Get the the selected element
  53.    public Object GetCurrentSelection()
  54.    {
  55.       Object sel;
  57.       sel = null;
  58.       if (selGridInt != -1)
  59.          sel = prefabs[selGridInt];
  61.       return sel;
  62.    }
  64.    /// Transform the object's parameters into a string (to save the state of the object)
  65.    public string Serialize()
  66.    {
  67.       return name + "," + folder + "," + selGridInt + "," + columns;
  68.    }
  70.    /// Takes a serialized string and loads all the parameters of the object
  71.    public void Deserialize(string data)
  72.    {
  73.       string[] attributes = data.Split(',');
  75.       name = attributes[0];
  76.       folder = attributes[1];
  77.       selGridInt = int.Parse(attributes[2]);
  78.       columns = int.Parse(attributes[3]);
  79.    }
  80. }

The EditorObjectsMenu class has properties such as: name, folder, selGridInt, columns, tiles and prefabs. Name and folder are the same but one is used to display the id in the GUI and the other to decide where should the prefabs be loaded from; selGridInt represents the selected element (prefab); columns, is there to customize the number of columns each menu displays; tiles is an array of textures that are mapped to the prefabs and help to display the prefabs buttons inside the menu.

LoadPredabs takes the folder path (which should be inside the physical folder “Resources” and loads all the prefabs inside that path. This data is stored in the textures and prefabs arrays to be displayed in the menu.

GetCurrentSelection just returns which of the current element was selcted by the user and with that we can create instances of that object in the editor.

Finally Serialize and Deserialize were created to easily convert the data to strings and store it as we explained in the previous post.

Going back to the previous method “BuildMenuObjects” now that the EditorsObjectMenu is defined, we can see that the new attribute called “menus” is a list of elements of EditorsObjectMenu class. With this variable we represent logically all the menus that are rendered in the GUI.

Adding Menus

We create a new button inside the GUI called “Add Menu”, the code can be seen in the “BuildMenuObjects” function above:

  1. if (GUILayout.Button("Add Menu"))
  2.    menus.Add(new EditorObjectsMenu());

Here we just create a new instance of the class and add it to the menu list and it automatically will render the information and inputs for that new menu.

Rendering Menus

All the menus are rendered inside a foreach instruction that handles each input of the menu separately:

  1. foreach (EditorObjectsMenu m in menus)
  2. {
  3.    //Title
  4.    GUILayout.Label("Menu: " + m.folder, EditorStyles.boldLabel);
  5.    //m.name = EditorGUILayout.TextField("Title", m.name);
  6.    //Columns
  7.    m.columns = EditorGUILayout.IntField("Columns", m.columns);
  8.    //Folder's location
  9.    EditorGUILayout.BeginHorizontal();
  10.    m.folder = EditorGUILayout.TextField("Folder Name", m.folder);
  11.    if (GUILayout.Button("Load"))
  12.    m.LoadPrefabs();
  13.    EditorGUILayout.EndHorizontal();
  14.    //Load elements
  15.    if (m.tiles != null && m.tiles.Length >= 0 && m.columns >= 0)
  16.    {
  17.       curSel = GUILayout.SelectionGrid(m.selGridInt, m.tiles, m.columns, GUILayout.Width(position.width - 20),GUILayout.Height(100));
  18.       if (curSel != m.selGridInt)
  19.       {
  20.          m.selGridInt = curSel;
  21.          objMenu = m;
  22.          cursorState = CursorState.Add;
  23.          DeactivateMenus();
  24.       }
  25.    }
  27.    //Remove menu
  28.    if (GUILayout.Button("Remove"))
  29.       removedMenus.Add(m);
  30. }


Here basically we handle basic information for the menu: name, location. There is also a field called “Folder Name” that specifies the path of the data. After the user writes the name of thr folder down, clicks “Load” and all the prefabs will be loaded automatically inside the menu, using the SpriteRenderer’s texture as icon image. In case that the SpriteRenderer for a prefab is empty, the algorithm automatically searches inside the children of this prefab and takes the first non null texture and use it.

Removing Menus

In the previous code we can see that a “removedMenus” list was created in additio to the general menus list. This is emptied everytime before the cycle for rendering menus starts so if the user removes a menu using the remove button, it will add it to this new list and delete all menus from the main list after the cycle finishes. This is done to prevent collection changes inside the cycle.

Deactivate Menus

Finally, this method verifies if any of the elements on any menu was selected and in case it was not selected it deactivates the whole menu. This was used to have only one element selected at the time, if we do not do this, then two different menus could have one element selected each and we don’t want that when creating new instances.

With the menu deactivation I want to close this post, I’ll continue explaining the rest of the code in upcoming articles. If you have questions, leave in them in the comments.


Tile Editor for Unity: Part II

Tile Editor for Unity: Part I


Before starting to talk about today’s topic, I would like to announce we have a new image: new logo, appeareance and website. This new website includes released games, current projects and prototypes that will hopefully become released projects soon. Hope you like it!


So, today’s post consists of the first of a series of short posts about how the tile editor for Unity was created and explain the basic functionality of it.

For those who only want to use it and are not really interested about how it was built, as soon as the Asset is available in the Unity Asset Store, you will be able to download it for free and use it.

This is only the beginning of this tool, I would like to keep improving it along with the development of the game I’m currently creating.

The whole explanation is divided in the following parts:

  1. Editor Window Creation
  2. Saving Status
  3. Menus
  4. Game Objects Actions: Create, Delete, Edit
  5. Layers
  6. Grid
  7. Snapping
  8. Transformations
  9. Snapping: Extended

For this post we will cover only the first two parts, the rest of the explanation will be covered in the upcoming weeks.


The first thing we need to do is to create a folder called “Editor” in our Project manager, this is a special folder designed to extend the functionality of the basic Editor.

As you can see, I added the folder inside a folder called “FSLevelEditor”, you can really put this folder wherever you want and you can also create multiple folders in different locations, if they are named “Editor”, that should be enough for it to work well.

After creating this folder, inside of it, we want to create a new class which will be the main class for our extension. In this particular case, I called the main class “LevelCreatorEditor”, you can customize this name as you like.

  1. using UnityEditor;
  2. using UnityEngine;
  3. public class LevelCreatorEditor : EditorWindow
  4. {
  5.    // Add menu named "My Window" to the Window menu
  6.    [MenuItem("Window/Level Editor")]
  7.    static void Init()
  8.    {
  9.       //Get existing open window or if none, make a new one:
  10.       LevelCreatorEditor window;
  11.       window = (LevelCreatorEditor)EditorWindow.GetWindow(typeof(LevelCreatorEditor));
  12.       window.Show();
  13.    }
  14. }

This new class should inherit from “EditorWindow” which is the base class for new extensions in Unity. You can see more details about this class in the manual. The class EditorWindow belongs to the UnityEditor library so we need to import it as well.

In this class a new static method called “Init” has to be added to show the new window and assign a name for it in the menu. In line 6 in the code above you can see that I set the path of the new menu to “Window/Level Editor”, the location “Window” represents the Window menu in the Unity editor, you can choose whichever menu you prefer to have your new extension. You can also customize the name of the new item in the menu by changing the “Level Editor” for whatever you like.

  1. int gridSize;
  2. float gridX;
  3. float gridY;
  4. Color gridColor = Color.white * 0.8f;
  5. Color cursorColor = Color.red;
  6. Color selectColor = Color.blue;
  7. bool showGrid = true;
  8. void OnGUI()
  9. {
  10.    //Header
  11.    BuildMenuHeader();
  12. }
  13. void BuildMenuHeader()
  14. {
  15.    GUILayout.Label("GRID SETTINGS", EditorStyles.boldLabel);
  16.    gridSize = EditorGUILayout.IntField("Grid Size (px)", gridSize);
  17.    gridX = gridSize / 100f;
  18.    gridY = gridSize / 100f;
  19.    gridColor = EditorGUILayout.ColorField("Grid Color", gridColor);
  20.    cursorColor = EditorGUILayout.ColorField("Cursor Color", cursorColor);
  21.    selectColor = EditorGUILayout.ColorField("Select Color", selectColor);
  22.    showGrid = EditorGUILayout.Toggle("Show Grid",showGrid);
  23. }

The “OnGUI” function is the one that renders all the elements you want inside your new window. In this particular case, I’m adding general properties for the grid just to illustrate how it works. You can directly put the GUI code inside this function but I’m getting the exact code I made for the tile editor, that’s why I added the “BuildMenuHeader” function.

The “BuildMenuHeader” basically includes all the elements that affect the grid and change the variable values according to whatever the user chooses.

We can see in line 16 a short example about how the variables are modified in real time, “EditorGUILayout.ColorField” takes a couple of parameters, the label for that element and also the current value, this function returns the modified value in real time, that’s why we use and modify the “gridSize” variable in the same line.


The previous section was about creating a very basic window with few elements that make our variables change in real time. The other important step for this post is about how to take those values we change and keep using them after we close the window. If we don’t do this, everytime that we close and re-open our new extension’s window, all the parameters will be initiallized again.

  1. bool loaded;
  2. void OnEnable()
  3. {
  4.    LoadData();
  5. }
  7. void OnDisable()
  8. {
  9.    SaveData();
  10. }
  12. void OnDestroy()
  13. {
  14.    SaveData();
  15. }
  17. ///
  18. /// Saves the current editor's status
  19. ///
  20. public void SaveData()
  21. {
  22.    string id;
  24.    id = PlayerSettings.productName;
  25.    EditorPrefs.SetInt(id + "-GridSize", gridSize);
  26.    EditorPrefs.SetString(id + "-CursorColor", FromColorToString(cursorColor));
  27.    EditorPrefs.SetString(id + "-GridColor", FromColorToString(gridColor));
  28.    EditorPrefs.SetString(id + "-SelectColor", FromColorToString(selectColor));
  29.    EditorPrefs.SetBool(id + "-ShowGrid", showGrid);
  30. }
  32. ///
  33. /// Convert an object from class Color into a serialized string
  34. ///
  35. public string FromColorToString(Color color)
  36. {
  37.    return color.r + "," + color.g + "," + color.b + "," + color.a;
  38. }
  40. ///
  41. /// Convert a string into an object from Color
  42. ///
  43. public Color FromStringToColor(string color)
  44. {
  45.    string[] desColor;
  46.    desColor = color.Split(',');
  48.    return new Color(float.Parse(desColor[0]), float.Parse(desColor[1]), float.Parse(desColor[2]), float.Parse(desColor[3]));
  49. }
  51. ///
  52. /// Restore the editor's status
  53. ///
  54. public void LoadData()
  55. {
  56.    string id;
  58.    id = PlayerSettings.productName;
  60.    if (EditorPrefs.HasKey(id + "-GridSize"))
  61.       gridSize = EditorPrefs.GetInt(id + "-GridSize");
  63.    if (EditorPrefs.HasKey(id + "-ShowGrid"))
  64.       showGrid = EditorPrefs.GetBool(id + "-ShowGrid");
  66.    if (EditorPrefs.HasKey(id + "-CursorColor"))
  67.       cursorColor = FromStringToColor(EditorPrefs.GetString(id + "-CursorColor"));
  69.    if (EditorPrefs.HasKey(id + "-GridColor"))
  70.       gridColor = FromStringToColor(EditorPrefs.GetString(id + "-GridColor"));
  72.    if (EditorPrefs.HasKey(id + "-SelectColor"))
  73.       selectColor = FromStringToColor(EditorPrefs.GetString(id + "-SelectColor"));
  75.    loaded = true;
  76. }

We have the “OnEnable” function that is executed every time the window is enabled; the “OnDisable” function that runs everytime the window is disabled and finally the “OnDestroy” function that runs when the window is closed. In these functions the status of the editor is saved and restored.

There are a couple of helpers in this part that make easier to save and restore objects from the Color class. “FromStringToColor” and “FromColorToString” are functions that transform the data to make the saving and restoring process easier.

The “SaveData” function basically stores all the important values in an internal storage (Editor Preferences). Depending on the type of data we want to save, we use different functions.

One important thing that has to be highlighted here is this: EditorPrefs.SetInt(id + “-variable id”, variable), the reason why we are using the “id” variable (this represents the name of the project) in the variable’s name is that this internal storage does not distinguish between projects, it means that if we do not add a project identifier, those values will be replaced if you try to use the editor again and we don’t want that.

The “LoadData” function just restores the data in the same way that the we save it but using the appropriate functions.


In this first post of a series on how to create a tile editor extension for Unity, we covered two basic steps: how to create a new window and how to store the data we modify using that window.

With these basic concepts you can create whatever you want, add more elements to the menu, include a different functionality or develop a completely different extension, I recommend testing all the elements you can add to a menu and play with it to understand better how it works, that’s what I did.

Upcoming posts will have details about the rest of the code and I will let you know as soon as the full extension is approved in the Unity Asset Store so you can download it and use it for your projects.

Tile Editor for Unity: Part I