KeyboardHandler.cs

using CellexalVR.General;
using System;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using System.Collections;
using CellexalVR.Extensions;
using System.IO;
#if UNITY_EDITOR
using System.Reflection;

#endif

namespace CellexalVR.Interaction
{
    /// <summary>
    /// Class for events that the keyboard trigger.
    /// </summary>
    [Serializable]
    public class KeyboardEvent : UnityEvent<string>
    {
    }

    /// <summary>
    /// Handles the keyboard and what happens when keys are pressed.
    /// </summary>
    public abstract class KeyboardHandler : MonoBehaviour
    {
        public ReferenceManager referenceManager;
        public GameObject keysParentObject;
        public TextMeshPro output;
        public List<TextMeshPro> additionalOutputs;
        public float height = 5f;
        public float anglePerUnit = 5f;
        public float distance = 8f;
        public string placeholder = "Enter a name";
        public bool clearOnEnter = true;
        public KeyboardEvent OnEdit;
        public KeyboardEvent OnEditMultiuser;
        public KeyboardEvent OnEnter;

        public KeyboardEvent OnAnnotate;
        //public GameObject testCube;

        protected KeyboardPanel[] sortedKeys;
        [HideInInspector] public Vector2 minPos;
        [HideInInspector] public Vector2 maxPos;
        [HideInInspector] public List<Material> materials;

        private bool displayingPlaceHolder = true;
        protected string prefabFolderPath = Path.Combine("Assets", "Prefabs", "Keyboards");
        protected string prefabPath;

        // vector used by the shader to display pulse when a panel is clicked and an animation where the laser is.
        private static Vector4 PulseAndLaserCoords;
        private float pulseDuration;

        public int CurrentLayout { get; protected set; }
        abstract public string[][] Layouts { get; protected set; }

        public virtual void Shift()
        {
        }

        public virtual void NumChar()
        {
        }

        protected virtual void Start()
        {
            //Clear();
            SwitchLayout(Layouts[0]);
            //GatherKeys();
            CellexalEvents.GraphsUnloaded.AddListener(Clear);
        }

        /// <summary>
        /// Gets the scale correction for the keyboard shader.
        /// </summary>
        public Vector4 ScaleCorrection()
        {
            float scaleCorrectionX = (maxPos.x - minPos.x) / (maxPos.y - minPos.y);
            return new Vector4(scaleCorrectionX, 1f, 1f, 1f);
        }

        /// <summary>
        /// Shows a message for a certain time or if the user starts typing again.
        /// Called if something went wrong or anything to inform the user.
        /// </summary>
        public IEnumerator ShowMessage(string message, float time = 5f)
        {
            float currentTime = 0f;
            output.text = message;
            while (currentTime < time)
            {
                if (!output.text.Equals(message))
                {
                    break;
                }
                currentTime += Time.deltaTime;
                yield return null;
            }
            if (output.text.Equals(message))
            {
                output.text = "";
            }
        }


        /// <summary>
        /// Sets the materials on all keys. See <see cref="ClickablePanel.SetMaterials(Material, Material, Material)"/>.
        /// </summary>
        public void SetMaterials(Material keyNormalMaterial, Material keyHighlightMaterial, Material keyPressedMaterial)
        {
            if (sortedKeys == null || sortedKeys.Length == 0)
            {
                GatherKeys();
            }

            pulseDuration = keyNormalMaterial.GetFloat("_PulseDuration");

            // set up the scale correction shader property so the rings on the keyboard are properly displayed
            Material adjustedKeyNormalMaterial = new Material(keyNormalMaterial);
            Material adjustedKeyHighlightedMaterial = new Material(keyHighlightMaterial);
            Material adjustedKeyPressedMaterial = new Material(keyPressedMaterial);
            Vector4 scaleCorrection = ScaleCorrection();
            adjustedKeyNormalMaterial.SetVector("_ScaleCorrection", scaleCorrection);
            adjustedKeyHighlightedMaterial.SetVector("_ScaleCorrection", scaleCorrection);
            adjustedKeyPressedMaterial.SetVector("_ScaleCorrection", scaleCorrection);
            materials = new List<Material>();
            materials.Add(adjustedKeyNormalMaterial);
            materials.Add(adjustedKeyHighlightedMaterial);
            materials.Add(adjustedKeyPressedMaterial);
            //foreach (ClickablePanel panel in sortedKeys)
            //{
            //    panel.SetMaterials(adjustedKeyNormalMaterial, adjustedKeyHighlightedMaterial, adjustedKeyPressedMaterial);
            //}

            foreach (ClickablePanel panel in GetComponentsInChildren<ClickablePanel>(true))
            {
                panel.SetMaterials(adjustedKeyNormalMaterial, adjustedKeyHighlightedMaterial,
                    adjustedKeyPressedMaterial, scaleCorrection);
            }
        }

