Merge branch 'feat-dev3' into 'main'

Feat dev3

See merge request unity-cross/UnityDemo!1

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_ExampleScript_01.cs

+using UnityEngine;
+using UnityEngine.UI;
+using System.Collections;
+using TMPro;
+
+
+namespace TMPro.Examples
+{
+
+    public class TMP_ExampleScript_01 : MonoBehaviour
+    {
+        public enum objectType { TextMeshPro = 0, TextMeshProUGUI = 1 };
+
+        public objectType ObjectType;
+        public bool isStatic;
+
+        private TMP_Text m_text;
+
+        //private TMP_InputField m_inputfield;
+
+
+        private const string k_label = "The count is <#0080ff>{0}</color>";
+        private int count;
+
+        void Awake()
+        {
+            // Get a reference to the TMP text component if one already exists otherwise add one.
+            // This example show the convenience of having both TMP components derive from TMP_Text. 
+            if (ObjectType == 0)
+                m_text = GetComponent<TextMeshPro>() ?? gameObject.AddComponent<TextMeshPro>();
+            else
+                m_text = GetComponent<TextMeshProUGUI>() ?? gameObject.AddComponent<TextMeshProUGUI>();
+
+            // Load a new font asset and assign it to the text object.
+            m_text.font = Resources.Load<TMP_FontAsset>("Fonts & Materials/Anton SDF");
+
+            // Load a new material preset which was created with the context menu duplicate.
+            m_text.fontSharedMaterial = Resources.Load<Material>("Fonts & Materials/Anton SDF - Drop Shadow");
+
+            // Set the size of the font.
+            m_text.fontSize = 120;
+
+            // Set the text
+            m_text.text = "A <#0080ff>simple</color> line of text.";
+
+            // Get the preferred width and height based on the supplied width and height as opposed to the actual size of the current text container.
+            Vector2 size = m_text.GetPreferredValues(Mathf.Infinity, Mathf.Infinity);
+
+            // Set the size of the RectTransform based on the new calculated values.
+            m_text.rectTransform.sizeDelta = new Vector2(size.x, size.y);
+        }
+
+
+        void Update()
+        {
+            if (!isStatic)
+            {
+                m_text.SetText(k_label, count % 1000);
+                count += 1;
+            }
+        }
+
+    }
+}

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_ExampleScript_01.cs.meta

+fileFormatVersion: 2
+guid: 6f2c5b59b6874405865e2616e4ec276a
+timeCreated: 1449625634
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_FrameRateCounter.cs

+using UnityEngine;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+    
+    public class TMP_FrameRateCounter : MonoBehaviour
+    {
+        public float UpdateInterval = 5.0f;
+        private float m_LastInterval = 0;
+        private int m_Frames = 0;
+
+        public enum FpsCounterAnchorPositions { TopLeft, BottomLeft, TopRight, BottomRight };
+
+        public FpsCounterAnchorPositions AnchorPosition = FpsCounterAnchorPositions.TopRight;
+
+        private string htmlColorTag;
+        private const string fpsLabel = "{0:2}</color> <#8080ff>FPS \n<#FF8000>{1:2} <#8080ff>MS";
+
+        private TextMeshPro m_TextMeshPro;
+        private Transform m_frameCounter_transform;
+        private Camera m_camera;
+
+        private FpsCounterAnchorPositions last_AnchorPosition;
+
+        void Awake()
+        {
+            if (!enabled)
+                return;
+
+            m_camera = Camera.main;
+            Application.targetFrameRate = 9999;
+
+            GameObject frameCounter = new GameObject("Frame Counter");
+
+            m_TextMeshPro = frameCounter.AddComponent<TextMeshPro>();
+            m_TextMeshPro.font = Resources.Load<TMP_FontAsset>("Fonts & Materials/LiberationSans SDF");
+            m_TextMeshPro.fontSharedMaterial = Resources.Load<Material>("Fonts & Materials/LiberationSans SDF - Overlay");
+
+
+            m_frameCounter_transform = frameCounter.transform;
+            m_frameCounter_transform.SetParent(m_camera.transform);
+            m_frameCounter_transform.localRotation = Quaternion.identity;
+
+            m_TextMeshPro.enableWordWrapping = false;
+            m_TextMeshPro.fontSize = 24;
+            //m_TextMeshPro.FontColor = new Color32(255, 255, 255, 128);
+            //m_TextMeshPro.edgeWidth = .15f;
+            //m_TextMeshPro.isOverlay = true;
+
+            //m_TextMeshPro.FaceColor = new Color32(255, 128, 0, 0);
+            //m_TextMeshPro.EdgeColor = new Color32(0, 255, 0, 255);
+            //m_TextMeshPro.FontMaterial.renderQueue = 4000;
+
+            //m_TextMeshPro.CreateSoftShadowClone(new Vector2(1f, -1f));
+
+            Set_FrameCounter_Position(AnchorPosition);
+            last_AnchorPosition = AnchorPosition;
+
+
+        }
+
+        void Start()
+        {
+            m_LastInterval = Time.realtimeSinceStartup;
+            m_Frames = 0;
+        }
+
+        void Update()
+        {
+            if (AnchorPosition != last_AnchorPosition)
+                Set_FrameCounter_Position(AnchorPosition);
+
+            last_AnchorPosition = AnchorPosition;
+
+            m_Frames += 1;
+            float timeNow = Time.realtimeSinceStartup;
+
+            if (timeNow > m_LastInterval + UpdateInterval)
+            {
+                // display two fractional digits (f2 format)
+                float fps = m_Frames / (timeNow - m_LastInterval);
+                float ms = 1000.0f / Mathf.Max(fps, 0.00001f);
+
+                if (fps < 30)
+                    htmlColorTag = "<color=yellow>";
+                else if (fps < 10)
+                    htmlColorTag = "<color=red>";
+                else
+                    htmlColorTag = "<color=green>";
+
+                //string format = System.String.Format(htmlColorTag + "{0:F2} </color>FPS \n{1:F2} <#8080ff>MS",fps, ms);
+                //m_TextMeshPro.text = format;
+
+                m_TextMeshPro.SetText(htmlColorTag + fpsLabel, fps, ms);
+
+                m_Frames = 0;
+                m_LastInterval = timeNow;
+            }
+        }
+
+
+        void Set_FrameCounter_Position(FpsCounterAnchorPositions anchor_position)
+        {
+            //Debug.Log("Changing frame counter anchor position.");
+            m_TextMeshPro.margin = new Vector4(1f, 1f, 1f, 1f);
+
+            switch (anchor_position)
+            {
+                case FpsCounterAnchorPositions.TopLeft:
+                    m_TextMeshPro.alignment = TextAlignmentOptions.TopLeft;
+                    m_TextMeshPro.rectTransform.pivot = new Vector2(0, 1);
+                    m_frameCounter_transform.position = m_camera.ViewportToWorldPoint(new Vector3(0, 1, 100.0f));
+                    break;
+                case FpsCounterAnchorPositions.BottomLeft:
+                    m_TextMeshPro.alignment = TextAlignmentOptions.BottomLeft;
+                    m_TextMeshPro.rectTransform.pivot = new Vector2(0, 0);
+                    m_frameCounter_transform.position = m_camera.ViewportToWorldPoint(new Vector3(0, 0, 100.0f));
+                    break;
+                case FpsCounterAnchorPositions.TopRight:
+                    m_TextMeshPro.alignment = TextAlignmentOptions.TopRight;
+                    m_TextMeshPro.rectTransform.pivot = new Vector2(1, 1);
+                    m_frameCounter_transform.position = m_camera.ViewportToWorldPoint(new Vector3(1, 1, 100.0f));
+                    break;
+                case FpsCounterAnchorPositions.BottomRight:
+                    m_TextMeshPro.alignment = TextAlignmentOptions.BottomRight;
+                    m_TextMeshPro.rectTransform.pivot = new Vector2(1, 0);
+                    m_frameCounter_transform.position = m_camera.ViewportToWorldPoint(new Vector3(1, 0, 100.0f));
+                    break;
+            }
+        }
+    }
+}

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_FrameRateCounter.cs.meta

+fileFormatVersion: 2
+guid: 686ec78b56aa445795335fbadafcfaa4
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_PhoneNumberValidator.cs

+using UnityEngine;
+using System.Collections;
+using System;
+
+namespace TMPro
+{
+    /// <summary>
+    /// Example of a Custom Character Input Validator to only allow phone number in the (800) 555-1212 format.
+    /// </summary>
+    [Serializable]
+    //[CreateAssetMenu(fileName = "InputValidator - Phone Numbers.asset", menuName = "TextMeshPro/Input Validators/Phone Numbers")]
+    public class TMP_PhoneNumberValidator : TMP_InputValidator
+    {
+        // Custom text input validation function
+        public override char Validate(ref string text, ref int pos, char ch)
+        {
+            Debug.Log("Trying to validate...");
+            
+            // Return unless the character is a valid digit
+            if (ch < '0' && ch > '9') return (char)0;
+
+            int length = text.Length;
+
+            // Enforce Phone Number format for every character input.
+            for (int i = 0; i < length + 1; i++)
+            {
+                switch (i)
+                {
+                    case 0:
+                        if (i == length)
+                            text = "(" + ch;
+                        pos = 2;
+                        break;
+                    case 1:
+                        if (i == length)
+                            text += ch;
+                        pos = 2;
+                        break;
+                    case 2:
+                        if (i == length)
+                            text += ch;
+                        pos = 3;
+                        break;
+                    case 3:
+                        if (i == length)
+                            text += ch + ") ";
+                        pos = 6;
+                        break;
+                    case 4:
+                        if (i == length)
+                            text += ") " + ch;
+                        pos = 7;
+                        break;
+                    case 5:
+                        if (i == length)
+                            text += " " + ch;
+                        pos = 7;
+                        break;
+                    case 6:
+                        if (i == length)
+                            text += ch;
+                        pos = 7;
+                        break;
+                    case 7:
+                        if (i == length)
+                            text += ch;
+                        pos = 8;
+                        break;
+                    case 8:
+                        if (i == length)
+                            text += ch + "-";
+                        pos = 10;
+                        break;
+                    case 9:
+                        if (i == length)
+                            text += "-" + ch;
+                        pos = 11;
+                        break;
+                    case 10:
+                        if (i == length)
+                            text += ch;
+                        pos = 11;
+                        break;
+                    case 11:
+                        if (i == length)
+                            text += ch;
+                        pos = 12;
+                        break;
+                    case 12:
+                        if (i == length)
+                            text += ch;
+                        pos = 13;
+                        break;
+                    case 13:
+                        if (i == length)
+                            text += ch;
+                        pos = 14;
+                        break;
+                }
+            }
+
+            return ch;
+        }
+    }
+}

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_PhoneNumberValidator.cs.meta

+fileFormatVersion: 2
+guid: 83680ab1a69f4102ac67d1459fe76e1f
+timeCreated: 1473056437
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_TextEventCheck.cs

+using UnityEngine;
+
+
+namespace TMPro.Examples
+{
+    public class TMP_TextEventCheck : MonoBehaviour
+    {
+
+        public TMP_TextEventHandler TextEventHandler;
+
+        private TMP_Text m_TextComponent;
+
+        void OnEnable()
+        {
+            if (TextEventHandler != null)
+            {
+                // Get a reference to the text component
+                m_TextComponent = TextEventHandler.GetComponent<TMP_Text>();
+                
+                TextEventHandler.onCharacterSelection.AddListener(OnCharacterSelection);
+                TextEventHandler.onSpriteSelection.AddListener(OnSpriteSelection);
+                TextEventHandler.onWordSelection.AddListener(OnWordSelection);
+                TextEventHandler.onLineSelection.AddListener(OnLineSelection);
+                TextEventHandler.onLinkSelection.AddListener(OnLinkSelection);
+            }
+        }
+
+
+        void OnDisable()
+        {
+            if (TextEventHandler != null)
+            {
+                TextEventHandler.onCharacterSelection.RemoveListener(OnCharacterSelection);
+                TextEventHandler.onSpriteSelection.RemoveListener(OnSpriteSelection);
+                TextEventHandler.onWordSelection.RemoveListener(OnWordSelection);
+                TextEventHandler.onLineSelection.RemoveListener(OnLineSelection);
+                TextEventHandler.onLinkSelection.RemoveListener(OnLinkSelection);
+            }
+        }
+
+
+        void OnCharacterSelection(char c, int index)
+        {
+            Debug.Log("Character [" + c + "] at Index: " + index + " has been selected.");
+        }
+
+        void OnSpriteSelection(char c, int index)
+        {
+            Debug.Log("Sprite [" + c + "] at Index: " + index + " has been selected.");
+        }
+
+        void OnWordSelection(string word, int firstCharacterIndex, int length)
+        {
+            Debug.Log("Word [" + word + "] with first character index of " + firstCharacterIndex + " and length of " + length + " has been selected.");
+        }
+
+        void OnLineSelection(string lineText, int firstCharacterIndex, int length)
+        {
+            Debug.Log("Line [" + lineText + "] with first character index of " + firstCharacterIndex + " and length of " + length + " has been selected.");
+        }
+
+        void OnLinkSelection(string linkID, string linkText, int linkIndex)
+        {
+            if (m_TextComponent != null)
+            {
+                TMP_LinkInfo linkInfo = m_TextComponent.textInfo.linkInfo[linkIndex];
+            }
+            
+            Debug.Log("Link Index: " + linkIndex + " with ID [" + linkID + "] and Text \"" + linkText + "\" has been selected.");
+        }
+
+    }
+}

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_TextEventCheck.cs.meta

+fileFormatVersion: 2
+guid: d736ce056cf444ca96e424f4d9c42b76
+timeCreated: 1480416736
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_TextEventHandler.cs

