AngryAnt.com

As some of you might have read, at Unity we have a thing called FAFF – very much the same as Google and other IT businesses are doing. It generally lets you step out of the bit stream for a day and just, during work hours, go with whatever crazy idea(s) you’ve been throwing around.

Some of these ideas are pushed into the product later and others are just filed under “something to play with when bored” and “now I can stop wondering about that”. Sketch was a micro FAFF project I just remembered I had filed under “this was fun” and then forgot all about. Since then I’ve continued work on other projects and started new ones – in all likelihood I’ll not return to this project.

So I figured I’d push it to github and let you guys take it for a spin. If nothing else, it’s a nice demo of what you can do with Unity editor scripting.

The idea of Sketch is to have simple tools inside the Unity editor to modify meshes in your assets. My goal with the project was never to turn Unity into a mesh authoring environment, but rather to give people an extra tool for rapid prototyping.

So what’s in there now? The simplest I could think of: Triangle selection and movement.

Workflow:
1. Go to the GameObject->Create Other menu and click Sketch Cube.
2. With the cube selected, click a triangle and with the handle that appears, drag it around to modify the mesh.
3. GOTO 1.

Alternatively, you could drag in your own mesh from the Assets folder (make sure that it generates a mesh collider in its import settings) and attach the Sketch script to it.

NOTICE: Sketch modifies the imported asset. This means that:
• If you modify a some of the basic geometry meshes (such as GameObject->Create Other->Cube), the changes will apply to all cubes until editor relaunch.
• If the geometry you’re modifying is based on an imported 3D asset, reimporting it will mean you loose your changes.

Structure-wise, Sketch consists of two components: A MonoBehaviour (Sketch/Sketch.cs) and a custom inspector (Sketch/Editor/SketchEditor.cs). The purpose of the MonoBehaviour is merely to do some bookkeeping and provide utility functions (it will even destroy itself at runtime) while the custom inspector holds the logic for doing the modifications.

Woah. That’s a lot of talk. Here’s the repository – go nuts: http://github.com/AngryAnt/Sketch

I like delegates. I also like enums. Furthermore, I happen to be part of a small group of people who actually enjoy the immediate mode GUI system in Unity. And I want you to like it too

So – menus. After having observed quite a few very funky approaches, in the IRC channel, to building main menu functionality and giving advice in there, I decided to sow together those ideas into a short example.

The main idea here is to be able to build and manage a menu system quickly and easily. This line adds a new submenu to the system – designated MyMenuState and implemented in the OnMyMenuGUI method:

m_Menus [MenuState.MyMenuState] = OnMyMenuGUI;

Notice that since we’re using delegates, the GUI method needn’t be implemented in the same script and could even live on an entirely different GameObject. Why is this so clever (besides enums and delegates being cool)? Because managing and switching between menus set up like this is insanely easy. This is the central GUI method for the menu system:

public void OnGUI ()
{
    m_Menus [m_CurrentState] ();
}

And this is GUI code inside a menu GUI method for switching to a different submenu:

m_CurrentState = GUILayout.Button ("Credits") ? MenuState.Credits : m_CurrentState;

So there. Enough talk. Have some example code:

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

public class Menu : MonoBehaviour
{
    delegate void OnGUIImplementation();
    public enum MenuState {Main,Settings,Credits};
    public struct Settings
    {
        public bool m_ThisSetting, m_ThatSetting, m_TheOtherSetting;
    };
    static Vector2 m_StandardMenuSize = new Vector2 (200.0f, 300.0f);
    static string m_LogoURL = "http://download.unity3d.com/images/top-menu/mm_unity_icon.png";
    static Texture2D m_Logo = null;

    private MenuState m_CurrentState = MenuState.Main;
    private Dictionary<MenuState, OnGUIImplementation> m_Menus;
    private Settings m_Settings;

    void Awake ()
    {
        m_Menus = new Dictionary<MenuState, OnGUIImplementation> ();
        m_Menus [MenuState.Main] = OnMainMenuGUI;
        m_Menus [MenuState.Settings] = OnSettingsGUI;
        m_Menus [MenuState.Credits] = OnCreditsGUI;
        StartCoroutine (GetLogo ());
    }

    IEnumerator GetLogo ()
    {
        WWW www = new WWW (m_LogoURL);

        yield return www;

        if (www.error == null)
        {
            m_Logo = www.texture;
        }
    }

    public void OnGUI ()
    {
        m_Menus [m_CurrentState] ();
    }

    static void BeginStandardMenu (string title)
    {
        GUILayout.BeginArea (new Rect ((Screen.width - m_StandardMenuSize.x) * 0.5f, (Screen.height - m_StandardMenuSize.y) * 0.5f, m_StandardMenuSize.x, m_StandardMenuSize.y));
            GUILayout.BeginVertical (GUI.skin.GetStyle ("Box"));
                GUILayout.Label (title, GUI.skin.GetStyle ("Box"));
    }

    static void EndStandardMenu ()
    {
        Color color;

                GUILayout.BeginHorizontal ();
                    GUILayout.FlexibleSpace ();
                        color = GUI.color;
                        GUI.color = Color.grey;
                        GUILayout.Label ("My game version 2.4X");
                        GUI.color = color;
                    GUILayout.FlexibleSpace ();
                GUILayout.EndHorizontal ();
            GUILayout.EndVertical ();
        GUILayout.EndArea ();
    }

    void OnMainMenuGUI ()
    {
        BeginStandardMenu ("Main menu");
            if (m_Logo != null)
            {
                GUILayout.BeginHorizontal ();
                    GUILayout.FlexibleSpace ();
                        GUILayout.Label (m_Logo);
                    GUILayout.FlexibleSpace ();
                GUILayout.EndHorizontal ();
            }
            if (GUILayout.Button ("New game"))
            {
                Application.LoadLevel ("Level one");
            }
            m_CurrentState = GUILayout.Button ("Settings") ? MenuState.Settings : m_CurrentState;
            m_CurrentState = GUILayout.Button ("Credits") ? MenuState.Credits : m_CurrentState;
            GUILayout.FlexibleSpace ();
        EndStandardMenu ();
    }

    void OnSettingsGUI ()
    {
        BeginStandardMenu ("Settings");
            m_Settings.m_ThisSetting = GUILayout.Toggle (m_Settings.m_ThisSetting, "This setting");
            m_Settings.m_ThatSetting = GUILayout.Toggle (m_Settings.m_ThatSetting, "That setting");
            m_Settings.m_TheOtherSetting = GUILayout.Toggle (m_Settings.m_TheOtherSetting, "The other setting", GUI.skin.GetStyle ("Button"));
            GUILayout.FlexibleSpace ();
            m_CurrentState = GUILayout.Button ("Main menu") ? MenuState.Main : m_CurrentState;
        EndStandardMenu ();
    }

    void OnCreditsGUI ()
    {
        BeginStandardMenu ("Credits");
            GUILayout.Label ("This game was created by some of the most awesomestest people on the planet. Having failed in their mission to Pluto, they started making games, which - as you can see - resulted in much joy and success!");
                GUILayout.Space (20.0f);
                GUILayout.BeginHorizontal ();
                    GUILayout.FlexibleSpace ();
                        GUILayout.Label ("The awesomestest people inc.");
                GUILayout.EndHorizontal ();

            GUILayout.FlexibleSpace ();
            m_CurrentState = GUILayout.Button ("Main menu") ? MenuState.Main : m_CurrentState;
        EndStandardMenu ();
    }
}

---

Example project: Menu.zip – built with Unity 2.6.1

Say you’re developing an RTS or maybe a connect-the-dots sort of game. What would be the easiest way to go about handling object selection? This is my suggested solution.

In the given example, I’m taking advantage of the object-mouse event handling that MonoBehaviours on GameObject with colliders on them give for free. You might be in a scenario where raycasting or otherwise resolving selection requests makes more sense, but the basic logic still applies. This example is merely intended to get your from start to goal as fast as possible.

First off, we need a selection manager class (cleverly named SelectionManager in my example). This is where we store selection state and via static accessors, we can get and modify the current selection. Seeing as this class is both public and all accessors are static, you can put its source anywhere. In my example I’ve simply put it right after the MonoBehaviour used for testing it.

SelectionManager

using UnityEngine;

public class SelectionManager
{
    private static GameObject s_ActiveSelection;

    public static GameObject ActiveSelection
    {
        get
        {
            return s_ActiveSelection;
        }
        set
        {
            s_ActiveSelection = value;
        }
    }

    public static void Select (GameObject gameObject, bool selectionValue)
    {
        if (selectionValue)
        {
            Select (gameObject);
        }
        else
        {
            Deselect (gameObject);
        }
    }

    public static void Select (GameObject gameObject)
    {
        ActiveSelection = gameObject;
    }

    public static void Deselect (GameObject gameObject)
    {
        if (ActiveSelection == gameObject)
        {
            ActiveSelection = null;
        }
    }

    public static bool IsSelected (GameObject gameObject)
    {
        return ActiveSelection == gameObject;
    }
}

And the promised MonoBehaviour using the SelectionManager class:

using UnityEngine;

public class SelectableObject : MonoBehaviour
{
    public Rect m_SelectionWindowRect = new Rect (10.0f, 10.0f, 300.0f, 100.0f);

    public void OnMouseDown ()
    {
        SelectionManager.Select (gameObject, !SelectionManager.IsSelected (gameObject));
    }

    public void OnDisable ()
    {
        SelectionManager.Deselect (gameObject);
    }

    public void Update ()
    {
        renderer.material.color = SelectionManager.IsSelected (gameObject) ? Color.green : Color.white;
    }

    public void OnGUI ()
    {
        if (SelectionManager.IsSelected (gameObject))
        {
            m_SelectionWindowRect = GUI.Window (GetInstanceID (), m_SelectionWindowRect, SelectionWindow, gameObject.name);
        }
    }

    void SelectionWindow (int id)
    {
        GUILayout.Box ("I am the selection and my name is " + gameObject.name);
        GUI.DragWindow ();
    }
}

---

And that is all there is to it. By popular demand, I’m now starting to provide pre-built projects with these tips and tricks posts. Download, unzip, open and play. Requires Unity 2.6.1:
SelectableObject

When needing to yield a coroutine for a single frame in C#, most people – including myself usually go about it this way:

private IEnumerator DoFadeAlphaIn ()
{
    while (m_Alpha < 1.0f)
    {
        m_Alpha += Time.deltaTime;
        yield return 0;
    }
    m_Alpha = 1.0f;
}

However, as Rodrigo recently brought to my attention, this approach ofcourse performs unneeded memory allocation, given that the zero needs boxing and unboxing before its passed to the coroutine system. Using null in stead saves you that work and allocation.

This might not seem like a lot at first glance, but if you make this a habit every time you need to yield for a frame, I guarantee you that you’ll see results in larger scenarios.

The more optimal way of yielding for a single frame in C#. Minor difference, but allocation saved – which is always awesome:

private IEnumerator DoFadeAlphaIn ()
{
    while (m_Alpha < 1.0f)
    {
        m_Alpha += Time.deltaTime;
        yield return null;
    }
    m_Alpha = 1.0f;
}

An interesting test could be to, on a larger co-routine heavy project, do a project-wide find and replace on “yield return 0;” and “yield return null;” back and forth and measuring the performance difference with the profiler (for non-pro users, maybe the performance gain is even measurable using external monitoring tools).