        public void AddMaterials(params Material[] mats)
        {
            materials.AddRange(mats);
        }


        /// <summary>
        /// Starts a pulse at the current laser coordinates, set by <see cref="UpdateLaserCoords(Vector2)"/>.
        /// </summary>
        public void Pulse()
        {
            // copy current laser coords (z and w) to the pulse coords (x and y).
            PulseAndLaserCoords = new Vector4(PulseAndLaserCoords.z, PulseAndLaserCoords.w, PulseAndLaserCoords.z, PulseAndLaserCoords.w);
            if (isActiveAndEnabled)
            {
                StartCoroutine(PulseCoroutine());
            }
        }

        /// <summary>
        /// Updates the coordinates for the laser hit animation.
        /// </summary>
        /// <param name="pos">The uv2 coordinates of the laser hit.</param>
        public virtual void UpdateLaserCoords(Vector2 pos)
        {
            PulseAndLaserCoords = new Vector4(PulseAndLaserCoords.x, PulseAndLaserCoords.y, pos.x, pos.y);
            SetVectors("_PulseCoords", PulseAndLaserCoords);
        }

        /// <summary>
        /// Uses the Keyboard shader to play a pulse anmimation.
        /// </summary>
        protected virtual IEnumerator PulseCoroutine()
        {
            float t = 0f;

            SetVectors("_PulseCoords", PulseAndLaserCoords);
            while (t < pulseDuration)
            {
                SetFloats("_PulseStartTime", t);
                t += Time.deltaTime;
                yield return null;
            }

            SetFloats("_PulseStartTime", -1f);
        }

        protected void SetVectors(string name, Vector4 value)
        {
            materials.ForEach((mat) => mat.SetVector(name, value));
        }

        protected void SetFloats(string name, float value)
        {
            materials.ForEach((mat) => mat.SetFloat(name, value));
        }

        /// <summary>
        /// Helper class to sort keyboarditems based on their position on the keyboard.
        /// </summary>
        private class KeyboardItemComparer : IComparer<KeyboardItem>
        {
            public int Compare(KeyboardItem a, KeyboardItem b)
            {
                return a.position.y == b.position.y
                    ? (int)(a.position.x - b.position.x)
                    : (int)(b.position.y - a.position.y);
            }
        }

        protected void GatherKeys()
        {
            GatherKeys(this);
        }

        /// <summary>
        /// Gathers the keys from the scene.
        /// </summary>
        /// <returns>True if keys were succesfully gathered, false otherwise.</returns>
        protected bool GatherKeys(KeyboardHandler prefabInstance)
        {
            prefabInstance.minPos = new Vector2(float.MaxValue, float.MaxValue);
            prefabInstance.maxPos = new Vector2(float.MinValue, float.MinValue);

            KeyboardItem[] items = prefabInstance.GetComponentsInChildren<KeyboardItem>(true);
            KeyboardItem[] itemsUnderKeyObject =
                prefabInstance.keysParentObject.GetComponentsInChildren<KeyboardItem>(true);
            prefabInstance.sortedKeys = prefabInstance.GetComponentsInChildren<KeyboardPanel>(true);
            // sort by position, y first then x
            if (itemsUnderKeyObject.Length != prefabInstance.sortedKeys.Length)
            {
                Debug.LogError("Can not build keyboard, different number of keys found. Items under key object: " +
                               itemsUnderKeyObject.Length + " keyboardpanels found: " +
                               prefabInstance.sortedKeys.Length);
                return false;
            }

            Array.Sort(itemsUnderKeyObject, prefabInstance.sortedKeys, new KeyboardItemComparer());
            // find the smallest and largest positions for later
            foreach (var item in items)
            {
                if (!item.hasKeyboardMaterial)
                {
                    continue;
                }

                Vector2 thisMinPos = item.position - new Vector2(item.size.x / 2f, 0f);
                Vector2 thisMaxPos = item.position + new Vector2(item.size.x / 2f, item.size.y);
                if (thisMinPos.x < minPos.x)
                {
                    prefabInstance.minPos.x = thisMinPos.x;
                }
                else if (thisMaxPos.x > maxPos.x)
                {
                    prefabInstance.maxPos.x = thisMaxPos.x;
                }

                if (thisMinPos.y < minPos.y)
                {
                    prefabInstance.minPos.y = thisMinPos.y;
                }
                else if (thisMaxPos.y > maxPos.y)
                {
                    prefabInstance.maxPos.y = thisMaxPos.y;
                }
            }

            return true;
        }

        /// <summary>
        /// Switches the layout of the keyboard.
        /// </summary>
        /// <param name="layout">The new layout.</param>
        protected void SwitchLayout(string[] layout)
        {
            if (sortedKeys == null || layout.Length != sortedKeys.Length)
            {
                // none, too many or too few keys found
                GatherKeys();

                if (layout.Length != sortedKeys.Length)
                {
                    Debug.LogError("Invalid number of keys on " + gameObject.name + ", string array layout length: " +
                                   layout.Length + ", number of found Keyboard panel gameobjects: " +
                                   sortedKeys.Length);
                    return;
                }
            }

            // everything seems ok, switch the layout
            for (int i = 0; i < sortedKeys.Length; ++i)
            {
                sortedKeys[i].GetComponentInChildren<KeyboardPanel>().Text = layout[i];
            }
        }

        /// <summary>
        /// Adds text to the output.
        /// </summary>
        /// <param name="add">Text to add</param>
        public void AddText(string add, bool invokeMultiuserEvent)
        {
            if (displayingPlaceHolder)
            {
                output.text = add.ToString();
                displayingPlaceHolder = false;
            }
            else
            {
                output.text += add;
            }

            if (OnEdit != null)
            {
                OnEdit.Invoke(Text());
            }

            if (invokeMultiuserEvent)
            {
                OnEditMultiuser.Invoke(add.ToString());
            }
        }


        /// <summary>
        /// Removes the last typed letter.
        /// </summary>
        public void BackSpace(bool invokeMultiuserEvent = false)
        {
            if (output.text.Length == 1)
            {
                Clear();
            }
            else if (!displayingPlaceHolder)
            {
                output.text = output.text.Remove(output.text.Length - 1);
            }

            if (OnEdit != null)
            {
                OnEdit.Invoke(Text());
            }

            if (invokeMultiuserEvent)
            {
                referenceManager.multiuserMessageSender.SendMessageBackspaceKeyClicked();
            }
        }

        /// <summary>
        /// Clears the output.
        /// </summary>
        public void Clear()
        {
            Clear(false);
        }

        /// <summary>
        /// Clears the output.
        /// </summary>
        /// <param name="invokeMultiuserEvent">True if an event to run this function on all connected clients should be invoked.</param>
        public void Clear(bool invokeMultiuserEvent = false)
        {
            output.text = placeholder;
            displayingPlaceHolder = true;
            if (OnEdit != null)
            {
                OnEdit.Invoke(Text());
            }

            if (invokeMultiuserEvent)
            {
                referenceManager.multiuserMessageSender.SendMessageClearKeyClicked();
            }
        }

        /// <summary>
        /// Colors all graphs based on what was typed.
        /// </summary>
        public void SubmitOutput(bool invoke = true)
        {
            foreach (var o in additionalOutputs)
            {
                o.text = output.text;
            }

            if (invoke && OnEnter != null)
            {
                OnEnter.Invoke(output.text);
            }


            //referenceManager.cellManager.ColorGraphsByGene(output.text);
            //referenceManager.previousSearchesList.AddEntry(output.text, Extensions.Definitions.Measurement.GENE, referenceManager.graphManager.GeneExpressionColoringMethod);
            //referenceManager.MultiuserMessageSender.SendMessageColorGraphsByGene(output.text);
            if (clearOnEnter)
            {
                Clear();
            }
        }