+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.EventSystems;
+using System;
+
+
+namespace TMPro
+{
+
+    public class TMP_TextEventHandler : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
+    {
+        [Serializable]
+        public class CharacterSelectionEvent : UnityEvent<char, int> { }
+
+        [Serializable]
+        public class SpriteSelectionEvent : UnityEvent<char, int> { }
+
+        [Serializable]
+        public class WordSelectionEvent : UnityEvent<string, int, int> { }
+
+        [Serializable]
+        public class LineSelectionEvent : UnityEvent<string, int, int> { }
+
+        [Serializable]
+        public class LinkSelectionEvent : UnityEvent<string, string, int> { }
+
+
+        /// <summary>
+        /// Event delegate triggered when pointer is over a character.
+        /// </summary>
+        public CharacterSelectionEvent onCharacterSelection
+        {
+            get { return m_OnCharacterSelection; }
+            set { m_OnCharacterSelection = value; }
+        }
+        [SerializeField]
+        private CharacterSelectionEvent m_OnCharacterSelection = new CharacterSelectionEvent();
+
+
+        /// <summary>
+        /// Event delegate triggered when pointer is over a sprite.
+        /// </summary>
+        public SpriteSelectionEvent onSpriteSelection
+        {
+            get { return m_OnSpriteSelection; }
+            set { m_OnSpriteSelection = value; }
+        }
+        [SerializeField]
+        private SpriteSelectionEvent m_OnSpriteSelection = new SpriteSelectionEvent();
+
+
+        /// <summary>
+        /// Event delegate triggered when pointer is over a word.
+        /// </summary>
+        public WordSelectionEvent onWordSelection
+        {
+            get { return m_OnWordSelection; }
+            set { m_OnWordSelection = value; }
+        }
+        [SerializeField]
+        private WordSelectionEvent m_OnWordSelection = new WordSelectionEvent();
+
+
+        /// <summary>
+        /// Event delegate triggered when pointer is over a line.
+        /// </summary>
+        public LineSelectionEvent onLineSelection
+        {
+            get { return m_OnLineSelection; }
+            set { m_OnLineSelection = value; }
+        }
+        [SerializeField]
+        private LineSelectionEvent m_OnLineSelection = new LineSelectionEvent();
+
+
+        /// <summary>
+        /// Event delegate triggered when pointer is over a link.
+        /// </summary>
+        public LinkSelectionEvent onLinkSelection
+        {
+            get { return m_OnLinkSelection; }
+            set { m_OnLinkSelection = value; }
+        }
+        [SerializeField]
+        private LinkSelectionEvent m_OnLinkSelection = new LinkSelectionEvent();
+
+
+
+        private TMP_Text m_TextComponent;
+
+        private Camera m_Camera;
+        private Canvas m_Canvas;
+
+        private int m_selectedLink = -1;
+        private int m_lastCharIndex = -1;
+        private int m_lastWordIndex = -1;
+        private int m_lastLineIndex = -1;
+
+        void Awake()
+        {
+            // Get a reference to the text component.
+            m_TextComponent = gameObject.GetComponent<TMP_Text>();
+
+            // Get a reference to the camera rendering the text taking into consideration the text component type.
+            if (m_TextComponent.GetType() == typeof(TextMeshProUGUI))
+            {
+                m_Canvas = gameObject.GetComponentInParent<Canvas>();
+                if (m_Canvas != null)
+                {
+                    if (m_Canvas.renderMode == RenderMode.ScreenSpaceOverlay)
+                        m_Camera = null;
+                    else
+                        m_Camera = m_Canvas.worldCamera;
+                }
+            }
+            else
+            {
+                m_Camera = Camera.main;
+            }
+        }
+
+
+        void LateUpdate()
+        {
+            if (TMP_TextUtilities.IsIntersectingRectTransform(m_TextComponent.rectTransform, Input.mousePosition, m_Camera))
+            {
+                #region Example of Character or Sprite Selection
+                int charIndex = TMP_TextUtilities.FindIntersectingCharacter(m_TextComponent, Input.mousePosition, m_Camera, true);
+                if (charIndex != -1 && charIndex != m_lastCharIndex)
+                {
+                    m_lastCharIndex = charIndex;
+
+                    TMP_TextElementType elementType = m_TextComponent.textInfo.characterInfo[charIndex].elementType;
+
+                    // Send event to any event listeners depending on whether it is a character or sprite.
+                    if (elementType == TMP_TextElementType.Character)
+                        SendOnCharacterSelection(m_TextComponent.textInfo.characterInfo[charIndex].character, charIndex);
+                    else if (elementType == TMP_TextElementType.Sprite)
+                        SendOnSpriteSelection(m_TextComponent.textInfo.characterInfo[charIndex].character, charIndex);
+                }
+                #endregion
+
+
+                #region Example of Word Selection
+                // Check if Mouse intersects any words and if so assign a random color to that word.
+                int wordIndex = TMP_TextUtilities.FindIntersectingWord(m_TextComponent, Input.mousePosition, m_Camera);
+                if (wordIndex != -1 && wordIndex != m_lastWordIndex)
+                {
+                    m_lastWordIndex = wordIndex;
+
+                    // Get the information about the selected word.
+                    TMP_WordInfo wInfo = m_TextComponent.textInfo.wordInfo[wordIndex];
+
+                    // Send the event to any listeners.
+                    SendOnWordSelection(wInfo.GetWord(), wInfo.firstCharacterIndex, wInfo.characterCount);
+                }
+                #endregion
+
+
+                #region Example of Line Selection
+                // Check if Mouse intersects any words and if so assign a random color to that word.
+                int lineIndex = TMP_TextUtilities.FindIntersectingLine(m_TextComponent, Input.mousePosition, m_Camera);
+                if (lineIndex != -1 && lineIndex != m_lastLineIndex)
+                {
+                    m_lastLineIndex = lineIndex;
+
+                    // Get the information about the selected word.
+                    TMP_LineInfo lineInfo = m_TextComponent.textInfo.lineInfo[lineIndex];
+
+                    // Send the event to any listeners.
+                    char[] buffer = new char[lineInfo.characterCount];
+                    for (int i = 0; i < lineInfo.characterCount && i < m_TextComponent.textInfo.characterInfo.Length; i++)
+                    {
+                        buffer[i] = m_TextComponent.textInfo.characterInfo[i + lineInfo.firstCharacterIndex].character;
+                    }
+
+                    string lineText = new string(buffer);
+                    SendOnLineSelection(lineText, lineInfo.firstCharacterIndex, lineInfo.characterCount);
+                }
+                #endregion
+
+
+                #region Example of Link Handling
+                // Check if mouse intersects with any links.
+                int linkIndex = TMP_TextUtilities.FindIntersectingLink(m_TextComponent, Input.mousePosition, m_Camera);
+
+                // Handle new Link selection.
+                if (linkIndex != -1 && linkIndex != m_selectedLink)
+                {
+                    m_selectedLink = linkIndex;
+
+                    // Get information about the link.
+                    TMP_LinkInfo linkInfo = m_TextComponent.textInfo.linkInfo[linkIndex];
+
+                    // Send the event to any listeners.
+                    SendOnLinkSelection(linkInfo.GetLinkID(), linkInfo.GetLinkText(), linkIndex);
+                }
+                #endregion
+            }
+            else
+            {
+                // Reset all selections given we are hovering outside the text container bounds.
+                m_selectedLink = -1;
+                m_lastCharIndex = -1;
+                m_lastWordIndex = -1;
+                m_lastLineIndex = -1;
+            }
+        }
+
+
+        public void OnPointerEnter(PointerEventData eventData)
+        {
+            //Debug.Log("OnPointerEnter()");
+        }
+
+
+        public void OnPointerExit(PointerEventData eventData)
+        {
+            //Debug.Log("OnPointerExit()");
+        }
+
+
+        private void SendOnCharacterSelection(char character, int characterIndex)
+        {
+            if (onCharacterSelection != null)
+                onCharacterSelection.Invoke(character, characterIndex);
+        }
+
+        private void SendOnSpriteSelection(char character, int characterIndex)
+        {
+            if (onSpriteSelection != null)
+                onSpriteSelection.Invoke(character, characterIndex);
+        }
+
+        private void SendOnWordSelection(string word, int charIndex, int length)
+        {
+            if (onWordSelection != null)
+                onWordSelection.Invoke(word, charIndex, length);
+        }
+
+        private void SendOnLineSelection(string line, int charIndex, int length)
+        {
+            if (onLineSelection != null)
+                onLineSelection.Invoke(line, charIndex, length);
+        }
+
+        private void SendOnLinkSelection(string linkID, string linkText, int linkIndex)
+        {
+            if (onLinkSelection != null)
+                onLinkSelection.Invoke(linkID, linkText, linkIndex);
+        }
+
+    }
+}

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_TextEventHandler.cs.meta

+fileFormatVersion: 2
+guid: 1312ae25639a4bae8e25ae223209cc50
+timeCreated: 1452811039
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_TextInfoDebugTool.cs

