Flashing Text in Unity Editor Window
December 12, 2014  by  
Tags: , ,

At first glance, flashing text in a custom Unity editor window may sound like an annoyance, and it certainly can be if used inappropriately. But it can be a useful tool for catching a user’s attention if used responsibly. I use it in a few of my custom editors to alert the user to various situations:

  • Missing components. For example, my vertex painters won’t work if the selected game object does not contain a mesh component.
  • When you’re locking standard scene selection. For example, when my vertex painters are in “Paint Mode”, you cannot select scene objects when clicking in the scene. This can be confusing if you forget you are in “Paint Mode”, or you are using the tool for the first time.
  • Warning messages. “Changes cannot be undone” might be a good candidate.

How I use it

 
'Component missing' error message

‘Component missing’ error message

'Scene selection locked' info message

‘Scene selection locked’ info message

How it works

Really the only thing you need to understand is that you cannot use Time.DeltaTime in edit mode, because the game is not running. This means you can’t use tools like iTween to change the color of your text, because it rely’s on Time.DeltaTime to perform all of it’s calculations (yes, even FloatUpdate). So, in order to make the animation happen, you’ll have to write a little extra code yourself. EditorApplication.update is called approximately 100 times per second, even in edit mode, so you can perform your animation logic in there.

Feel free to use or modify the code below for any purpose. I only use it to animate text color, but you could easily adapt it to perform animations of any kind. Maybe you’d like to have a small, animated company logo at the top of editors you release to the asset store for example. The sky’s the limit. Hopefully this code will be of use to someone.

pop-uptext
  1. namespace Assets.Editor
  2. {
  3.     using UnityEditor;
  4.     using UnityEngine;
  6.     /// <summary>
  7.     /// Class definition for FlashingTextInEditorWindow.cs.
  8.     /// </summary>
  9.     public class FlashingTextInEditorWindow : EditorWindow 
  10.     {
  11.         private const float FlashingTextCycleDuration = 2.0f;
  13.         private Color _flashingTextColor = Color.red;
  14.         private float _realTimeLastFrame;
  15.         private bool _fadingColorIn;
  17.         /// <summary>
  18.         /// Register our editor window.
  19.         /// </summary>
  20.         [MenuItem("Sector12/Flashing Text")]
  21.         protected static void Init()
  22.         {
  23.             GetWindow(typeof(FlashingTextInEditorWindow), false, "Flashing Text");
  24.         }
  25.         
  26.         /// <summary>
  27.         /// Setup a hook into an update method so that we can display flashing text
  28.         /// over time in the editor window.
  29.         /// </summary>
  30.         private void OnEnable()
  31.         {   
  32.             // Make sure we're never registered twice
  33.             EditorApplication.update -= UpdateHook;
  34.             EditorApplication.update += UpdateHook;
  35.         }
  37.         /// <summary>
  38.         /// Draw our flashing text.
  39.         /// </summary>
  40.         private void OnGUI()
  41.         {
  42.             Color originalGUIColor = GUI.color;
  43.             GUI.color = _flashingTextColor;
  44.             GUILayout.Label("My flashing warning message!", EditorStyles.boldLabel);
  45.             GUI.color = originalGUIColor;
  46.         }
  48.         /// <summary>
  49.         /// Update() is not automatically called in UnityEditor.Editor controls.
  50.         /// We can, however, hook into the EditorApplication.update delegate.
  51.         /// </summary>
  52.         private void UpdateHook()
  53.         {
  54.             // Determine the amount of time elapsed since last frame. Remember that 
  55.             // we are in edit mode, so we cannot use Time.deltaTime.
  56.             float timeElapsed = Time.realtimeSinceStartup - _realTimeLastFrame;
  57.             _realTimeLastFrame = Time.realtimeSinceStartup;
  59.             // Update our flashing text color
  60.             UpdateFlashingTextColor(timeElapsed);
  61.         }
  63.         /// <summary>
  64.         /// Updates our flashing text color (for displaying warning messages in 
  65.         /// the inspector).
  66.         /// </summary>
  67.         /// <param name="timeElapsed"></param>
  68.         private void UpdateFlashingTextColor(float timeElapsed)
  69.         {
  70.             // Don't fade the text out entirely, just to low opacity, so it can 
  71.             // flash but still always be easily read.
  72.             float minOpacity = .3f;
  74.             // Determine how much to change the color based on the time elapsed
  75.             float amountToChange = (timeElapsed / FlashingTextCycleDuration) * (1f - minOpacity) * 2;
  77.             // Fade the color in or out
  78.             if (_fadingColorIn)
  79.                 _flashingTextColor.a += amountToChange;
  80.             else
  81.                 _flashingTextColor.a -= amountToChange;
  83.             // When we've fully faded out, start to fade in, and vice versa
  84.             if (_flashingTextColor.a < minOpacity)
  85.             {
  86.                 _flashingTextColor.a = minOpacity;
  87.                 _fadingColorIn = true;
  88.             }
  90.             if (_flashingTextColor.a > 1)
  91.             {
  92.                 _flashingTextColor.a = 1;
  93.                 _fadingColorIn = false;
  94.             }
  96.             // Repaint our inspector window
  97.             Repaint();
  98.         }
  99.     }
  100. }


Comments are closed here.