        /// <summary>
        /// Returns the currently typed text.
        /// </summary>
        public string Text()
        {
            if (displayingPlaceHolder)
            {
                return "";
            }
            else
            {
                return output.text;
            }
        }

        /// <summary>
        /// Clears all outputs and disables this keyboard.
        /// </summary>
        public void DismissKeyboard()
        {
            additionalOutputs.Clear();
            gameObject.SetActive(false);
        }

        public void SetAllOutputs(string text)
        {
            SetAllOutputs(text, Definitions.Measurement.GENE);
        }

        /// <summary>
        /// Sets all outputs to a text.
        /// </summary>
        /// <param name="text">The text to set all outputs to</param>
        public void SetAllOutputs(string text, Definitions.Measurement type)
        {
            if (text == "")
            {
                text = placeholder;
                displayingPlaceHolder = true;
            }
            else
            {
                displayingPlaceHolder = false;
            }

            foreach (var o in additionalOutputs)
            {
                o.text = text;
            }

            if (type == Definitions.Measurement.FACS)
            {
                output.text = $"FACS {text}";
            }
            else if (type == Definitions.Measurement.NUM)
            {
                output.text = $"NUM {text}";
            }
            else
            {
                output.text = text;
            }
        }

        /// <summary>
        /// Converts a direction to a uv2 coordinate on the keyboard.
        /// This function can return uv2 coordinates that are not actually on the keyboard if there is no keyboard in that direction.
        /// </summary>
        /// <param name="dir">A direction starting from the keyboard's local (0, 0, 0) position, preferably pointing towards the keyboard.</param>
        /// <returns>A uv2 coordinate where the <paramref name="dir"/> points to.</returns>
        public Vector2 ToUv2Coord(Vector3 dir)
        {
            float angleMultiplier = anglePerUnit == 0f ? 1f : anglePerUnit;
            Vector3 dirLocalSpace = transform.InverseTransformPoint(dir);

            // y coordinate
            float keyboardYCoord = dirLocalSpace.y / height;

            // x coordinate
            dirLocalSpace.y = 0f;
            Vector3 a = Vector3.right;
            Vector3 b = dirLocalSpace + new Vector3(distance, 0f, 0f);
            float angle = Vector3.SignedAngle(a, b, Vector3.up);
            float keyboardSizeX = (maxPos.x - minPos.x) * angleMultiplier;
            float keyboardAngleSizeNegative = minPos.x * angleMultiplier;
            float angleFromZero = Mathf.Abs(keyboardAngleSizeNegative) + angle;

            return new Vector2(angleFromZero / keyboardSizeX, keyboardYCoord);
            //print("angleMultiplier " + angleMultiplier + " a " + V2S(a) + " b " + V2S(b) + " angle " + angle + " keyboardSizeX " + keyboardSizeX +
            //    " keyboardAngleSizeNegative " + keyboardAngleSizeNegative + " angleFromZero " + angleFromZero +
            //    " keyboardYCoord " + keyboardYCoord + " laserCoords " + V2S(laserCoords));
        }
#if UNITY_EDITOR

        private string V2S(Vector3 v)
        {
            return "(" + v.x + ", " + v.y + ", " + v.z + ")";
        }

        private string V2S(Vector2 v)
        {
            return "(" + v.x + ", " + v.y + ")";
        }

        private void OnValidate()
        {
            if (referenceManager == null && gameObject.scene.IsValid())
            {
                referenceManager = GameObject.Find("InputReader").GetComponent<General.ReferenceManager>();
            }

            if (!System.IO.Directory.Exists(prefabFolderPath))
            {
                System.IO.Directory.CreateDirectory(prefabFolderPath);
            }
        }

        /// <summary>
        /// Helper method for inherited classes to open the correct prefab. Remember to call <see cref="ClosePrefab(GameObject)"/> after.
        /// </summary>
        /// <param name="prefab">The opened prefab.</param>
        /// <param name="scriptOnPrefab">This script, but on the prefab.</param>
        protected void OpenPrefab<T>(out GameObject outerMostPrefab, out T scriptOnPrefab) where T : KeyboardHandler
        {
            UnityEditor.EditorUtility.DisplayProgressBar("Building keyboard", "Getting correct prefab", 0f);
            GameObject outerMostPrefabInstance = UnityEditor.PrefabUtility.GetOutermostPrefabInstanceRoot(gameObject);
            prefabPath = UnityEditor.PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(outerMostPrefabInstance);

            UnityEditor.EditorUtility.DisplayProgressBar("Building keyboard", "Applying overrides", 0.1f);
            UnityEditor.Undo.RecordObject(outerMostPrefabInstance, "Apply keyboard override");
            UnityEditor.PrefabUtility.ApplyPrefabInstance(outerMostPrefabInstance,
                UnityEditor.InteractionMode.AutomatedAction);
            UnityEditor.PrefabUtility.SaveAsPrefabAssetAndConnect(outerMostPrefabInstance, prefabPath,
                UnityEditor.InteractionMode.AutomatedAction);
            UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(outerMostPrefabInstance.scene);
            UnityEditor.EditorUtility.DisplayProgressBar("Building keyboard", "Opening prefab", 0.2f);
            outerMostPrefab = UnityEditor.PrefabUtility.LoadPrefabContents(prefabPath);
            scriptOnPrefab = outerMostPrefab.GetComponentInChildren<T>(true);
            if (!scriptOnPrefab)
            {
                Debug.LogError("No appropriate script (" + typeof(T).ToString() + ") found in prefab at " + prefabPath);
                UnityEditor.PrefabUtility.UnloadPrefabContents(outerMostPrefab);
                UnityEditor.EditorUtility.ClearProgressBar();
                return;
            }

            UnityEditor.EditorUtility.DisplayProgressBar("Building keyboard", "Building keyboard", 0.3f);
            UnityEditor.AssetDatabase.StartAssetEditing();
        }

        /// <summary>
        /// Helper method for inherited clases to close the correct prefab.
        /// </summary>
        /// <param name="prefab">The <see cref="GameObject"/> that <see cref="OpenPrefab{T}(out GameObject, out T)"/> returns</param>
        protected void ClosePrefab(GameObject prefab)
        {
            UnityEditor.AssetDatabase.StopAssetEditing();
            UnityEditor.EditorUtility.DisplayProgressBar("Building keyboard", "Saving prefab", 0.9f);
            UnityEditor.PrefabUtility.SaveAsPrefabAssetAndConnect(prefab, prefabPath,
                UnityEditor.InteractionMode.AutomatedAction);
            UnityEditor.PrefabUtility.UnloadPrefabContents(prefab);


            UnityEditor.EditorUtility.ClearProgressBar();
        }


        /// <summary>
        /// Builds the keyboard by creating the meshes and positioning everything.
        /// </summary>
        /// <returns>True if the keyboard was successfully built, false otherwise.</returns>
        public virtual bool BuildKeyboard(KeyboardHandler prefab)
        {
            string keyboardMeshesBaseFolder = Path.Combine(prefabFolderPath, "KeyboardMeshes");
            if (!UnityEditor.AssetDatabase.IsValidFolder(keyboardMeshesBaseFolder))
            {
                UnityEditor.AssetDatabase.CreateFolder(prefabFolderPath, "KeyboardMeshes");
            }

            string keyboardMeshesFolder = Path.Combine(keyboardMeshesBaseFolder, prefab.name);
            if (!UnityEditor.AssetDatabase.IsValidFolder(keyboardMeshesFolder))
            {
                UnityEditor.AssetDatabase.CreateFolder(keyboardMeshesBaseFolder, prefab.name);
            }
            else
            {
                foreach (var asset in UnityEditor.AssetDatabase.FindAssets("", new string[] { keyboardMeshesFolder }))
                {
                    UnityEditor.AssetDatabase.DeleteAsset(UnityEditor.AssetDatabase.GUIDToAssetPath(asset));
                }
            }

            if (!prefab.GatherKeys(prefab))
            {
                return false;
            }

            Vector2 size = prefab.maxPos - prefab.minPos;

            float radiansPerUnit = anglePerUnit / 180f * Mathf.PI;

            foreach (KeyboardItem item in prefab.GetComponentsInChildren<KeyboardItem>())
            {
                Vector3 position;
                float keyAngleDegrees = 0;
                if (anglePerUnit != 0f)
                {
                    keyAngleDegrees = anglePerUnit * -item.position.x;
                    float keyAngleRadians = radiansPerUnit * -item.position.x;
                    position = new Vector3(Mathf.Cos(keyAngleRadians) - 1f, 0, Mathf.Sin(keyAngleRadians)) * distance;

                    item.transform.localRotation = Quaternion.Euler(0f, 90 - keyAngleDegrees, 0f);
                }
                else
                {
                    position = new Vector3(item.position.x / height, item.position.y / height, 0);
                }

                float yPos = item.position.y * height / size.y;
                position += new Vector3(0f, yPos, 0f);
                item.transform.localPosition = position;
                // scale so everything fits
                float scale = height / size.y;
                item.transform.localScale = new Vector3(1f, 1f, 1f);
                ClickablePanel panel = item.GetComponentInChildren<ClickablePanel>();
                if (panel != null)
                {
                    if (panel is KeyboardPanel keyboardPanel)
                    {
                        UnityEditor.Undo.RecordObject(keyboardPanel, "Keyboardpanel build keyboard");
                        keyboardPanel.referenceManager = prefab.referenceManager;
                        keyboardPanel.handler = prefab;

                        TextMeshPro text = item.GetComponentInChildren<TextMeshPro>();
                        text.margin = new Vector4(0.25f, 0f, 0.25f, 0.5f);
                        if (keyboardPanel.keyType == KeyboardPanel.Type.Enter)
                        {
                            text.transform.localPosition = new Vector3(0f, 0f, -0.1f * anglePerUnit / 3f);
                        }
                        else
                        {
                            text.transform.localPosition = new Vector3(0f, 0f, -0.01f);
                        }

                        text.transform.localScale = Vector3.one * (height / ((size.y - 1) / 4));
                    }

                    Vector2 min = item.position - new Vector2(item.size.x / 2f, 0f) - minPos;
                    Vector2 max = item.position + new Vector2(item.size.x / 2f, item.size.y) - minPos;
                    Vector2 smallUV = new Vector2(min.x / size.x, min.y / size.y);
                    Vector2 largeUV = new Vector2(max.x / size.x, max.y / size.y);
                    panel.CenterUV = (smallUV + largeUV) / 2f;
                    //print("panel " + item.name + " smalluv (" + smallUV.x + ", " + smallUV.y + ") largeuv (" + largeUV.x + ", " + largeUV.y + ") keyangle " + keyAngleDegrees);
                    Mesh mesh = CreateNineSlicedQuad(smallUV, largeUV, item.size, radiansPerUnit, size);
                    string assetName = Path.Combine(keyboardMeshesFolder, "KeyboardMesh_" + item.name + ".mesh");
                    assetName = UnityEditor.AssetDatabase.GenerateUniqueAssetPath(assetName);
                    UnityEditor.AssetDatabase.CreateAsset(mesh, assetName);
                    panel.transform.localRotation = Quaternion.Euler(0f, -90f, 0f);
                    panel.GetComponent<MeshFilter>().mesh = mesh;
                    if (panel.GetComponent<MeshCollider>())
                    {
                        DestroyImmediate(panel.GetComponent<MeshCollider>());
                    }

                    if (panel.GetComponent<BoxCollider>() == null)
                    {
                        panel.gameObject.AddComponent<BoxCollider>();
                    }

                    var boxCollider = panel.gameObject.GetComponent<BoxCollider>();
                    boxCollider.center = mesh.bounds.center;
                    boxCollider.size = mesh.bounds.size;
                    panel.transform.localScale = new Vector3(1f, 1f, 1f);
                }

                //print("assigning (" + smallUV.x + ", " + smallUV.y + ") (" + largeUV.x + ", " + largeUV.y + ") to " + panel.Text);
            }


            prefab.SwitchLayout(Layouts[0]);
            if (prefab.output)
            {
                prefab.output.text = placeholder;
            }

            return true;
        }

        /// <summary>
        /// Creates a nine sliced quad that is used for the panels on the keyboard. This lets us use a texture with a border that won't be stretched over non-square panels. 
        /// Meshes will be curved along a circle arc with the angle <paramref name="anglePerUnit"/> multiplied by the x component of <paramref name="size"/> and with the radius <paramref name="distance"/>.
        /// </summary>
        /// <param name="uv2min">The smallest uv2 coordinates. The uv2 should reflect the panel's position on the keyboard.</param>
        /// <param name="uv2max">The largest uv2 coordinates.</param>
        /// <param name="size">This panel's size.</param>
        /// <param name="anglePerUnit">Radians per unit of <paramref name="size"/>. Affects how wide the panel becomes.</param>
        /// <param name="keyboardSize">The size of the keyboard, in the same units as <paramref name="size"/>.</param>
        /// <returns></returns>
        public Mesh CreateNineSlicedQuad(Vector2 uv2min, Vector2 uv2max, Vector2 size, float anglePerUnit,
            Vector2 keyboardSize)
        {
            // left, right, bottom and top margins
            float l = 0.1f, r = 0.1f;
            float b = 0.1f, t = 0.1f;
            float uvl = l / 2f, uvr = r / 2f;
            float uvb = b / 2f, uvt = t / 2f;
            int xSegments = (int)size.x;
            float maxXCoord = size.x / 2f;
            float minXCoord = -maxXCoord;
            float adjHeight = height / keyboardSize.y;
            float maxYCoord = size.y * adjHeight;

            // vertices need their coordinates scaled, uv does not 
            //float adjl = l * adjSize.x;
            //float adjr = r * adjSize.x;
            float adjb = b * adjHeight;
            float adjt = t * adjHeight;
            anglePerUnit = -anglePerUnit;
            // pre-calculate some values
            float[] cosVals = new float[]
            {
                Mathf.Cos(anglePerUnit * minXCoord) * distance - distance,
                Mathf.Cos(anglePerUnit * (minXCoord + l)) * distance - distance,
                Mathf.Cos(anglePerUnit * (maxXCoord - r)) * distance - distance,
                Mathf.Cos(anglePerUnit * maxXCoord) * distance - distance
            };
            float[] sinVals = new float[]
            {
                Mathf.Sin(anglePerUnit * minXCoord) * distance,
                Mathf.Sin(anglePerUnit * (minXCoord + l)) * distance,
                Mathf.Sin(anglePerUnit * (maxXCoord - r)) * distance,
                Mathf.Sin(anglePerUnit * maxXCoord) * distance
            };

            Vector3[] verts = new Vector3[16 + 4 * (xSegments - 1)];
            // set up the corners
            Vector3[] vertCorners = new Vector3[]
            {
                new Vector3(cosVals[0], maxYCoord, sinVals[0]), new Vector3(cosVals[0], maxYCoord - adjt, sinVals[0]),
                new Vector3(cosVals[0], adjb, sinVals[0]), new Vector3(cosVals[0], 0f, sinVals[0]),
                new Vector3(cosVals[1], maxYCoord, sinVals[1]), new Vector3(cosVals[1], maxYCoord - adjt, sinVals[1]),
                new Vector3(cosVals[1], adjb, sinVals[1]), new Vector3(cosVals[1], 0f, sinVals[1]),
                new Vector3(cosVals[2], maxYCoord, sinVals[2]), new Vector3(cosVals[2], maxYCoord - adjt, sinVals[2]),
                new Vector3(cosVals[2], adjb, sinVals[2]), new Vector3(cosVals[2], 0f, sinVals[2]),
                new Vector3(cosVals[3], maxYCoord, sinVals[3]), new Vector3(cosVals[3], maxYCoord - adjt, sinVals[3]),
                new Vector3(cosVals[3], adjb, sinVals[3]), new Vector3(cosVals[3], 0f, sinVals[3])
            };

            Array.Copy(vertCorners, 0, verts, 0, 8);
            Array.Copy(vertCorners, 8, verts, verts.Length - 8, 8);

            // do the same for the uv
            Vector2[] uv = new Vector2[verts.Length];
            Vector2[] uvCorners = new Vector2[]
            {
                new Vector2(0f, 1f), new Vector2(0f, 1f - uvt), new Vector2(0f, uvb), new Vector2(0f, 0f),
                new Vector2(uvl, 1f), new Vector2(uvl, 1f - uvt), new Vector2(uvl, uvb), new Vector2(uvl, 0f),
                new Vector2(1f - uvr, 1f), new Vector2(1f - uvr, 1f - uvt), new Vector2(1f - uvr, uvb),
                new Vector2(1f - uvr, 0f),
                new Vector2(1f, 1f), new Vector2(1f, 1f - uvt), new Vector2(1f, uvb), new Vector2(1f, 0f)
            };

            Array.Copy(uvCorners, 0, uv, 0, 8);
            Array.Copy(uvCorners, 8, uv, uv.Length - 8, 8);

            // set up the middle segments
            float xCoordDiff = (maxXCoord - minXCoord) / xSegments;
            for (int i = 1, index = 8; i < xSegments; ++i)
            {
                float xposUV = i / size.x;
                float angle = anglePerUnit * (minXCoord + xCoordDiff * i);
                float xpos = Mathf.Cos(angle) * distance - distance;
                float zpos = Mathf.Sin(angle) * distance;

                verts[index] = new Vector3(xpos, maxYCoord, zpos);
                uv[index] = new Vector2(xposUV, 1f);
                index++;

                verts[index] = new Vector3(xpos, maxYCoord - adjt, zpos);
                uv[index] = new Vector2(xposUV, 1f - uvt);
                index++;

                verts[index] = new Vector3(xpos, adjb, zpos);
                uv[index] = new Vector2(xposUV, uvb);
                index++;

                verts[index] = new Vector3(xpos, 0f, zpos);
                uv[index] = new Vector2(xposUV, 0f);
                index++;
            }

            // fill in all the triangles, these fortunately look the same over the entire mesh
            int[] tris = new int[54 + 18 * (xSegments - 1)];
            for (int i = 0, vert = 0; i < tris.Length; ++vert)
            {
                tris[i++] = vert;
                tris[i++] = vert + 4;
                tris[i++] = vert + 5;
                tris[i++] = vert;
                tris[i++] = vert + 5;
                tris[i++] = vert + 1;
                // skip every 4th vertex as that is jumping to a new coloumn
                if (vert % 4 == 2)
                {
                    vert++;
                }
            }

            // uv2 should be the each vertex position relative to its position on the keyboard
            Vector2[] uv2 = new Vector2[verts.Length];

            float uv2l = l / keyboardSize.x, uv2r = r / keyboardSize.x;
            float uv2b = b / keyboardSize.y, uv2t = t / keyboardSize.y;
            // set up the corners 
            Vector2[] uv2Corners = new Vector2[]
            {
                new Vector2(uv2min.x, uv2max.y), new Vector2(uv2min.x, uv2max.y - uv2t),
                new Vector2(uv2min.x, uv2min.y + uv2b), new Vector2(uv2min.x, uv2min.y),
                new Vector2(uv2min.x + uv2l, uv2max.y), new Vector2(uv2min.x + uv2l, uv2max.y - uv2t),
                new Vector2(uv2min.x + uv2l, uv2min.y + uv2b), new Vector2(uv2min.x + uv2l, uv2min.y),
                new Vector2(uv2max.x - uv2r, uv2max.y), new Vector2(uv2max.x - uv2r, uv2max.y - uv2t),
                new Vector2(uv2max.x - uv2r, uv2min.y + uv2b), new Vector2(uv2max.x - uv2r, uv2min.y),
                new Vector2(uv2max.x, uv2max.y), new Vector2(uv2max.x, uv2max.y - uv2t),
                new Vector2(uv2max.x, uv2min.y + uv2b), new Vector2(uv2max.x, uv2min.y)
            };
            Array.Copy(uv2Corners, 0, uv2, 0, 8);
            Array.Copy(uv2Corners, 8, uv2, uv2.Length - 8, 8);

            // set up the middle segments
            float uv2XDiff = (uv2max.x - uv2min.x) / xSegments;
            for (int i = 1, index = 8; i < xSegments; ++i)
            {
                float xPos = uv2min.x + uv2XDiff * i;
                uv2[index] = new Vector2(xPos, uv2max.y);
                index++;
                uv2[index] = new Vector2(xPos, uv2max.y - uv2t);
                index++;
                uv2[index] = new Vector2(xPos, uv2min.y + uv2b);
                index++;
                uv2[index] = new Vector2(xPos, uv2min.y);
                index++;
            }

            Mesh mesh = new Mesh()
            {
                vertices = verts,
                triangles = tris,
                uv = uv,
                uv2 = uv2
            };
            mesh.RecalculateBounds();

            return mesh;
        }
#endif
    }
}