+using System;
+using UnityEngine;
+using System.Collections;
+using UnityEditor;
+
+
+namespace TMPro.Examples
+{
+
+    public class TMP_TextInfoDebugTool : MonoBehaviour
+    {
+        // Since this script is used for debugging, we exclude it from builds.
+        // TODO: Rework this script to make it into an editor utility.
+        #if UNITY_EDITOR
+        public bool ShowCharacters;
+        public bool ShowWords;
+        public bool ShowLinks;
+        public bool ShowLines;
+        public bool ShowMeshBounds;
+        public bool ShowTextBounds;
+        [Space(10)]
+        [TextArea(2, 2)]
+        public string ObjectStats;
+
+        [SerializeField]
+        private TMP_Text m_TextComponent;
+
+        private Transform m_Transform;
+        private TMP_TextInfo m_TextInfo;
+
+        private float m_ScaleMultiplier;
+        private float m_HandleSize;
+
+
+        void OnDrawGizmos()
+        {
+            if (m_TextComponent == null)
+            {
+                m_TextComponent = GetComponent<TMP_Text>();
+
+                if (m_TextComponent == null)
+                    return;
+            }
+
+            m_Transform = m_TextComponent.transform;
+
+            // Get a reference to the text object's textInfo
+            m_TextInfo = m_TextComponent.textInfo;
+
+            // Update Text Statistics
+            ObjectStats = "Characters: " + m_TextInfo.characterCount + "   Words: " + m_TextInfo.wordCount + "   Spaces: " + m_TextInfo.spaceCount + "   Sprites: " + m_TextInfo.spriteCount + "   Links: " + m_TextInfo.linkCount
+                          + "\nLines: " + m_TextInfo.lineCount + "   Pages: " + m_TextInfo.pageCount;
+
+            // Get the handle size for drawing the various
+            m_ScaleMultiplier = m_TextComponent.GetType() == typeof(TextMeshPro) ? 1 : 0.1f;
+            m_HandleSize = HandleUtility.GetHandleSize(m_Transform.position) * m_ScaleMultiplier;
+
+            // Draw line metrics
+            #region Draw Lines
+            if (ShowLines)
+                DrawLineBounds();
+            #endregion
+
+            // Draw word metrics
+            #region Draw Words
+            if (ShowWords)
+                DrawWordBounds();
+            #endregion
+
+            // Draw character metrics
+            #region Draw Characters
+            if (ShowCharacters)
+                DrawCharactersBounds();
+            #endregion
+
+            // Draw Quads around each of the words
+            #region Draw Links
+            if (ShowLinks)
+                DrawLinkBounds();
+            #endregion
+
+            // Draw Quad around the bounds of the text
+            #region Draw Bounds
+            if (ShowMeshBounds)
+                DrawBounds();
+            #endregion
+
+            // Draw Quad around the rendered region of the text.
+            #region Draw Text Bounds
+            if (ShowTextBounds)
+                DrawTextBounds();
+            #endregion
+        }
+
+
+        /// <summary>
+        /// Method to draw a rectangle around each character.
+        /// </summary>
+        /// <param name="text"></param>
+        void DrawCharactersBounds()
+        {
+            int characterCount = m_TextInfo.characterCount;
+
+            for (int i = 0; i < characterCount; i++)
+            {
+                // Draw visible as well as invisible characters
+                TMP_CharacterInfo characterInfo = m_TextInfo.characterInfo[i];
+
+                bool isCharacterVisible = i < m_TextComponent.maxVisibleCharacters &&
+                                          characterInfo.lineNumber < m_TextComponent.maxVisibleLines &&
+                                          i >= m_TextComponent.firstVisibleCharacter;
+
+                if (m_TextComponent.overflowMode == TextOverflowModes.Page)
+                    isCharacterVisible = isCharacterVisible && characterInfo.pageNumber + 1 == m_TextComponent.pageToDisplay;
+
+                if (!isCharacterVisible)
+                    continue;
+
+                float dottedLineSize = 6;
+
+                // Get Bottom Left and Top Right position of the current character
+                Vector3 bottomLeft = m_Transform.TransformPoint(characterInfo.bottomLeft);
+                Vector3 topLeft = m_Transform.TransformPoint(new Vector3(characterInfo.topLeft.x, characterInfo.topLeft.y, 0));
+                Vector3 topRight = m_Transform.TransformPoint(characterInfo.topRight);
+                Vector3 bottomRight = m_Transform.TransformPoint(new Vector3(characterInfo.bottomRight.x, characterInfo.bottomRight.y, 0));
+
+                // Draw character bounds
+                if (characterInfo.isVisible)
+                {
+                    Color color = Color.green;
+                    DrawDottedRectangle(bottomLeft, topRight, color);
+                }
+                else
+                {
+                    Color color = Color.grey;
+
+                    float whiteSpaceAdvance = Math.Abs(characterInfo.origin - characterInfo.xAdvance) > 0.01f ? characterInfo.xAdvance : characterInfo.origin + (characterInfo.ascender - characterInfo.descender) * 0.03f;
+                    DrawDottedRectangle(m_Transform.TransformPoint(new Vector3(characterInfo.origin, characterInfo.descender, 0)), m_Transform.TransformPoint(new Vector3(whiteSpaceAdvance, characterInfo.ascender, 0)), color, 4);
+                }
+
+                float origin = characterInfo.origin;
+                float advance = characterInfo.xAdvance;
+                float ascentline = characterInfo.ascender;
+                float baseline = characterInfo.baseLine;
+                float descentline = characterInfo.descender;
+
+                //Draw Ascent line
+                Vector3 ascentlineStart = m_Transform.TransformPoint(new Vector3(origin, ascentline, 0));
+                Vector3 ascentlineEnd = m_Transform.TransformPoint(new Vector3(advance, ascentline, 0));
+
+                Handles.color = Color.cyan;
+                Handles.DrawDottedLine(ascentlineStart, ascentlineEnd, dottedLineSize);
+
+                // Draw Cap Height & Mean line
+                float capline = characterInfo.fontAsset == null ? 0 : baseline + characterInfo.fontAsset.faceInfo.capLine * characterInfo.scale;
+                Vector3 capHeightStart = new Vector3(topLeft.x, m_Transform.TransformPoint(new Vector3(0, capline, 0)).y, 0);
+                Vector3 capHeightEnd = new Vector3(topRight.x, m_Transform.TransformPoint(new Vector3(0, capline, 0)).y, 0);
+
+                float meanline = characterInfo.fontAsset == null ? 0 : baseline + characterInfo.fontAsset.faceInfo.meanLine * characterInfo.scale;
+                Vector3 meanlineStart = new Vector3(topLeft.x, m_Transform.TransformPoint(new Vector3(0, meanline, 0)).y, 0);
+                Vector3 meanlineEnd = new Vector3(topRight.x, m_Transform.TransformPoint(new Vector3(0, meanline, 0)).y, 0);
+
+                if (characterInfo.isVisible)
+                {
+                    // Cap line
+                    Handles.color = Color.cyan;
+                    Handles.DrawDottedLine(capHeightStart, capHeightEnd, dottedLineSize);
+
+                    // Mean line
+                    Handles.color = Color.cyan;
+                    Handles.DrawDottedLine(meanlineStart, meanlineEnd, dottedLineSize);
+                }
+
+                //Draw Base line
+                Vector3 baselineStart = m_Transform.TransformPoint(new Vector3(origin, baseline, 0));
+                Vector3 baselineEnd = m_Transform.TransformPoint(new Vector3(advance, baseline, 0));
+
+                Handles.color = Color.cyan;
+                Handles.DrawDottedLine(baselineStart, baselineEnd, dottedLineSize);
+
+                //Draw Descent line
+                Vector3 descentlineStart = m_Transform.TransformPoint(new Vector3(origin, descentline, 0));
+                Vector3 descentlineEnd = m_Transform.TransformPoint(new Vector3(advance, descentline, 0));
+
+                Handles.color = Color.cyan;
+                Handles.DrawDottedLine(descentlineStart, descentlineEnd, dottedLineSize);
+
+                // Draw Origin
+                Vector3 originPosition = m_Transform.TransformPoint(new Vector3(origin, baseline, 0));
+                DrawCrosshair(originPosition, 0.05f / m_ScaleMultiplier, Color.cyan);
+
+                // Draw Horizontal Advance
+                Vector3 advancePosition = m_Transform.TransformPoint(new Vector3(advance, baseline, 0));
+                DrawSquare(advancePosition, 0.025f / m_ScaleMultiplier, Color.yellow);
+                DrawCrosshair(advancePosition, 0.0125f / m_ScaleMultiplier, Color.yellow);
+
+                // Draw text labels for metrics
+               if (m_HandleSize < 0.5f)
+               {
+                   GUIStyle style = new GUIStyle(GUI.skin.GetStyle("Label"));
+                   style.normal.textColor = new Color(0.6f, 0.6f, 0.6f, 1.0f);
+                   style.fontSize = 12;
+                   style.fixedWidth = 200;
+                   style.fixedHeight = 20;
+
+                   Vector3 labelPosition;
+                   float center = (origin + advance) / 2;
+
+                   //float baselineMetrics = 0;
+                   //float ascentlineMetrics = ascentline - baseline;
+                   //float caplineMetrics = capline - baseline;
+                   //float meanlineMetrics = meanline - baseline;
+                   //float descentlineMetrics = descentline - baseline;
+
+                   // Ascent Line
+                   labelPosition = m_Transform.TransformPoint(new Vector3(center, ascentline, 0));
+                   style.alignment = TextAnchor.UpperCenter;
+                   Handles.Label(labelPosition, "Ascent Line", style);
+                   //Handles.Label(labelPosition, "Ascent Line (" + ascentlineMetrics.ToString("f3") + ")" , style);
+
+                   // Base Line
+                   labelPosition = m_Transform.TransformPoint(new Vector3(center, baseline, 0));
+                   Handles.Label(labelPosition, "Base Line", style);
+                   //Handles.Label(labelPosition, "Base Line (" + baselineMetrics.ToString("f3") + ")" , style);
+
+                   // Descent line
+                   labelPosition = m_Transform.TransformPoint(new Vector3(center, descentline, 0));
+                   Handles.Label(labelPosition, "Descent Line", style);
+                   //Handles.Label(labelPosition, "Descent Line (" + descentlineMetrics.ToString("f3") + ")" , style);
+
+                   if (characterInfo.isVisible)
+                   {
+                       // Cap Line
+                       labelPosition = m_Transform.TransformPoint(new Vector3(center, capline, 0));
+                       style.alignment = TextAnchor.UpperCenter;
+                       Handles.Label(labelPosition, "Cap Line", style);
+                       //Handles.Label(labelPosition, "Cap Line (" + caplineMetrics.ToString("f3") + ")" , style);
+
+                       // Mean Line
+                       labelPosition = m_Transform.TransformPoint(new Vector3(center, meanline, 0));
+                       style.alignment = TextAnchor.UpperCenter;
+                       Handles.Label(labelPosition, "Mean Line", style);
+                       //Handles.Label(labelPosition, "Mean Line (" + ascentlineMetrics.ToString("f3") + ")" , style);
+
+                       // Origin
+                       labelPosition = m_Transform.TransformPoint(new Vector3(origin, baseline, 0));
+                       style.alignment = TextAnchor.UpperRight;
+                       Handles.Label(labelPosition, "Origin ", style);
+
+                       // Advance
+                       labelPosition = m_Transform.TransformPoint(new Vector3(advance, baseline, 0));
+                       style.alignment = TextAnchor.UpperLeft;
+                       Handles.Label(labelPosition, "  Advance", style);
+                   }
+               }
+            }
+        }
+
+
+        /// <summary>
+        /// Method to draw rectangles around each word of the text.
+        /// </summary>
+        /// <param name="text"></param>
+        void DrawWordBounds()
+        {
+            for (int i = 0; i < m_TextInfo.wordCount; i++)
+            {
+                TMP_WordInfo wInfo = m_TextInfo.wordInfo[i];
+
+                bool isBeginRegion = false;
+
+                Vector3 bottomLeft = Vector3.zero;
+                Vector3 topLeft = Vector3.zero;
+                Vector3 bottomRight = Vector3.zero;
+                Vector3 topRight = Vector3.zero;
+
+                float maxAscender = -Mathf.Infinity;
+                float minDescender = Mathf.Infinity;
+
+                Color wordColor = Color.green;
+
+                // Iterate through each character of the word
+                for (int j = 0; j < wInfo.characterCount; j++)
+                {
+                    int characterIndex = wInfo.firstCharacterIndex + j;
+                    TMP_CharacterInfo currentCharInfo = m_TextInfo.characterInfo[characterIndex];
+                    int currentLine = currentCharInfo.lineNumber;
+
+                    bool isCharacterVisible = characterIndex > m_TextComponent.maxVisibleCharacters ||
+                                              currentCharInfo.lineNumber > m_TextComponent.maxVisibleLines ||
+                                             (m_TextComponent.overflowMode == TextOverflowModes.Page && currentCharInfo.pageNumber + 1 != m_TextComponent.pageToDisplay) ? false : true;
+
+                    // Track Max Ascender and Min Descender
+                    maxAscender = Mathf.Max(maxAscender, currentCharInfo.ascender);
+                    minDescender = Mathf.Min(minDescender, currentCharInfo.descender);
+
+                    if (isBeginRegion == false && isCharacterVisible)
+                    {
+                        isBeginRegion = true;
+
+                        bottomLeft = new Vector3(currentCharInfo.bottomLeft.x, currentCharInfo.descender, 0);
+                        topLeft = new Vector3(currentCharInfo.bottomLeft.x, currentCharInfo.ascender, 0);
+
+                        //Debug.Log("Start Word Region at [" + currentCharInfo.character + "]");
+
+                        // If Word is one character
+                        if (wInfo.characterCount == 1)
+                        {
+                            isBeginRegion = false;
+
+                            topLeft = m_Transform.TransformPoint(new Vector3(topLeft.x, maxAscender, 0));
+                            bottomLeft = m_Transform.TransformPoint(new Vector3(bottomLeft.x, minDescender, 0));
+                            bottomRight = m_Transform.TransformPoint(new Vector3(currentCharInfo.topRight.x, minDescender, 0));
+                            topRight = m_Transform.TransformPoint(new Vector3(currentCharInfo.topRight.x, maxAscender, 0));
+
+                            // Draw Region
+                            DrawRectangle(bottomLeft, topLeft, topRight, bottomRight, wordColor);
+
+                            //Debug.Log("End Word Region at [" + currentCharInfo.character + "]");
+                        }
+                    }
+
+                    // Last Character of Word
+                    if (isBeginRegion && j == wInfo.characterCount - 1)
+                    {
+                        isBeginRegion = false;
+
+                        topLeft = m_Transform.TransformPoint(new Vector3(topLeft.x, maxAscender, 0));
+                        bottomLeft = m_Transform.TransformPoint(new Vector3(bottomLeft.x, minDescender, 0));
+                        bottomRight = m_Transform.TransformPoint(new Vector3(currentCharInfo.topRight.x, minDescender, 0));
+                        topRight = m_Transform.TransformPoint(new Vector3(currentCharInfo.topRight.x, maxAscender, 0));
+
+                        // Draw Region
+                        DrawRectangle(bottomLeft, topLeft, topRight, bottomRight, wordColor);
+
+                        //Debug.Log("End Word Region at [" + currentCharInfo.character + "]");
+                    }
+                    // If Word is split on more than one line.
+                    else if (isBeginRegion && currentLine != m_TextInfo.characterInfo[characterIndex + 1].lineNumber)
+                    {
+                        isBeginRegion = false;
+
+                        topLeft = m_Transform.TransformPoint(new Vector3(topLeft.x, maxAscender, 0));
+                        bottomLeft = m_Transform.TransformPoint(new Vector3(bottomLeft.x, minDescender, 0));
+                        bottomRight = m_Transform.TransformPoint(new Vector3(currentCharInfo.topRight.x, minDescender, 0));
+                        topRight = m_Transform.TransformPoint(new Vector3(currentCharInfo.topRight.x, maxAscender, 0));
+
+                        // Draw Region
+                        DrawRectangle(bottomLeft, topLeft, topRight, bottomRight, wordColor);
+                        //Debug.Log("End Word Region at [" + currentCharInfo.character + "]");
+                        maxAscender = -Mathf.Infinity;
+                        minDescender = Mathf.Infinity;
+
+                    }
+                }
+
+                //Debug.Log(wInfo.GetWord(m_TextMeshPro.textInfo.characterInfo));
+            }
+
+
+        }
+
+
+        /// <summary>
+        /// Draw rectangle around each of the links contained in the text.
+        /// </summary>
+        /// <param name="text"></param>
+        void DrawLinkBounds()
+        {
+            TMP_TextInfo textInfo = m_TextComponent.textInfo;
+
+            for (int i = 0; i < textInfo.linkCount; i++)
+            {
+                TMP_LinkInfo linkInfo = textInfo.linkInfo[i];
+
+                bool isBeginRegion = false;
+
+                Vector3 bottomLeft = Vector3.zero;
+                Vector3 topLeft = Vector3.zero;
+                Vector3 bottomRight = Vector3.zero;
+                Vector3 topRight = Vector3.zero;
+
+                float maxAscender = -Mathf.Infinity;
+                float minDescender = Mathf.Infinity;
+
+                Color32 linkColor = Color.cyan;
+
+                // Iterate through each character of the link text
+                for (int j = 0; j < linkInfo.linkTextLength; j++)
+                {
+                    int characterIndex = linkInfo.linkTextfirstCharacterIndex + j;
+                    TMP_CharacterInfo currentCharInfo = textInfo.characterInfo[characterIndex];
+                    int currentLine = currentCharInfo.lineNumber;
+
+                    bool isCharacterVisible = characterIndex > m_TextComponent.maxVisibleCharacters ||
+                                              currentCharInfo.lineNumber > m_TextComponent.maxVisibleLines ||
+                                             (m_TextComponent.overflowMode == TextOverflowModes.Page && currentCharInfo.pageNumber + 1 != m_TextComponent.pageToDisplay) ? false : true;
+
+                    // Track Max Ascender and Min Descender
+                    maxAscender = Mathf.Max(maxAscender, currentCharInfo.ascender);
+                    minDescender = Mathf.Min(minDescender, currentCharInfo.descender);
+
+                    if (isBeginRegion == false && isCharacterVisible)
+                    {
+                        isBeginRegion = true;
+
+                        bottomLeft = new Vector3(currentCharInfo.bottomLeft.x, currentCharInfo.descender, 0);
+                        topLeft = new Vector3(currentCharInfo.bottomLeft.x, currentCharInfo.ascender, 0);
+
+                        //Debug.Log("Start Word Region at [" + currentCharInfo.character + "]");
+
+                        // If Link is one character
+                        if (linkInfo.linkTextLength == 1)
+                        {
+                            isBeginRegion = false;
+
+                            topLeft = m_Transform.TransformPoint(new Vector3(topLeft.x, maxAscender, 0));
+                            bottomLeft = m_Transform.TransformPoint(new Vector3(bottomLeft.x, minDescender, 0));
+                            bottomRight = m_Transform.TransformPoint(new Vector3(currentCharInfo.topRight.x, minDescender, 0));
+                            topRight = m_Transform.TransformPoint(new Vector3(currentCharInfo.topRight.x, maxAscender, 0));
+
+                            // Draw Region
+                            DrawRectangle(bottomLeft, topLeft, topRight, bottomRight, linkColor);
+
+                            //Debug.Log("End Word Region at [" + currentCharInfo.character + "]");
+                        }
+                    }
+
+                    // Last Character of Link
+                    if (isBeginRegion && j == linkInfo.linkTextLength - 1)
+                    {
+                        isBeginRegion = false;
+
+                        topLeft = m_Transform.TransformPoint(new Vector3(topLeft.x, maxAscender, 0));
+                        bottomLeft = m_Transform.TransformPoint(new Vector3(bottomLeft.x, minDescender, 0));
+                        bottomRight = m_Transform.TransformPoint(new Vector3(currentCharInfo.topRight.x, minDescender, 0));
+                        topRight = m_Transform.TransformPoint(new Vector3(currentCharInfo.topRight.x, maxAscender, 0));
+
+                        // Draw Region
+                        DrawRectangle(bottomLeft, topLeft, topRight, bottomRight, linkColor);
+
+                        //Debug.Log("End Word Region at [" + currentCharInfo.character + "]");
+                    }
+                    // If Link is split on more than one line.
+                    else if (isBeginRegion && currentLine != textInfo.characterInfo[characterIndex + 1].lineNumber)
+                    {
+                        isBeginRegion = false;
+
+                        topLeft = m_Transform.TransformPoint(new Vector3(topLeft.x, maxAscender, 0));
+                        bottomLeft = m_Transform.TransformPoint(new Vector3(bottomLeft.x, minDescender, 0));
+                        bottomRight = m_Transform.TransformPoint(new Vector3(currentCharInfo.topRight.x, minDescender, 0));
+                        topRight = m_Transform.TransformPoint(new Vector3(currentCharInfo.topRight.x, maxAscender, 0));
+
+                        // Draw Region
+                        DrawRectangle(bottomLeft, topLeft, topRight, bottomRight, linkColor);
+
+                        maxAscender = -Mathf.Infinity;
+                        minDescender = Mathf.Infinity;
+                        //Debug.Log("End Word Region at [" + currentCharInfo.character + "]");
+                    }
+                }
+
+                //Debug.Log(wInfo.GetWord(m_TextMeshPro.textInfo.characterInfo));
+            }
+        }
+
+
+        /// <summary>
+        /// Draw Rectangles around each lines of the text.
+        /// </summary>
+        /// <param name="text"></param>
+        void DrawLineBounds()
+        {
+            int lineCount = m_TextInfo.lineCount;
+
+            for (int i = 0; i < lineCount; i++)
+            {
+                TMP_LineInfo lineInfo = m_TextInfo.lineInfo[i];
+                TMP_CharacterInfo firstCharacterInfo = m_TextInfo.characterInfo[lineInfo.firstCharacterIndex];
+                TMP_CharacterInfo lastCharacterInfo = m_TextInfo.characterInfo[lineInfo.lastCharacterIndex];
+
+                bool isLineVisible = (lineInfo.characterCount == 1 && (firstCharacterInfo.character == 10 || firstCharacterInfo.character == 11 || firstCharacterInfo.character == 0x2028 || firstCharacterInfo.character == 0x2029)) ||
+                                      i > m_TextComponent.maxVisibleLines ||
+                                     (m_TextComponent.overflowMode == TextOverflowModes.Page && firstCharacterInfo.pageNumber + 1 != m_TextComponent.pageToDisplay) ? false : true;
+
+                if (!isLineVisible) continue;
+
+                float lineBottomLeft = firstCharacterInfo.bottomLeft.x;
+                float lineTopRight = lastCharacterInfo.topRight.x;
+
+                float ascentline = lineInfo.ascender;
+                float baseline = lineInfo.baseline;
+                float descentline = lineInfo.descender;
+
+                float dottedLineSize = 12;
+
+                // Draw line extents
+                DrawDottedRectangle(m_Transform.TransformPoint(lineInfo.lineExtents.min), m_Transform.TransformPoint(lineInfo.lineExtents.max), Color.green, 4);
+
+                // Draw Ascent line
+                Vector3 ascentlineStart = m_Transform.TransformPoint(new Vector3(lineBottomLeft, ascentline, 0));
+                Vector3 ascentlineEnd = m_Transform.TransformPoint(new Vector3(lineTopRight, ascentline, 0));
+
+                Handles.color = Color.yellow;
+                Handles.DrawDottedLine(ascentlineStart, ascentlineEnd, dottedLineSize);
+
+                // Draw Base line
+                Vector3 baseLineStart = m_Transform.TransformPoint(new Vector3(lineBottomLeft, baseline, 0));
+                Vector3 baseLineEnd = m_Transform.TransformPoint(new Vector3(lineTopRight, baseline, 0));
+
+                Handles.color = Color.yellow;
+                Handles.DrawDottedLine(baseLineStart, baseLineEnd, dottedLineSize);
+
+                // Draw Descent line
+                Vector3 descentLineStart = m_Transform.TransformPoint(new Vector3(lineBottomLeft, descentline, 0));
+                Vector3 descentLineEnd = m_Transform.TransformPoint(new Vector3(lineTopRight, descentline, 0));
+
+                Handles.color = Color.yellow;
+                Handles.DrawDottedLine(descentLineStart, descentLineEnd, dottedLineSize);
+
+                // Draw text labels for metrics
+                if (m_HandleSize < 1.0f)
+                {
+                    GUIStyle style = new GUIStyle();
+                    style.normal.textColor = new Color(0.8f, 0.8f, 0.8f, 1.0f);
+                    style.fontSize = 12;
+                    style.fixedWidth = 200;
+                    style.fixedHeight = 20;
+                    Vector3 labelPosition;
+
+                    // Ascent Line
+                    labelPosition = m_Transform.TransformPoint(new Vector3(lineBottomLeft, ascentline, 0));
+                    style.padding = new RectOffset(0, 10, 0, 5);
+                    style.alignment = TextAnchor.MiddleRight;
+                    Handles.Label(labelPosition, "Ascent Line", style);
+
+                    // Base Line
+                    labelPosition = m_Transform.TransformPoint(new Vector3(lineBottomLeft, baseline, 0));
+                    Handles.Label(labelPosition, "Base Line", style);
+
+                    // Descent line
+                    labelPosition = m_Transform.TransformPoint(new Vector3(lineBottomLeft, descentline, 0));
+                    Handles.Label(labelPosition, "Descent Line", style);
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Draw Rectangle around the bounds of the text object.
+        /// </summary>
+        void DrawBounds()
+        {
+            Bounds meshBounds = m_TextComponent.bounds;
+
+            // Get Bottom Left and Top Right position of each word
+            Vector3 bottomLeft = m_TextComponent.transform.position + meshBounds.min;
+            Vector3 topRight = m_TextComponent.transform.position + meshBounds.max;
+
+            DrawRectangle(bottomLeft, topRight, new Color(1, 0.5f, 0));
+        }
+
+
+        void DrawTextBounds()
+        {
+            Bounds textBounds = m_TextComponent.textBounds;
+
+            Vector3 bottomLeft = m_TextComponent.transform.position + (textBounds.center - textBounds.extents);
+            Vector3 topRight = m_TextComponent.transform.position + (textBounds.center + textBounds.extents);
+
+            DrawRectangle(bottomLeft, topRight, new Color(0f, 0.5f, 0.5f));
+        }
+
+
+        // Draw Rectangles
+        void DrawRectangle(Vector3 BL, Vector3 TR, Color color)
+        {
+            Gizmos.color = color;
+
+            Gizmos.DrawLine(new Vector3(BL.x, BL.y, 0), new Vector3(BL.x, TR.y, 0));
+            Gizmos.DrawLine(new Vector3(BL.x, TR.y, 0), new Vector3(TR.x, TR.y, 0));
+            Gizmos.DrawLine(new Vector3(TR.x, TR.y, 0), new Vector3(TR.x, BL.y, 0));
+            Gizmos.DrawLine(new Vector3(TR.x, BL.y, 0), new Vector3(BL.x, BL.y, 0));
+        }
+
+        void DrawDottedRectangle(Vector3 bottomLeft, Vector3 topRight, Color color, float size = 5.0f)
+        {
+            Handles.color = color;
+            Handles.DrawDottedLine(bottomLeft, new Vector3(bottomLeft.x, topRight.y, bottomLeft.z), size);
+            Handles.DrawDottedLine(new Vector3(bottomLeft.x, topRight.y, bottomLeft.z), topRight, size);
+            Handles.DrawDottedLine(topRight, new Vector3(topRight.x, bottomLeft.y, bottomLeft.z), size);
+            Handles.DrawDottedLine(new Vector3(topRight.x, bottomLeft.y, bottomLeft.z), bottomLeft, size);
+        }
+
+        void DrawSolidRectangle(Vector3 bottomLeft, Vector3 topRight, Color color, float size = 5.0f)
+        {
+            Handles.color = color;
+            Rect rect = new Rect(bottomLeft, topRight - bottomLeft);
+            Handles.DrawSolidRectangleWithOutline(rect, color, Color.black);
+        }
+
+        void DrawSquare(Vector3 position, float size, Color color)
+        {
+            Handles.color = color;
+            Vector3 bottomLeft = new Vector3(position.x - size, position.y - size, position.z);
+            Vector3 topLeft = new Vector3(position.x - size, position.y + size, position.z);
+            Vector3 topRight = new Vector3(position.x + size, position.y + size, position.z);
+            Vector3 bottomRight = new Vector3(position.x + size, position.y - size, position.z);
+
+            Handles.DrawLine(bottomLeft, topLeft);
+            Handles.DrawLine(topLeft, topRight);
+            Handles.DrawLine(topRight, bottomRight);
+            Handles.DrawLine(bottomRight, bottomLeft);
+        }
+
+        void DrawCrosshair(Vector3 position, float size, Color color)
+        {
+            Handles.color = color;
+
+            Handles.DrawLine(new Vector3(position.x - size, position.y, position.z), new Vector3(position.x + size, position.y, position.z));
+            Handles.DrawLine(new Vector3(position.x, position.y - size, position.z), new Vector3(position.x, position.y + size, position.z));
+        }
+
+
+        // Draw Rectangles
+        void DrawRectangle(Vector3 bl, Vector3 tl, Vector3 tr, Vector3 br, Color color)
+        {
+            Gizmos.color = color;
+
+            Gizmos.DrawLine(bl, tl);
+            Gizmos.DrawLine(tl, tr);
+            Gizmos.DrawLine(tr, br);
+            Gizmos.DrawLine(br, bl);
+        }
+
+
+        // Draw Rectangles
+        void DrawDottedRectangle(Vector3 bl, Vector3 tl, Vector3 tr, Vector3 br, Color color)
+        {
+            var cam = Camera.current;
+            float dotSpacing = (cam.WorldToScreenPoint(br).x - cam.WorldToScreenPoint(bl).x) / 75f;
+            UnityEditor.Handles.color = color;
+
+            UnityEditor.Handles.DrawDottedLine(bl, tl, dotSpacing);
+            UnityEditor.Handles.DrawDottedLine(tl, tr, dotSpacing);
+            UnityEditor.Handles.DrawDottedLine(tr, br, dotSpacing);
+            UnityEditor.Handles.DrawDottedLine(br, bl, dotSpacing);
+        }
+        #endif
+    }
+}
+

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_TextInfoDebugTool.cs.meta

+fileFormatVersion: 2
+guid: 21256c5b62f346f18640dad779911e20
+timeCreated: 1430348781
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_TextSelector_A.cs

+using UnityEngine;
+using UnityEngine.EventSystems;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+
+    public class TMP_TextSelector_A : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
+    {
+        private TextMeshPro m_TextMeshPro;
+
+        private Camera m_Camera;
+
+        private bool m_isHoveringObject;
+        private int m_selectedLink = -1;
+        private int m_lastCharIndex = -1;
+        private int m_lastWordIndex = -1;
+
+        void Awake()
+        {
+            m_TextMeshPro = gameObject.GetComponent<TextMeshPro>();
+            m_Camera = Camera.main;
+
+            // Force generation of the text object so we have valid data to work with. This is needed since LateUpdate() will be called before the text object has a chance to generated when entering play mode.
+            m_TextMeshPro.ForceMeshUpdate();
+        }
+
+
+        void LateUpdate()
+        {
+            m_isHoveringObject = false;
+
+            if (TMP_TextUtilities.IsIntersectingRectTransform(m_TextMeshPro.rectTransform, Input.mousePosition, Camera.main))
+            {
+                m_isHoveringObject = true;
+            }
+
+            if (m_isHoveringObject)
+            {
+                #region Example of Character Selection
+                int charIndex = TMP_TextUtilities.FindIntersectingCharacter(m_TextMeshPro, Input.mousePosition, Camera.main, true);
+                if (charIndex != -1 && charIndex != m_lastCharIndex && (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift)))
+                {
+                    //Debug.Log("[" + m_TextMeshPro.textInfo.characterInfo[charIndex].character + "] has been selected.");
+
+                    m_lastCharIndex = charIndex;
+
+                    int meshIndex = m_TextMeshPro.textInfo.characterInfo[charIndex].materialReferenceIndex;
+
+                    int vertexIndex = m_TextMeshPro.textInfo.characterInfo[charIndex].vertexIndex;
+
+                    Color32 c = new Color32((byte)Random.Range(0, 255), (byte)Random.Range(0, 255), (byte)Random.Range(0, 255), 255);
+
+                    Color32[] vertexColors = m_TextMeshPro.textInfo.meshInfo[meshIndex].colors32;
+
+                    vertexColors[vertexIndex + 0] = c;
+                    vertexColors[vertexIndex + 1] = c;
+                    vertexColors[vertexIndex + 2] = c;
+                    vertexColors[vertexIndex + 3] = c;
+
+                    //m_TextMeshPro.mesh.colors32 = vertexColors;
+                    m_TextMeshPro.textInfo.meshInfo[meshIndex].mesh.colors32 = vertexColors;
+                }
+                #endregion
+
+                #region Example of Link Handling
+                // Check if mouse intersects with any links.
+                int linkIndex = TMP_TextUtilities.FindIntersectingLink(m_TextMeshPro, Input.mousePosition, m_Camera);
+
+                // Clear previous link selection if one existed.
+                if ((linkIndex == -1 && m_selectedLink != -1) || linkIndex != m_selectedLink)
+                {
+                    //m_TextPopup_RectTransform.gameObject.SetActive(false);
+                    m_selectedLink = -1;
+                }
+
+                // Handle new Link selection.
+                if (linkIndex != -1 && linkIndex != m_selectedLink)
+                {
+                    m_selectedLink = linkIndex;
+
+                    TMP_LinkInfo linkInfo = m_TextMeshPro.textInfo.linkInfo[linkIndex];
+
+                    // The following provides an example of how to access the link properties.
+                    //Debug.Log("Link ID: \"" + linkInfo.GetLinkID() + "\"   Link Text: \"" + linkInfo.GetLinkText() + "\""); // Example of how to retrieve the Link ID and Link Text.
+
+                    Vector3 worldPointInRectangle;
+
+                    RectTransformUtility.ScreenPointToWorldPointInRectangle(m_TextMeshPro.rectTransform, Input.mousePosition, m_Camera, out worldPointInRectangle);
+
+                    switch (linkInfo.GetLinkID())
+                    {
+                        case "id_01": // 100041637: // id_01
+                                      //m_TextPopup_RectTransform.position = worldPointInRectangle;
+                                      //m_TextPopup_RectTransform.gameObject.SetActive(true);
+                                      //m_TextPopup_TMPComponent.text = k_LinkText + " ID 01";
+                            break;
+                        case "id_02": // 100041638: // id_02
+                                      //m_TextPopup_RectTransform.position = worldPointInRectangle;
+                                      //m_TextPopup_RectTransform.gameObject.SetActive(true);
+                                      //m_TextPopup_TMPComponent.text = k_LinkText + " ID 02";
+                            break;
+                    }
+                }
+                #endregion
+
+
+                #region Example of Word Selection
+                // Check if Mouse intersects any words and if so assign a random color to that word.
+                int wordIndex = TMP_TextUtilities.FindIntersectingWord(m_TextMeshPro, Input.mousePosition, Camera.main);
+                if (wordIndex != -1 && wordIndex != m_lastWordIndex)
+                {
+                    m_lastWordIndex = wordIndex;
+
+                    TMP_WordInfo wInfo = m_TextMeshPro.textInfo.wordInfo[wordIndex];
+
+                    Vector3 wordPOS = m_TextMeshPro.transform.TransformPoint(m_TextMeshPro.textInfo.characterInfo[wInfo.firstCharacterIndex].bottomLeft);
+                    wordPOS = Camera.main.WorldToScreenPoint(wordPOS);
+
+                    //Debug.Log("Mouse Position: " + Input.mousePosition.ToString("f3") + "  Word Position: " + wordPOS.ToString("f3"));
+
+                    Color32[] vertexColors = m_TextMeshPro.textInfo.meshInfo[0].colors32;
+
+                    Color32 c = new Color32((byte)Random.Range(0, 255), (byte)Random.Range(0, 255), (byte)Random.Range(0, 255), 255);
+                    for (int i = 0; i < wInfo.characterCount; i++)
+                    {
+                        int vertexIndex = m_TextMeshPro.textInfo.characterInfo[wInfo.firstCharacterIndex + i].vertexIndex;
+
+                        vertexColors[vertexIndex + 0] = c;
+                        vertexColors[vertexIndex + 1] = c;
+                        vertexColors[vertexIndex + 2] = c;
+                        vertexColors[vertexIndex + 3] = c;
+                    }
+
+                    m_TextMeshPro.mesh.colors32 = vertexColors;
+                }
+                #endregion
+            }
+        }
+
+
+        public void OnPointerEnter(PointerEventData eventData)
+        {
+            Debug.Log("OnPointerEnter()");
+            m_isHoveringObject = true;
+        }
+
+
+        public void OnPointerExit(PointerEventData eventData)
+        {
+            Debug.Log("OnPointerExit()");
+            m_isHoveringObject = false;
+        }
+
+    }
+}

Assets/TextMesh Pro/Examples & Extras/Scripts/TMP_TextSelector_A.cs.meta

+fileFormatVersion: 2
+guid: 103e0a6a1d404693b9fb1a5173e0e979
+timeCreated: 1452811039
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: