first commit

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

@@ -0,0 +1,128 @@
+using UnityEngine;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+    
+    public class Benchmark01 : MonoBehaviour
+    {
+
+        public int BenchmarkType = 0;
+
+        public TMP_FontAsset TMProFont;
+        public Font TextMeshFont;
+
+        private TextMeshPro m_textMeshPro;
+        private TextContainer m_textContainer;
+        private TextMesh m_textMesh;
+
+        private const string label01 = "The <#0050FF>count is: </color>{0}";
+        private const string label02 = "The <color=#0050FF>count is: </color>";
+
+        //private string m_string;
+        //private int m_frame;
+
+        private Material m_material01;
+        private Material m_material02;
+
+
+
+        IEnumerator Start()
+        {
+
+
+
+            if (BenchmarkType == 0) // TextMesh Pro Component
+            {
+                m_textMeshPro = gameObject.AddComponent<TextMeshPro>();
+                m_textMeshPro.autoSizeTextContainer = true;
+
+                //m_textMeshPro.anchorDampening = true;
+
+                if (TMProFont != null)
+                    m_textMeshPro.font = TMProFont;
+
+                //m_textMeshPro.font = Resources.Load("Fonts & Materials/Anton SDF", typeof(TextMeshProFont)) as TextMeshProFont; // Make sure the Anton SDF exists before calling this...
+                //m_textMeshPro.fontSharedMaterial = Resources.Load("Fonts & Materials/Anton SDF", typeof(Material)) as Material; // Same as above make sure this material exists.
+
+                m_textMeshPro.fontSize = 48;
+                m_textMeshPro.alignment = TextAlignmentOptions.Center;
+                //m_textMeshPro.anchor = AnchorPositions.Center;
+                m_textMeshPro.extraPadding = true;
+                //m_textMeshPro.outlineWidth = 0.25f;
+                //m_textMeshPro.fontSharedMaterial.SetFloat("_OutlineWidth", 0.2f);
+                //m_textMeshPro.fontSharedMaterial.EnableKeyword("UNDERLAY_ON");
+                //m_textMeshPro.lineJustification = LineJustificationTypes.Center;
+                m_textMeshPro.enableWordWrapping = false;    
+                //m_textMeshPro.lineLength = 60;          
+                //m_textMeshPro.characterSpacing = 0.2f;
+                //m_textMeshPro.fontColor = new Color32(255, 255, 255, 255);
+
+                m_material01 = m_textMeshPro.font.material;
+                m_material02 = Resources.Load<Material>("Fonts & Materials/LiberationSans SDF - Drop Shadow"); // Make sure the LiberationSans SDF exists before calling this...  
+
+
+            }
+            else if (BenchmarkType == 1) // TextMesh
+            {
+                m_textMesh = gameObject.AddComponent<TextMesh>();
+
+                if (TextMeshFont != null)
+                {
+                    m_textMesh.font = TextMeshFont;
+                    m_textMesh.GetComponent<Renderer>().sharedMaterial = m_textMesh.font.material;
+                }
+                else
+                {
+                    m_textMesh.font = Resources.Load("Fonts/ARIAL", typeof(Font)) as Font;
+                    m_textMesh.GetComponent<Renderer>().sharedMaterial = m_textMesh.font.material;
+                }
+
+                m_textMesh.fontSize = 48;
+                m_textMesh.anchor = TextAnchor.MiddleCenter;
+
+                //m_textMesh.color = new Color32(255, 255, 0, 255);
+            }
+
+
+
+            for (int i = 0; i <= 1000000; i++)
+            {
+                if (BenchmarkType == 0)
+                {
+                    m_textMeshPro.SetText(label01, i % 1000);
+                    if (i % 1000 == 999)
+                        m_textMeshPro.fontSharedMaterial = m_textMeshPro.fontSharedMaterial == m_material01 ? m_textMeshPro.fontSharedMaterial = m_material02 : m_textMeshPro.fontSharedMaterial = m_material01;
+
+
+
+                }
+                else if (BenchmarkType == 1)
+                    m_textMesh.text = label02 + (i % 1000).ToString();
+
+                yield return null;
+            }
+
+
+            yield return null;
+        }
+
+
+        /*
+        void Update()
+        {
+            if (BenchmarkType == 0)
+            {
+                m_textMeshPro.text = (m_frame % 1000).ToString();
+            }
+            else if (BenchmarkType == 1)
+            {
+                m_textMesh.text = (m_frame % 1000).ToString();
+            }
+
+            m_frame += 1;
+        }
+        */
+    }
+}

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

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: f970ea55f9f84bf79b05dab180b8c125
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,135 @@
+using UnityEngine;
+using System.Collections;
+using UnityEngine.UI;
+
+
+namespace TMPro.Examples
+{
+    
+    public class Benchmark01_UGUI : MonoBehaviour
+    {
+
+        public int BenchmarkType = 0;
+
+        public Canvas canvas;
+        public TMP_FontAsset TMProFont;
+        public Font TextMeshFont;
+
+        private TextMeshProUGUI m_textMeshPro;
+        //private TextContainer m_textContainer;
+        private Text m_textMesh;
+
+        private const string label01 = "The <#0050FF>count is: </color>";
+        private const string label02 = "The <color=#0050FF>count is: </color>";
+
+        //private const string label01 = "TextMesh <#0050FF>Pro!</color>  The count is: {0}";
+        //private const string label02 = "Text Mesh<color=#0050FF>        The count is: </color>";
+
+        //private string m_string;
+        //private int m_frame;
+
+        private Material m_material01;
+        private Material m_material02;
+
+
+
+        IEnumerator Start()
+        {
+
+
+
+            if (BenchmarkType == 0) // TextMesh Pro Component
+            {
+                m_textMeshPro = gameObject.AddComponent<TextMeshProUGUI>();
+                //m_textContainer = GetComponent<TextContainer>();
+
+
+                //m_textMeshPro.anchorDampening = true;
+
+                if (TMProFont != null)
+                    m_textMeshPro.font = TMProFont;
+
+                //m_textMeshPro.font = Resources.Load("Fonts & Materials/Anton SDF", typeof(TextMeshProFont)) as TextMeshProFont; // Make sure the Anton SDF exists before calling this...           
+                //m_textMeshPro.fontSharedMaterial = Resources.Load("Fonts & Materials/Anton SDF", typeof(Material)) as Material; // Same as above make sure this material exists.
+
+                m_textMeshPro.fontSize = 48;
+                m_textMeshPro.alignment = TextAlignmentOptions.Center;
+                //m_textMeshPro.anchor = AnchorPositions.Center;
+                m_textMeshPro.extraPadding = true;
+                //m_textMeshPro.outlineWidth = 0.25f;
+                //m_textMeshPro.fontSharedMaterial.SetFloat("_OutlineWidth", 0.2f);
+                //m_textMeshPro.fontSharedMaterial.EnableKeyword("UNDERLAY_ON");
+                //m_textMeshPro.lineJustification = LineJustificationTypes.Center;
+                //m_textMeshPro.enableWordWrapping = true;    
+                //m_textMeshPro.lineLength = 60;          
+                //m_textMeshPro.characterSpacing = 0.2f;
+                //m_textMeshPro.fontColor = new Color32(255, 255, 255, 255);
+
+                m_material01 = m_textMeshPro.font.material;
+                m_material02 = Resources.Load<Material>("Fonts & Materials/LiberationSans SDF - BEVEL"); // Make sure the LiberationSans SDF exists before calling this...  
+
+
+            }
+            else if (BenchmarkType == 1) // TextMesh
+            {
+                m_textMesh = gameObject.AddComponent<Text>();
+
+                if (TextMeshFont != null)
+                {
+                    m_textMesh.font = TextMeshFont;
+                    //m_textMesh.renderer.sharedMaterial = m_textMesh.font.material;
+                }
+                else
+                {
+                    //m_textMesh.font = Resources.Load("Fonts/ARIAL", typeof(Font)) as Font;
+                    //m_textMesh.renderer.sharedMaterial = m_textMesh.font.material;
+                }
+
+                m_textMesh.fontSize = 48;
+                m_textMesh.alignment = TextAnchor.MiddleCenter;
+
+                //m_textMesh.color = new Color32(255, 255, 0, 255);    
+            }
+
+
+
+            for (int i = 0; i <= 1000000; i++)
+            {
+                if (BenchmarkType == 0)
+                {
+                    m_textMeshPro.text = label01 + (i % 1000);
+                    if (i % 1000 == 999)
+                        m_textMeshPro.fontSharedMaterial = m_textMeshPro.fontSharedMaterial == m_material01 ? m_textMeshPro.fontSharedMaterial = m_material02 : m_textMeshPro.fontSharedMaterial = m_material01;
+
+
+
+                }
+                else if (BenchmarkType == 1)
+                    m_textMesh.text = label02 + (i % 1000).ToString();
+
+                yield return null;
+            }
+
+
+            yield return null;
+        }
+
+
+        /*
+        void Update()
+        {
+            if (BenchmarkType == 0)
+            {
+                m_textMeshPro.text = (m_frame % 1000).ToString();            
+            }
+            else if (BenchmarkType == 1)
+            {
+                m_textMesh.text = (m_frame % 1000).ToString();
+            }
+
+            m_frame += 1;
+        }
+        */
+    }
+
+}

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

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 8ef7be1c625941f7ba8ed7cc71718c0d
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,97 @@
+using UnityEngine;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+
+    public class Benchmark02 : MonoBehaviour
+    {
+
+        public int SpawnType = 0;
+        public int NumberOfNPC = 12;
+
+        public bool IsTextObjectScaleStatic;
+        private TextMeshProFloatingText floatingText_Script;
+
+
+        void Start()
+        {
+
+            for (int i = 0; i < NumberOfNPC; i++)
+            {
+
+
+                if (SpawnType == 0)
+                {
+                    // TextMesh Pro Implementation
+                    GameObject go = new GameObject();
+                    go.transform.position = new Vector3(Random.Range(-95f, 95f), 0.25f, Random.Range(-95f, 95f));
+
+                    TextMeshPro textMeshPro = go.AddComponent<TextMeshPro>();
+
+                    textMeshPro.autoSizeTextContainer = true;
+                    textMeshPro.rectTransform.pivot = new Vector2(0.5f, 0);
+
+                    textMeshPro.alignment = TextAlignmentOptions.Bottom;
+                    textMeshPro.fontSize = 96;
+                    textMeshPro.enableKerning = false;
+
+                    textMeshPro.color = new Color32(255, 255, 0, 255);
+                    textMeshPro.text = "!";
+                    textMeshPro.isTextObjectScaleStatic = IsTextObjectScaleStatic;
+
+                    // Spawn Floating Text
+                    floatingText_Script = go.AddComponent<TextMeshProFloatingText>();
+                    floatingText_Script.SpawnType = 0;
+                    floatingText_Script.IsTextObjectScaleStatic = IsTextObjectScaleStatic;
+                }
+                else if (SpawnType == 1)
+                {
+                    // TextMesh Implementation
+                    GameObject go = new GameObject();
+                    go.transform.position = new Vector3(Random.Range(-95f, 95f), 0.25f, Random.Range(-95f, 95f));
+
+                    TextMesh textMesh = go.AddComponent<TextMesh>();
+                    textMesh.font = Resources.Load<Font>("Fonts/ARIAL");
+                    textMesh.GetComponent<Renderer>().sharedMaterial = textMesh.font.material;
+
+                    textMesh.anchor = TextAnchor.LowerCenter;
+                    textMesh.fontSize = 96;
+
+                    textMesh.color = new Color32(255, 255, 0, 255);
+                    textMesh.text = "!";
+
+                    // Spawn Floating Text
+                    floatingText_Script = go.AddComponent<TextMeshProFloatingText>();
+                    floatingText_Script.SpawnType = 1;
+                }
+                else if (SpawnType == 2)
+                {
+                    // Canvas WorldSpace Camera
+                    GameObject go = new GameObject();
+                    Canvas canvas = go.AddComponent<Canvas>();
+                    canvas.worldCamera = Camera.main;
+
+                    go.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);
+                    go.transform.position = new Vector3(Random.Range(-95f, 95f), 5f, Random.Range(-95f, 95f));
+
+                    TextMeshProUGUI textObject = new GameObject().AddComponent<TextMeshProUGUI>();
+                    textObject.rectTransform.SetParent(go.transform, false);
+
+                    textObject.color = new Color32(255, 255, 0, 255);
+                    textObject.alignment = TextAlignmentOptions.Bottom;
+                    textObject.fontSize = 96;
+                    textObject.text = "!";
+
+                    // Spawn Floating Text
+                    floatingText_Script = go.AddComponent<TextMeshProFloatingText>();
+                    floatingText_Script.SpawnType = 0;
+                }
+
+
+
+            }
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e8538afcddc14efbb5d9e94b7ae50197
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences:
+  - TheFont: {instanceID: 0}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,92 @@
+using UnityEngine;
+using System.Collections;
+using UnityEngine.TextCore.LowLevel;
+
+
+namespace TMPro.Examples
+{
+
+    public class Benchmark03 : MonoBehaviour
+    {
+        public enum BenchmarkType { TMP_SDF_MOBILE = 0, TMP_SDF__MOBILE_SSD = 1, TMP_SDF = 2, TMP_BITMAP_MOBILE = 3, TEXTMESH_BITMAP = 4 }
+
+        public int NumberOfSamples = 100;
+        public BenchmarkType Benchmark;
+
+        public Font SourceFont;
+
+
+        void Awake()
+        {
+
+        }
+
+
+        void Start()
+        {
+            TMP_FontAsset fontAsset = null;
+
+            // Create Dynamic Font Asset for the given font file.
+            switch (Benchmark)
+            {
+                case BenchmarkType.TMP_SDF_MOBILE:
+                    fontAsset = TMP_FontAsset.CreateFontAsset(SourceFont, 90, 9, GlyphRenderMode.SDFAA, 256, 256, AtlasPopulationMode.Dynamic);
+                    break;
+                case BenchmarkType.TMP_SDF__MOBILE_SSD:
+                    fontAsset = TMP_FontAsset.CreateFontAsset(SourceFont, 90, 9, GlyphRenderMode.SDFAA, 256, 256, AtlasPopulationMode.Dynamic);
+                    fontAsset.material.shader = Shader.Find("TextMeshPro/Mobile/Distance Field SSD");
+                    break;
+                case BenchmarkType.TMP_SDF:
+                    fontAsset = TMP_FontAsset.CreateFontAsset(SourceFont, 90, 9, GlyphRenderMode.SDFAA, 256, 256, AtlasPopulationMode.Dynamic);
+                    fontAsset.material.shader = Shader.Find("TextMeshPro/Distance Field");
+                    break;
+                case BenchmarkType.TMP_BITMAP_MOBILE:
+                    fontAsset = TMP_FontAsset.CreateFontAsset(SourceFont, 90, 9, GlyphRenderMode.SMOOTH, 256, 256, AtlasPopulationMode.Dynamic);
+                    break;
+            }
+
+            for (int i = 0; i < NumberOfSamples; i++)
+            {
+                switch (Benchmark)
+                {
+                    case BenchmarkType.TMP_SDF_MOBILE:
+                    case BenchmarkType.TMP_SDF__MOBILE_SSD:
+                    case BenchmarkType.TMP_SDF:
+                    case BenchmarkType.TMP_BITMAP_MOBILE:
+                        {
+                            GameObject go = new GameObject();
+                            go.transform.position = new Vector3(0, 1.2f, 0);
+
+                            TextMeshPro textComponent = go.AddComponent<TextMeshPro>();
+                            textComponent.font = fontAsset;
+                            textComponent.fontSize = 128;
+                            textComponent.text = "@";
+                            textComponent.alignment = TextAlignmentOptions.Center;
+                            textComponent.color = new Color32(255, 255, 0, 255);
+
+                            if (Benchmark == BenchmarkType.TMP_BITMAP_MOBILE)
+                                textComponent.fontSize = 132;
+
+                        }
+                        break;
+                    case BenchmarkType.TEXTMESH_BITMAP:
+                        {
+                            GameObject go = new GameObject();
+                            go.transform.position = new Vector3(0, 1.2f, 0);
+
+                            TextMesh textMesh = go.AddComponent<TextMesh>();
+                            textMesh.GetComponent<Renderer>().sharedMaterial = SourceFont.material;
+                            textMesh.font = SourceFont;
+                            textMesh.anchor = TextAnchor.MiddleCenter;
+                            textMesh.fontSize = 130;
+
+                            textMesh.color = new Color32(255, 255, 0, 255);
+                            textMesh.text = "@";
+                        }
+                        break;
+                }
+            }
+        }
+
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a73109742c8d47ac822895a473300c29
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences:
+  - TheFont: {instanceID: 0}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,85 @@
+using UnityEngine;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+    
+    public class Benchmark04 : MonoBehaviour
+    {
+
+        public int SpawnType = 0;
+
+        public int MinPointSize = 12;
+        public int MaxPointSize = 64;
+        public int Steps = 4;
+
+        private Transform m_Transform;
+        //private TextMeshProFloatingText floatingText_Script;
+        //public Material material;
+
+
+        void Start()
+        {
+            m_Transform = transform;
+
+            float lineHeight = 0;
+            float orthoSize = Camera.main.orthographicSize = Screen.height / 2;
+            float ratio = (float)Screen.width / Screen.height;
+
+            for (int i = MinPointSize; i <= MaxPointSize; i += Steps)
+            {
+                if (SpawnType == 0)
+                {
+                    // TextMesh Pro Implementation
+                    GameObject go = new GameObject("Text - " + i + " Pts");
+
+                    if (lineHeight > orthoSize * 2) return;
+
+                    go.transform.position = m_Transform.position + new Vector3(ratio * -orthoSize * 0.975f, orthoSize * 0.975f - lineHeight, 0);
+
+                    TextMeshPro textMeshPro = go.AddComponent<TextMeshPro>();
+
+                    //textMeshPro.fontSharedMaterial = material;
+                    //textMeshPro.font = Resources.Load("Fonts & Materials/LiberationSans SDF", typeof(TextMeshProFont)) as TextMeshProFont;
+                    //textMeshPro.anchor = AnchorPositions.Left;
+                    textMeshPro.rectTransform.pivot = new Vector2(0, 0.5f);
+
+                    textMeshPro.enableWordWrapping = false;
+                    textMeshPro.extraPadding = true;
+                    textMeshPro.isOrthographic = true;
+                    textMeshPro.fontSize = i;
+
+                    textMeshPro.text = i + " pts - Lorem ipsum dolor sit...";
+                    textMeshPro.color = new Color32(255, 255, 255, 255);
+
+                    lineHeight += i;
+                }
+                else
+                {
+                    // TextMesh Implementation
+                    // Causes crashes since atlas needed exceeds 4096 X 4096
+                    /*
+                    GameObject go = new GameObject("Arial " + i);
+
+                    //if (lineHeight > orthoSize * 2 * 0.9f) return;
+
+                    go.transform.position = m_Transform.position + new Vector3(ratio * -orthoSize * 0.975f, orthoSize * 0.975f - lineHeight, 1);
+                                       
+                    TextMesh textMesh = go.AddComponent<TextMesh>();
+                    textMesh.font = Resources.Load("Fonts/ARIAL", typeof(Font)) as Font;
+                    textMesh.renderer.sharedMaterial = textMesh.font.material;
+                    textMesh.anchor = TextAnchor.MiddleLeft;
+                    textMesh.fontSize = i * 10;
+
+                    textMesh.color = new Color32(255, 255, 255, 255);
+                    textMesh.text = i + " pts - Lorem ipsum dolor sit...";
+
+                    lineHeight += i;
+                    */
+                }
+            }
+        }
+
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dc20866c0d5e413ab7559440e15333ae
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences:
+  - TheFont: {instanceID: 0}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,292 @@
+using UnityEngine;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+    
+    public class CameraController : MonoBehaviour
+    {
+        public enum CameraModes { Follow, Isometric, Free }
+
+        private Transform cameraTransform;
+        private Transform dummyTarget;
+
+        public Transform CameraTarget;
+
+        public float FollowDistance = 30.0f;
+        public float MaxFollowDistance = 100.0f;
+        public float MinFollowDistance = 2.0f;
+
+        public float ElevationAngle = 30.0f;
+        public float MaxElevationAngle = 85.0f;
+        public float MinElevationAngle = 0f;
+
+        public float OrbitalAngle = 0f;
+
+        public CameraModes CameraMode = CameraModes.Follow;
+
+        public bool MovementSmoothing = true;
+        public bool RotationSmoothing = false;
+        private bool previousSmoothing;
+
+        public float MovementSmoothingValue = 25f;
+        public float RotationSmoothingValue = 5.0f;
+
+        public float MoveSensitivity = 2.0f;
+
+        private Vector3 currentVelocity = Vector3.zero;
+        private Vector3 desiredPosition;
+        private float mouseX;
+        private float mouseY;
+        private Vector3 moveVector;
+        private float mouseWheel;
+
+        // Controls for Touches on Mobile devices
+        //private float prev_ZoomDelta;
+
+
+        private const string event_SmoothingValue = "Slider - Smoothing Value";
+        private const string event_FollowDistance = "Slider - Camera Zoom";
+
+
+        void Awake()
+        {
+            if (QualitySettings.vSyncCount > 0)
+                Application.targetFrameRate = 60;
+            else
+                Application.targetFrameRate = -1;
+
+            if (Application.platform == RuntimePlatform.IPhonePlayer || Application.platform == RuntimePlatform.Android)
+                Input.simulateMouseWithTouches = false;
+
+            cameraTransform = transform;
+            previousSmoothing = MovementSmoothing;
+        }
+
+
+        // Use this for initialization
+        void Start()
+        {
+            if (CameraTarget == null)
+            {
+                // If we don't have a target (assigned by the player, create a dummy in the center of the scene).
+                dummyTarget = new GameObject("Camera Target").transform;
+                CameraTarget = dummyTarget;
+            }
+        }
+
+        // Update is called once per frame
+        void LateUpdate()
+        {
+            GetPlayerInput();
+
+
+            // Check if we still have a valid target
+            if (CameraTarget != null)
+            {
+                if (CameraMode == CameraModes.Isometric)
+                {
+                    desiredPosition = CameraTarget.position + Quaternion.Euler(ElevationAngle, OrbitalAngle, 0f) * new Vector3(0, 0, -FollowDistance);
+                }
+                else if (CameraMode == CameraModes.Follow)
+                {
+                    desiredPosition = CameraTarget.position + CameraTarget.TransformDirection(Quaternion.Euler(ElevationAngle, OrbitalAngle, 0f) * (new Vector3(0, 0, -FollowDistance)));
+                }
+                else
+                {
+                    // Free Camera implementation
+                }
+
+                if (MovementSmoothing == true)
+                {
+                    // Using Smoothing
+                    cameraTransform.position = Vector3.SmoothDamp(cameraTransform.position, desiredPosition, ref currentVelocity, MovementSmoothingValue * Time.fixedDeltaTime);
+                    //cameraTransform.position = Vector3.Lerp(cameraTransform.position, desiredPosition, Time.deltaTime * 5.0f);
+                }
+                else
+                {
+                    // Not using Smoothing
+                    cameraTransform.position = desiredPosition;
+                }
+
+                if (RotationSmoothing == true)
+                    cameraTransform.rotation = Quaternion.Lerp(cameraTransform.rotation, Quaternion.LookRotation(CameraTarget.position - cameraTransform.position), RotationSmoothingValue * Time.deltaTime);
+                else
+                {
+                    cameraTransform.LookAt(CameraTarget);
+                }
+
+            }
+
+        }
+
+
+
+        void GetPlayerInput()
+        {
+            moveVector = Vector3.zero;
+
+            // Check Mouse Wheel Input prior to Shift Key so we can apply multiplier on Shift for Scrolling
+            mouseWheel = Input.GetAxis("Mouse ScrollWheel");
+
+            float touchCount = Input.touchCount;
+
+            if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift) || touchCount > 0)
+            {
+                mouseWheel *= 10;
+
+                if (Input.GetKeyDown(KeyCode.I))
+                    CameraMode = CameraModes.Isometric;
+
+                if (Input.GetKeyDown(KeyCode.F))
+                    CameraMode = CameraModes.Follow;
+
+                if (Input.GetKeyDown(KeyCode.S))
+                    MovementSmoothing = !MovementSmoothing;
+
+
+                // Check for right mouse button to change camera follow and elevation angle
+                if (Input.GetMouseButton(1))
+                {
+                    mouseY = Input.GetAxis("Mouse Y");
+                    mouseX = Input.GetAxis("Mouse X");
+
+                    if (mouseY > 0.01f || mouseY < -0.01f)
+                    {
+                        ElevationAngle -= mouseY * MoveSensitivity;
+                        // Limit Elevation angle between min & max values.
+                        ElevationAngle = Mathf.Clamp(ElevationAngle, MinElevationAngle, MaxElevationAngle);
+                    }
+
+                    if (mouseX > 0.01f || mouseX < -0.01f)
+                    {
+                        OrbitalAngle += mouseX * MoveSensitivity;
+                        if (OrbitalAngle > 360)
+                            OrbitalAngle -= 360;
+                        if (OrbitalAngle < 0)
+                            OrbitalAngle += 360;
+                    }
+                }
+
+                // Get Input from Mobile Device
+                if (touchCount == 1 && Input.GetTouch(0).phase == TouchPhase.Moved)
+                {
+                    Vector2 deltaPosition = Input.GetTouch(0).deltaPosition;
+
+                    // Handle elevation changes
+                    if (deltaPosition.y > 0.01f || deltaPosition.y < -0.01f)
+                    {
+                        ElevationAngle -= deltaPosition.y * 0.1f;
+                        // Limit Elevation angle between min & max values.
+                        ElevationAngle = Mathf.Clamp(ElevationAngle, MinElevationAngle, MaxElevationAngle);
+                    }
+
+
+                    // Handle left & right 
+                    if (deltaPosition.x > 0.01f || deltaPosition.x < -0.01f)
+                    {
+                        OrbitalAngle += deltaPosition.x * 0.1f;
+                        if (OrbitalAngle > 360)
+                            OrbitalAngle -= 360;
+                        if (OrbitalAngle < 0)
+                            OrbitalAngle += 360;
+                    }
+
+                }
+
+                // Check for left mouse button to select a new CameraTarget or to reset Follow position
+                if (Input.GetMouseButton(0))
+                {
+                    Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
+                    RaycastHit hit;
+
+                    if (Physics.Raycast(ray, out hit, 300, 1 << 10 | 1 << 11 | 1 << 12 | 1 << 14))
+                    {
+                        if (hit.transform == CameraTarget)
+                        {
+                            // Reset Follow Position
+                            OrbitalAngle = 0;
+                        }
+                        else
+                        {
+                            CameraTarget = hit.transform;
+                            OrbitalAngle = 0;
+                            MovementSmoothing = previousSmoothing;
+                        }
+
+                    }
+                }
+
+
+                if (Input.GetMouseButton(2))
+                {
+                    if (dummyTarget == null)
+                    {
+                        // We need a Dummy Target to anchor the Camera
+                        dummyTarget = new GameObject("Camera Target").transform;
+                        dummyTarget.position = CameraTarget.position;
+                        dummyTarget.rotation = CameraTarget.rotation;
+                        CameraTarget = dummyTarget;
+                        previousSmoothing = MovementSmoothing;
+                        MovementSmoothing = false;
+                    }
+                    else if (dummyTarget != CameraTarget)
+                    {
+                        // Move DummyTarget to CameraTarget
+                        dummyTarget.position = CameraTarget.position;
+                        dummyTarget.rotation = CameraTarget.rotation;
+                        CameraTarget = dummyTarget;
+                        previousSmoothing = MovementSmoothing;
+                        MovementSmoothing = false;
+                    }
+
+
+                    mouseY = Input.GetAxis("Mouse Y");
+                    mouseX = Input.GetAxis("Mouse X");
+
+                    moveVector = cameraTransform.TransformDirection(mouseX, mouseY, 0);
+
+                    dummyTarget.Translate(-moveVector, Space.World);
+
+                }
+
+            }
+
+            // Check Pinching to Zoom in - out on Mobile device
+            if (touchCount == 2)
+            {
+                Touch touch0 = Input.GetTouch(0);
+                Touch touch1 = Input.GetTouch(1);
+
+                Vector2 touch0PrevPos = touch0.position - touch0.deltaPosition;
+                Vector2 touch1PrevPos = touch1.position - touch1.deltaPosition;
+
+                float prevTouchDelta = (touch0PrevPos - touch1PrevPos).magnitude;
+                float touchDelta = (touch0.position - touch1.position).magnitude;
+
+                float zoomDelta = prevTouchDelta - touchDelta;
+
+                if (zoomDelta > 0.01f || zoomDelta < -0.01f)
+                {
+                    FollowDistance += zoomDelta * 0.25f;
+                    // Limit FollowDistance between min & max values.
+                    FollowDistance = Mathf.Clamp(FollowDistance, MinFollowDistance, MaxFollowDistance);
+                }
+
+
+            }
+
+            // Check MouseWheel to Zoom in-out
+            if (mouseWheel < -0.01f || mouseWheel > 0.01f)
+            {
+
+                FollowDistance -= mouseWheel * 5.0f;
+                // Limit FollowDistance between min & max values.
+                FollowDistance = Mathf.Clamp(FollowDistance, MinFollowDistance, MaxFollowDistance);
+            }
+
+
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 2d687537154440a3913a9a3c7977978c
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,51 @@
+using UnityEngine;
+using UnityEngine.UI;
+using TMPro;
+
+public class ChatController : MonoBehaviour {
+
+
+    public TMP_InputField ChatInputField;
+
+    public TMP_Text ChatDisplayOutput;
+
+    public Scrollbar ChatScrollbar;
+
+    void OnEnable()
+    {
+        ChatInputField.onSubmit.AddListener(AddToChatOutput);
+    }
+
+    void OnDisable()
+    {
+        ChatInputField.onSubmit.RemoveListener(AddToChatOutput);
+    }
+
+
+    void AddToChatOutput(string newText)
+    {
+        // Clear Input Field
+        ChatInputField.text = string.Empty;
+
+        var timeNow = System.DateTime.Now;
+
+        string formattedInput = "[<#FFFF80>" + timeNow.Hour.ToString("d2") + ":" + timeNow.Minute.ToString("d2") + ":" + timeNow.Second.ToString("d2") + "</color>] " + newText;
+
+        if (ChatDisplayOutput != null)
+        {
+            // No special formatting for first entry
+            // Add line feed before each subsequent entries
+            if (ChatDisplayOutput.text == string.Empty)
+                ChatDisplayOutput.text = formattedInput;
+            else
+                ChatDisplayOutput.text += "\n" + formattedInput;
+        }
+
+        // Keep Chat input field active
+        ChatInputField.ActivateInputField();
+
+        // Set the scrollbar to the bottom when next text is submitted.
+        ChatScrollbar.value = 0;
+    }
+
+}

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

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 53d91f98a2664f5cb9af11de72ac54ec
+timeCreated: 1487197841
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,19 @@
+using TMPro;
+using UnityEngine;
+
+public class DropdownSample: MonoBehaviour
+{
+	[SerializeField]
+	private TextMeshProUGUI text = null;
+
+	[SerializeField]
+	private TMP_Dropdown dropdownWithoutPlaceholder = null;
+
+	[SerializeField]
+	private TMP_Dropdown dropdownWithPlaceholder = null;
+
+	public void OnButtonClick()
+	{
+		text.text = dropdownWithPlaceholder.value > -1 ? "Selected values:\n" + dropdownWithoutPlaceholder.value + " - " + dropdownWithPlaceholder.value : "Error: Please make a selection";
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ac1eb05af6d391b4eb0f4c070a99f1d0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,35 @@
+using UnityEngine;
+using System.Collections;
+using TMPro;
+
+public class EnvMapAnimator : MonoBehaviour {
+
+    //private Vector3 TranslationSpeeds;
+    public Vector3 RotationSpeeds;
+    private TMP_Text m_textMeshPro;
+    private Material m_material;
+    
+
+    void Awake()
+    {
+        //Debug.Log("Awake() on Script called.");
+        m_textMeshPro = GetComponent<TMP_Text>();
+        m_material = m_textMeshPro.fontSharedMaterial;
+    }
+
+    // Use this for initialization
+	IEnumerator Start ()
+    {
+        Matrix4x4 matrix = new Matrix4x4(); 
+        
+        while (true)
+        {
+            //matrix.SetTRS(new Vector3 (Time.time * TranslationSpeeds.x, Time.time * TranslationSpeeds.y, Time.time * TranslationSpeeds.z), Quaternion.Euler(Time.time * RotationSpeeds.x, Time.time * RotationSpeeds.y , Time.time * RotationSpeeds.z), Vector3.one);
+             matrix.SetTRS(Vector3.zero, Quaternion.Euler(Time.time * RotationSpeeds.x, Time.time * RotationSpeeds.y , Time.time * RotationSpeeds.z), Vector3.one);
+
+            m_material.SetMatrix("_EnvMatrix", matrix);
+
+            yield return null;
+        }
+	}
+}

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

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a4b6f99e8bc54541bbd149b014ff441c
+timeCreated: 1449025325
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,69 @@
+using UnityEngine;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+    
+    public class ObjectSpin : MonoBehaviour
+    {
+
+#pragma warning disable 0414
+
+        public float SpinSpeed = 5;
+        public int RotationRange = 15;
+        private Transform m_transform;
+
+        private float m_time;
+        private Vector3 m_prevPOS;
+        private Vector3 m_initial_Rotation;
+        private Vector3 m_initial_Position;
+        private Color32 m_lightColor;
+        private int frames = 0;
+
+        public enum MotionType { Rotation, BackAndForth, Translation };
+        public MotionType Motion;
+
+        void Awake()
+        {
+            m_transform = transform;
+            m_initial_Rotation = m_transform.rotation.eulerAngles;
+            m_initial_Position = m_transform.position;
+
+            Light light = GetComponent<Light>();
+            m_lightColor = light != null ? light.color : Color.black;
+        }
+
+
+        // Update is called once per frame
+        void Update()
+        {
+            if (Motion == MotionType.Rotation)
+            {
+                m_transform.Rotate(0, SpinSpeed * Time.deltaTime, 0);
+            }
+            else if (Motion == MotionType.BackAndForth)
+            {
+                m_time += SpinSpeed * Time.deltaTime;
+                m_transform.rotation = Quaternion.Euler(m_initial_Rotation.x, Mathf.Sin(m_time) * RotationRange + m_initial_Rotation.y, m_initial_Rotation.z);
+            }
+            else
+            {
+                m_time += SpinSpeed * Time.deltaTime;
+
+                float x = 15 * Mathf.Cos(m_time * .95f);
+                float y = 10; // *Mathf.Sin(m_time * 1f) * Mathf.Cos(m_time * 1f);
+                float z = 0f; // *Mathf.Sin(m_time * .9f);    
+
+                m_transform.position = m_initial_Position + new Vector3(x, z, y);
+
+                // Drawing light patterns because they can be cool looking.
+                //if (frames > 2)
+                //    Debug.DrawLine(m_transform.position, m_prevPOS, m_lightColor, 100f);
+
+                m_prevPOS = m_transform.position;
+                frames += 1;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 4f19c7f94c794c5097d8bd11e39c750d
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,51 @@
+using UnityEngine;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+    
+    public class ShaderPropAnimator : MonoBehaviour
+    {
+
+        private Renderer m_Renderer;
+        private Material m_Material;
+
+        public AnimationCurve GlowCurve;
+
+        public float m_frame;
+
+        void Awake()
+        {
+            // Cache a reference to object's renderer
+            m_Renderer = GetComponent<Renderer>();
+
+            // Cache a reference to object's material and create an instance by doing so.
+            m_Material = m_Renderer.material;
+        }
+
+        void Start()
+        {
+            StartCoroutine(AnimateProperties());
+        }
+
+        IEnumerator AnimateProperties()
+        {
+            //float lightAngle;
+            float glowPower;
+            m_frame = Random.Range(0f, 1f);
+
+            while (true)
+            {
+                //lightAngle = (m_Material.GetFloat(ShaderPropertyIDs.ID_LightAngle) + Time.deltaTime) % 6.2831853f;
+                //m_Material.SetFloat(ShaderPropertyIDs.ID_LightAngle, lightAngle);
+
+                glowPower = GlowCurve.Evaluate(m_frame);
+                m_Material.SetFloat(ShaderUtilities.ID_GlowPower, glowPower);
+
+                m_frame += Time.deltaTime * Random.Range(0.2f, 0.3f);
+                yield return new WaitForEndOfFrame();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 2787a46a4dc848c1b4b7b9307b614bfd
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,58 @@
+using UnityEngine;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+    
+    public class SimpleScript : MonoBehaviour
+    {
+
+        private TextMeshPro m_textMeshPro;
+        //private TMP_FontAsset m_FontAsset;
+
+        private const string label = "The <#0050FF>count is: </color>{0:2}";
+        private float m_frame;
+
+
+        void Start()
+        {
+            // Add new TextMesh Pro Component
+            m_textMeshPro = gameObject.AddComponent<TextMeshPro>();
+
+            m_textMeshPro.autoSizeTextContainer = true;
+
+            // Load the Font Asset to be used.
+            //m_FontAsset = Resources.Load("Fonts & Materials/LiberationSans SDF", typeof(TMP_FontAsset)) as TMP_FontAsset;
+            //m_textMeshPro.font = m_FontAsset;
+
+            // Assign Material to TextMesh Pro Component
+            //m_textMeshPro.fontSharedMaterial = Resources.Load("Fonts & Materials/LiberationSans SDF - Bevel", typeof(Material)) as Material;
+            //m_textMeshPro.fontSharedMaterial.EnableKeyword("BEVEL_ON");
+            
+            // Set various font settings.
+            m_textMeshPro.fontSize = 48;
+
+            m_textMeshPro.alignment = TextAlignmentOptions.Center;
+            
+            //m_textMeshPro.anchorDampening = true; // Has been deprecated but under consideration for re-implementation.
+            //m_textMeshPro.enableAutoSizing = true;
+
+            //m_textMeshPro.characterSpacing = 0.2f;
+            //m_textMeshPro.wordSpacing = 0.1f;
+
+            //m_textMeshPro.enableCulling = true;
+            m_textMeshPro.enableWordWrapping = false;
+
+            //textMeshPro.fontColor = new Color32(255, 255, 255, 255);
+        }
+
+
+        void Update()
+        {
+            m_textMeshPro.SetText(label, m_frame % 1000);
+            m_frame += 1 * Time.deltaTime;
+        }
+
+    }
+}

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

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 9eff140b25d64601aabc6ba32245d099
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,158 @@
+using UnityEngine;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+
+    public class SkewTextExample : MonoBehaviour
+    {
+
+        private TMP_Text m_TextComponent;
+
+        public AnimationCurve VertexCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.25f, 2.0f), new Keyframe(0.5f, 0), new Keyframe(0.75f, 2.0f), new Keyframe(1, 0f));
+        //public float AngleMultiplier = 1.0f;
+        //public float SpeedMultiplier = 1.0f;
+        public float CurveScale = 1.0f;
+        public float ShearAmount = 1.0f;
+
+        void Awake()
+        {
+            m_TextComponent = gameObject.GetComponent<TMP_Text>();
+        }
+
+
+        void Start()
+        {
+            StartCoroutine(WarpText());
+        }
+
+
+        private AnimationCurve CopyAnimationCurve(AnimationCurve curve)
+        {
+            AnimationCurve newCurve = new AnimationCurve();
+
+            newCurve.keys = curve.keys;
+
+            return newCurve;
+        }
+
+
+        /// <summary>
+        ///  Method to curve text along a Unity animation curve.
+        /// </summary>
+        /// <param name="textComponent"></param>
+        /// <returns></returns>
+        IEnumerator WarpText()
+        {
+            VertexCurve.preWrapMode = WrapMode.Clamp;
+            VertexCurve.postWrapMode = WrapMode.Clamp;
+
+            //Mesh mesh = m_TextComponent.textInfo.meshInfo[0].mesh;
+
+            Vector3[] vertices;
+            Matrix4x4 matrix;
+
+            m_TextComponent.havePropertiesChanged = true; // Need to force the TextMeshPro Object to be updated.
+            CurveScale *= 10;
+            float old_CurveScale = CurveScale;
+            float old_ShearValue = ShearAmount;
+            AnimationCurve old_curve = CopyAnimationCurve(VertexCurve);
+
+            while (true)
+            {
+                if (!m_TextComponent.havePropertiesChanged && old_CurveScale == CurveScale && old_curve.keys[1].value == VertexCurve.keys[1].value && old_ShearValue == ShearAmount)
+                {
+                    yield return null;
+                    continue;
+                }
+
+                old_CurveScale = CurveScale;
+                old_curve = CopyAnimationCurve(VertexCurve);
+                old_ShearValue = ShearAmount;
+
+                m_TextComponent.ForceMeshUpdate(); // Generate the mesh and populate the textInfo with data we can use and manipulate.
+
+                TMP_TextInfo textInfo = m_TextComponent.textInfo;
+                int characterCount = textInfo.characterCount;
+
+
+                if (characterCount == 0) continue;
+
+                //vertices = textInfo.meshInfo[0].vertices;
+                //int lastVertexIndex = textInfo.characterInfo[characterCount - 1].vertexIndex;
+
+                float boundsMinX = m_TextComponent.bounds.min.x;  //textInfo.meshInfo[0].mesh.bounds.min.x;
+                float boundsMaxX = m_TextComponent.bounds.max.x;  //textInfo.meshInfo[0].mesh.bounds.max.x;
+
+
+
+                for (int i = 0; i < characterCount; i++)
+                {
+                    if (!textInfo.characterInfo[i].isVisible)
+                        continue;
+
+                    int vertexIndex = textInfo.characterInfo[i].vertexIndex;
+
+                    // Get the index of the mesh used by this character.
+                    int materialIndex = textInfo.characterInfo[i].materialReferenceIndex;
+
+                    vertices = textInfo.meshInfo[materialIndex].vertices;
+
+                    // Compute the baseline mid point for each character
+                    Vector3 offsetToMidBaseline = new Vector2((vertices[vertexIndex + 0].x + vertices[vertexIndex + 2].x) / 2, textInfo.characterInfo[i].baseLine);
+                    //float offsetY = VertexCurve.Evaluate((float)i / characterCount + loopCount / 50f); // Random.Range(-0.25f, 0.25f);
+
+                    // Apply offset to adjust our pivot point.
+                    vertices[vertexIndex + 0] += -offsetToMidBaseline;
+                    vertices[vertexIndex + 1] += -offsetToMidBaseline;
+                    vertices[vertexIndex + 2] += -offsetToMidBaseline;
+                    vertices[vertexIndex + 3] += -offsetToMidBaseline;
+
+                    // Apply the Shearing FX
+                    float shear_value = ShearAmount * 0.01f;
+                    Vector3 topShear = new Vector3(shear_value * (textInfo.characterInfo[i].topRight.y - textInfo.characterInfo[i].baseLine), 0, 0);
+                    Vector3 bottomShear = new Vector3(shear_value * (textInfo.characterInfo[i].baseLine - textInfo.characterInfo[i].bottomRight.y), 0, 0);
+
+                    vertices[vertexIndex + 0] += -bottomShear;
+                    vertices[vertexIndex + 1] += topShear;
+                    vertices[vertexIndex + 2] += topShear;
+                    vertices[vertexIndex + 3] += -bottomShear;
+
+
+                    // Compute the angle of rotation for each character based on the animation curve
+                    float x0 = (offsetToMidBaseline.x - boundsMinX) / (boundsMaxX - boundsMinX); // Character's position relative to the bounds of the mesh.
+                    float x1 = x0 + 0.0001f;
+                    float y0 = VertexCurve.Evaluate(x0) * CurveScale;
+                    float y1 = VertexCurve.Evaluate(x1) * CurveScale;
+
+                    Vector3 horizontal = new Vector3(1, 0, 0);
+                    //Vector3 normal = new Vector3(-(y1 - y0), (x1 * (boundsMaxX - boundsMinX) + boundsMinX) - offsetToMidBaseline.x, 0);
+                    Vector3 tangent = new Vector3(x1 * (boundsMaxX - boundsMinX) + boundsMinX, y1) - new Vector3(offsetToMidBaseline.x, y0);
+
+                    float dot = Mathf.Acos(Vector3.Dot(horizontal, tangent.normalized)) * 57.2957795f;
+                    Vector3 cross = Vector3.Cross(horizontal, tangent);
+                    float angle = cross.z > 0 ? dot : 360 - dot;
+
+                    matrix = Matrix4x4.TRS(new Vector3(0, y0, 0), Quaternion.Euler(0, 0, angle), Vector3.one);
+
+                    vertices[vertexIndex + 0] = matrix.MultiplyPoint3x4(vertices[vertexIndex + 0]);
+                    vertices[vertexIndex + 1] = matrix.MultiplyPoint3x4(vertices[vertexIndex + 1]);
+                    vertices[vertexIndex + 2] = matrix.MultiplyPoint3x4(vertices[vertexIndex + 2]);
+                    vertices[vertexIndex + 3] = matrix.MultiplyPoint3x4(vertices[vertexIndex + 3]);
+
+                    vertices[vertexIndex + 0] += offsetToMidBaseline;
+                    vertices[vertexIndex + 1] += offsetToMidBaseline;
+                    vertices[vertexIndex + 2] += offsetToMidBaseline;
+                    vertices[vertexIndex + 3] += offsetToMidBaseline;
+                }
+
+
+                // Upload the mesh with the revised information
+                m_TextComponent.UpdateVertexData();
+
+                yield return null; // new WaitForSeconds(0.025f);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d412675cfb3441efa3bf8dcd9b7624dc
+timeCreated: 1458801336
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,27 @@
+using UnityEngine;
+using System;
+
+
+namespace TMPro
+{
+    /// <summary>
+    /// EXample of a Custom Character Input Validator to only allow digits from 0 to 9.
+    /// </summary>
+    [Serializable]
+    //[CreateAssetMenu(fileName = "InputValidator - Digits.asset", menuName = "TextMeshPro/Input Validators/Digits", order = 100)]
+    public class TMP_DigitValidator : TMP_InputValidator
+    {
+        // Custom text input validation function
+        public override char Validate(ref string text, ref int pos, char ch)
+        {
+            if (ch >= '0' && ch <= '9')
+            {
+                text += ch;
+                pos += 1;
+                return ch;
+            }
+
+            return (char)0;
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 1a7eb92a01ed499a987bde9def05fbce
+timeCreated: 1473112765
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,254 @@
+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

@@ -0,0 +1,12 @@
+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.meta

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,157 @@
+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

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

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

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: a05dcd8be7ec4ccbb35c26219884aa37
+timeCreated: 1435531209
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences:
+  - TextPopup_Prefab_01: {fileID: 22450954, guid: b06f0e6c1dfa4356ac918da1bb32c603,
+      type: 2}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,125 @@
+using UnityEngine;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+    
+    public class TMP_UiFrameRateCounter : 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 TextMeshProUGUI m_TextMeshPro;
+        private RectTransform m_frameCounter_transform;
+
+        private FpsCounterAnchorPositions last_AnchorPosition;
+
+        void Awake()
+        {
+            if (!enabled)
+                return;
+
+            Application.targetFrameRate = 1000;
+
+            GameObject frameCounter = new GameObject("Frame Counter");
+            m_frameCounter_transform = frameCounter.AddComponent<RectTransform>();
+
+            m_frameCounter_transform.SetParent(this.transform, false);
+
+            m_TextMeshPro = frameCounter.AddComponent<TextMeshProUGUI>();
+            m_TextMeshPro.font = Resources.Load<TMP_FontAsset>("Fonts & Materials/LiberationSans SDF");
+            m_TextMeshPro.fontSharedMaterial = Resources.Load<Material>("Fonts & Materials/LiberationSans SDF - Overlay");
+
+            m_TextMeshPro.enableWordWrapping = false;
+            m_TextMeshPro.fontSize = 36;
+
+            m_TextMeshPro.isOverlay = true;
+
+            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>";
+
+                m_TextMeshPro.SetText(htmlColorTag + fpsLabel, fps, ms);
+
+                m_Frames = 0;
+                m_LastInterval = timeNow;
+            }
+        }
+
+
+        void Set_FrameCounter_Position(FpsCounterAnchorPositions anchor_position)
+        {
+            switch (anchor_position)
+            {
+                case FpsCounterAnchorPositions.TopLeft:
+                    m_TextMeshPro.alignment = TextAlignmentOptions.TopLeft;
+                    m_frameCounter_transform.pivot = new Vector2(0, 1);
+                    m_frameCounter_transform.anchorMin = new Vector2(0.01f, 0.99f);
+                    m_frameCounter_transform.anchorMax = new Vector2(0.01f, 0.99f);
+                    m_frameCounter_transform.anchoredPosition = new Vector2(0, 1);
+                    break;
+                case FpsCounterAnchorPositions.BottomLeft:
+                    m_TextMeshPro.alignment = TextAlignmentOptions.BottomLeft;
+                    m_frameCounter_transform.pivot = new Vector2(0, 0);
+                    m_frameCounter_transform.anchorMin = new Vector2(0.01f, 0.01f);
+                    m_frameCounter_transform.anchorMax = new Vector2(0.01f, 0.01f);
+                    m_frameCounter_transform.anchoredPosition = new Vector2(0, 0);
+                    break;
+                case FpsCounterAnchorPositions.TopRight:
+                    m_TextMeshPro.alignment = TextAlignmentOptions.TopRight;
+                    m_frameCounter_transform.pivot = new Vector2(1, 1);
+                    m_frameCounter_transform.anchorMin = new Vector2(0.99f, 0.99f);
+                    m_frameCounter_transform.anchorMax = new Vector2(0.99f, 0.99f);
+                    m_frameCounter_transform.anchoredPosition = new Vector2(1, 1);
+                    break;
+                case FpsCounterAnchorPositions.BottomRight:
+                    m_TextMeshPro.alignment = TextAlignmentOptions.BottomRight;
+                    m_frameCounter_transform.pivot = new Vector2(1, 0);
+                    m_frameCounter_transform.anchorMin = new Vector2(0.99f, 0.01f);
+                    m_frameCounter_transform.anchorMax = new Vector2(0.99f, 0.01f);
+                    m_frameCounter_transform.anchoredPosition = new Vector2(1, 0);
+                    break;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 24b0dc2d1d494adbbec1f4db26b4cf83
+timeCreated: 1448607572
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,84 @@
+using UnityEngine;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+    
+    public class TMPro_InstructionOverlay : MonoBehaviour
+    {
+
+        public enum FpsCounterAnchorPositions { TopLeft, BottomLeft, TopRight, BottomRight };
+
+        public FpsCounterAnchorPositions AnchorPosition = FpsCounterAnchorPositions.BottomLeft;
+
+        private const string instructions = "Camera Control - <#ffff00>Shift + RMB\n</color>Zoom - <#ffff00>Mouse wheel.";
+
+        private TextMeshPro m_TextMeshPro;
+        private TextContainer m_textContainer;
+        private Transform m_frameCounter_transform;
+        private Camera m_camera;
+
+        //private FpsCounterAnchorPositions last_AnchorPosition;
+
+        void Awake()
+        {
+            if (!enabled)
+                return;
+
+            m_camera = Camera.main;
+
+            GameObject frameCounter = new GameObject("Frame Counter");
+            m_frameCounter_transform = frameCounter.transform;
+            m_frameCounter_transform.parent = m_camera.transform;
+            m_frameCounter_transform.localRotation = Quaternion.identity;
+
+
+            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_TextMeshPro.fontSize = 30;
+
+            m_TextMeshPro.isOverlay = true;
+            m_textContainer = frameCounter.GetComponent<TextContainer>();
+
+            Set_FrameCounter_Position(AnchorPosition);
+            //last_AnchorPosition = AnchorPosition;
+
+            m_TextMeshPro.text = instructions;
+
+        }
+
+
+
+
+        void Set_FrameCounter_Position(FpsCounterAnchorPositions anchor_position)
+        {
+
+            switch (anchor_position)
+            {
+                case FpsCounterAnchorPositions.TopLeft:
+                    //m_TextMeshPro.anchor = AnchorPositions.TopLeft;
+                    m_textContainer.anchorPosition = TextContainerAnchors.TopLeft;
+                    m_frameCounter_transform.position = m_camera.ViewportToWorldPoint(new Vector3(0, 1, 100.0f));
+                    break;
+                case FpsCounterAnchorPositions.BottomLeft:
+                    //m_TextMeshPro.anchor = AnchorPositions.BottomLeft;
+                    m_textContainer.anchorPosition = TextContainerAnchors.BottomLeft;
+                    m_frameCounter_transform.position = m_camera.ViewportToWorldPoint(new Vector3(0, 0, 100.0f));
+                    break;
+                case FpsCounterAnchorPositions.TopRight:
+                    //m_TextMeshPro.anchor = AnchorPositions.TopRight;
+                    m_textContainer.anchorPosition = TextContainerAnchors.TopRight;
+                    m_frameCounter_transform.position = m_camera.ViewportToWorldPoint(new Vector3(1, 1, 100.0f));
+                    break;
+                case FpsCounterAnchorPositions.BottomRight:
+                    //m_TextMeshPro.anchor = AnchorPositions.BottomRight;
+                    m_textContainer.anchorPosition = TextContainerAnchors.BottomRight;
+                    m_frameCounter_transform.position = m_camera.ViewportToWorldPoint(new Vector3(1, 0, 100.0f));
+                    break;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: c3c1afeda5e545e0b19add5373896d2e
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,83 @@
+using UnityEngine;
+using System.Collections;
+
+
+namespace TMPro.Examples
+{
+    
+    public class TeleType : MonoBehaviour
+    {
+
+
+        //[Range(0, 100)]
+        //public int RevealSpeed = 50;
+
+        private string label01 = "Example <sprite=2> of using <sprite=7> <#ffa000>Graphics Inline</color> <sprite=5> with Text in <font=\"Bangers SDF\" material=\"Bangers SDF - Drop Shadow\">TextMesh<#40a0ff>Pro</color></font><sprite=0> and Unity<sprite=1>";
+        private string label02 = "Example <sprite=2> of using <sprite=7> <#ffa000>Graphics Inline</color> <sprite=5> with Text in <font=\"Bangers SDF\" material=\"Bangers SDF - Drop Shadow\">TextMesh<#40a0ff>Pro</color></font><sprite=0> and Unity<sprite=2>";
+
+
+        private TMP_Text m_textMeshPro;
+
+
+        void Awake()
+        {
+            // Get Reference to TextMeshPro Component
+            m_textMeshPro = GetComponent<TMP_Text>();
+            m_textMeshPro.text = label01;
+            m_textMeshPro.enableWordWrapping = true;
+            m_textMeshPro.alignment = TextAlignmentOptions.Top;
+
+
+
+            //if (GetComponentInParent(typeof(Canvas)) as Canvas == null)
+            //{
+            //    GameObject canvas = new GameObject("Canvas", typeof(Canvas));
+            //    gameObject.transform.SetParent(canvas.transform);
+            //    canvas.GetComponent<Canvas>().renderMode = RenderMode.ScreenSpaceOverlay;
+
+            //    // Set RectTransform Size
+            //    gameObject.GetComponent<RectTransform>().sizeDelta = new Vector2(500, 300);
+            //    m_textMeshPro.fontSize = 48;
+            //}
+
+
+        }
+
+
+        IEnumerator Start()
+        {
+
+            // Force and update of the mesh to get valid information.
+            m_textMeshPro.ForceMeshUpdate();
+
+
+            int totalVisibleCharacters = m_textMeshPro.textInfo.characterCount; // Get # of Visible Character in text object
+            int counter = 0;
+            int visibleCount = 0;
+
+            while (true)
+            {
+                visibleCount = counter % (totalVisibleCharacters + 1);
+
+                m_textMeshPro.maxVisibleCharacters = visibleCount; // How many characters should TextMeshPro display?
+
+                // Once the last character has been revealed, wait 1.0 second and start over.
+                if (visibleCount >= totalVisibleCharacters)
+                {
+                    yield return new WaitForSeconds(1.0f);
+                    m_textMeshPro.text = label02;
+                    yield return new WaitForSeconds(1.0f);
+                    m_textMeshPro.text = label01;
+                    yield return new WaitForSeconds(1.0f);
+                }
+
+                counter += 1;
+
+                yield return new WaitForSeconds(0.05f);
+            }
+
+            //Debug.Log("Done revealing the text.");
+        }
+
+    }
+}

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

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: e32c266ee6204b21a427753cb0694c81
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: