//using UnityEngine;
//#if UNITY_EDITOR
//using UnityEditor;
//#endif
//using System.Collections;
//using System.IO;
//using System;
//using System.Collections.Generic;
//using System.Reflection;
//using System.Text;

//namespace Gaia
//{
//    public class Utils : MonoBehaviour
//    {
//        #region Asset directory helpers
//        /// <summary>
//        /// Get raw gaia asset directory
//        /// </summary>
//        /// <returns>Base gaia directory</returns>
//        //public static string GetGaiaAssetDirectory()
//        //{
//        //    string path = Path.Combine(Application.dataPath, Gaia.GaiaConstants.AssetDir);
//        //    return path.Replace('\\', '/');
//        //}

//        /// <summary>
//        /// Get the asset directory for a particular featiure type
//        /// </summary>
//        /// <param name="featureType"></param>
//        /// <returns>Path of feature type</returns>
//        //public static string GetGaiaAssetDirectory(Gaia.GaiaConstants.FeatureType featureType)
//        //{
//        //    string path = Path.Combine(Application.dataPath, Gaia.GaiaConstants.AssetDir);
//        //    path = Path.Combine(path, featureType.ToString());
//        //    return path.Replace('\\', '/');
//        //}

//        /// <summary>
//        /// Get a list of the Gaia stamps for the feature type provided
//        /// </summary>
//        /// <param name="featureType"></param>
//        /// <returns></returns>
//        //public static List<string> GetGaiaStampsList(Gaia.GaiaConstants.FeatureType featureType)
//        //{
//        //    return new List<string>(System.IO.Directory.GetFiles(GetGaiaAssetDirectory(featureType), "*.jpg"));
//        //}

//        /// <summary>
//        /// Get the full asset path for a specific asset type and name
//        /// </summary>
//        /// <param name="featureType">The type of feature this asset is</param>
//        /// <param name="assetName">The file name of the asset</param>
//        /// <returns>Fully qualified path of the asset</returns>
//        //public static string GetGaiaAssetPath(Gaia.GaiaConstants.FeatureType featureType, string assetName)
//        //{
//        //    string path = GetGaiaAssetDirectory(featureType);
//        //    path = Path.Combine(GetGaiaAssetDirectory(featureType), assetName);
//        //    return path.Replace('\\', '/');
//        //}

//        /// <summary>
//        /// Get the full asset path for a specific asset type and name
//        /// </summary>
//        /// <param name="featureType">The type of feature this asset is</param>
//        /// <param name="assetName">The file name of the asset</param>
//        /// <returns>Fully qualified path of the asset</returns>
//        //public static string GetGaiaStampAssetPath(Gaia.GaiaConstants.FeatureType featureType, string assetName)
//        //{
//        //    string path = GetGaiaAssetDirectory(featureType);
//        //    path = Path.Combine(GetGaiaAssetDirectory(featureType), "Data");
//        //    path = Path.Combine(path, assetName);
//        //    return path.Replace('\\', '/');
//        //}


//        /// <summary>
//        /// Parse a stamp preview texture to work out where the stamp lives
//        /// </summary>
//        /// <param name="source">Source texture</param>
//        /// <returns></returns>
////        public static string GetGaiaStampPath(Texture2D source)
////        {
////            string path = "";
////#if UNITY_EDITOR
////            path = UnityEditor.AssetDatabase.GetAssetPath(source);
////#endif

////            string fileName = Path.GetFileName(path);
////            path = Path.Combine(Path.GetDirectoryName(path), "Data");
////            path = Path.Combine(path, fileName);
////            path = Path.ChangeExtension(path, ".bytes");
////            path = path.Replace('\\', '/');
////            return path;
////        }

//        /// <summary>
//        /// Check to see if this actually a valid stamp - needs a .jpg and a .bytes file
//        /// </summary>
//        /// <param name="source">Source texture</param>
//        /// <returns></returns>
////        public static bool CheckValidGaiaStampPath(Texture2D source)
////        {
////            string path = "";
////#if UNITY_EDITOR
////            path = UnityEditor.AssetDatabase.GetAssetPath(source);
////#endif

////            //path = GetGaiaAssetDirectory() + path.Replace(Gaia.GaiaConstants.AssetDirFromAssetDB, "");

////            // Check to see if we have a jpg file
////            if (Path.GetExtension(path).ToLower() != ".jpg")
////            {
////                return false;
////            }

////            //Check to see if we have asset file
////            string fileName = Path.GetFileName(path);
////            path = Path.Combine(Path.GetDirectoryName(path), "Data");
////            path = Path.Combine(path, fileName);
////            path = Path.ChangeExtension(path, ".bytes");
////            path = path.Replace('\\', '/');

////            if (System.IO.File.Exists(path))
////            {
////                return true;
////            }
////            else
////            {
////                return false;
////            }
////        }

//        /// <summary>
//        /// Create all the Gaia asset directories for scans to go into
//        /// </summary>
////        public static void CreateGaiaAssetDirectories()
////        {
////#if UNITY_EDITOR
////            string path = Path.Combine(Application.dataPath, Gaia.GaiaConstants.AssetDir);
////            try
////            {
////                bool addedDir = false;
////                foreach (Gaia.GaiaConstants.FeatureType feature in Enum.GetValues(typeof(Gaia.GaiaConstants.FeatureType)))
////                {
////                    path = GetGaiaAssetDirectory(feature);
////                    if (!Directory.Exists(path))
////                    {
////                        Directory.CreateDirectory(path);
////                        path = Path.Combine(path, "Data");
////                        Directory.CreateDirectory(path);
////                        addedDir = true;
////                    }
////                }

////                if (addedDir)
////                {
////                    AssetDatabase.Refresh();
////                }
////            }
////            catch (Exception e)
////            {
////                Debug.LogError(string.Format("Failed to create directory {0} : {1}", path, e.Message));
////            }
////#endif
////        }

//        /// <summary>
//        /// Get all objects of the given type at the location in the path. Only works in the editor.
//        /// </summary>
//        /// <typeparam name="T">Type of object to load</typeparam>
//        /// <param name="path">The path to look in</param>
//        /// <returns>List of those objects</returns>
//        public static T[] GetAtPath<T>(string path)
//        {

//            ArrayList al = new ArrayList();

//#if UNITY_EDITOR

//            string[] fileEntries = Directory.GetFiles(Application.dataPath + "/" + path);
//            foreach (string fileName in fileEntries)
//            {
//                int index = fileName.LastIndexOf("/");
//                string localPath = "Assets/" + path;

//                if (index > 0)
//                    localPath += fileName.Substring(index);

//                UnityEngine.Object t = UnityEditor.AssetDatabase.LoadAssetAtPath(localPath, typeof(T));

//                if (t != null)
//                    al.Add(t);
//            }

//#endif

//            T[] result = new T[al.Count];
//            for (int i = 0; i < al.Count; i++)
//                result[i] = (T)al[i];

//            return result;
//        }

//        #endregion

//        #region Image helpers

//        /// <summary>
//        /// Make the texture supplied into a normal map
//        /// </summary>
//        /// <param name="texture">Texture to convert</param>
//        public static void MakeTextureNormal(Texture2D texture)
//        {
//            if (texture == null)
//            {
//                return;
//            }
//#if UNITY_EDITOR
//            string assetPath = AssetDatabase.GetAssetPath(texture);
//            var tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
//            if (tImporter != null && tImporter.textureType != TextureImporterType.NormalMap)
//            {
//                tImporter.textureType = TextureImporterType.NormalMap;
//                tImporter.SaveAndReimport();
//                AssetDatabase.Refresh();
//            }
//#endif
//        }

//        /// <summary>
//        /// Make the texture supplied readable
//        /// </summary>
//        /// <param name="texture">Texture to convert</param>
//        public static void MakeTextureReadable(Texture2D texture)
//        {
//            if (texture == null)
//            {
//                return;
//            }
//#if UNITY_EDITOR
//            string assetPath = AssetDatabase.GetAssetPath(texture);
//            var tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
//            if (tImporter != null && tImporter.isReadable != true)
//            {
//                tImporter.isReadable = true;
//                tImporter.SaveAndReimport();
//                AssetDatabase.Refresh();
//            }
//#endif
//        }

//        /// <summary>
//        /// Make the texture supplied uncompressed
//        /// </summary>
//        /// <param name="texture">Texture to convert</param>
//        public static void MakeTextureUncompressed(Texture2D texture)
//        {
//            if (texture == null)
//            {
//                return;
//            }
//#if UNITY_EDITOR
//            string assetPath = AssetDatabase.GetAssetPath(texture);
//            var tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
//            if (tImporter != null && tImporter.textureCompression != TextureImporterCompression.Uncompressed)
//            {
//                tImporter.textureCompression = TextureImporterCompression.Uncompressed;
//                tImporter.SaveAndReimport();
//                AssetDatabase.Refresh();
//            }
//#endif
//        }

//        /// <summary>
//        /// Compress / encode a single layer map file to an image
//        /// </summary>
//        /// <param name="input">Single layer map in format x,y</param>
//        /// <param name="imageName">Output image name - image image index and extension will be added</param>
//        /// <param name="exportPNG">True if a png is wanted</param>
//        /// <param name="exportJPG">True if a jpg is wanted</param>
//        public static void CompressToSingleChannelFileImage(float[,] input, string imageName, TextureFormat imageStorageFormat = Gaia.GaiaConstants.defaultTextureFormat, bool exportPNG = true, bool exportJPG = true)
//        {
//            int width = input.GetLength(0);
//            int height = input.GetLength(1);

//            Texture2D exportTexture = new Texture2D(width, height, imageStorageFormat, false);
//            Color pixelColor = new Color();
//            pixelColor.a = 1f;
//            pixelColor.r = pixelColor.g = pixelColor.b = 0f;

//            for (int x = 0; x < width; x++)
//            {
//                for (int y = 0; y < height; y++)
//                {
//                    pixelColor.r = pixelColor.b = pixelColor.g = input[x, y];
//                    exportTexture.SetPixel(x, y, pixelColor);
//                }
//            }

//            exportTexture.Apply();

//            // Write JPG
//            if (exportJPG)
//            {
//                ExportJPG(imageName, exportTexture);
//            }

//            // Write PNG
//            if (exportPNG)
//            {
//                ExportPNG(imageName, exportTexture);
//            }

//            //Lose the texture
//            DestroyImmediate(exportTexture);
//        }

//        /// <summary>
//        /// Compress / encode a multi layer map file to an image
//        /// </summary>
//        /// <param name="input">Multi layer map in format x,y,layer</param>
//        /// <param name="imageName">Output image name - image image index and extension will be added</param>
//        /// <param name="exportPNG">True if a png is wanted</param>
//        /// <param name="exportJPG">True if a jpg is wanted</param>
//        public static void CompressToMultiChannelFileImage(float[,,] input, string imageName, TextureFormat imageStorageFormat = Gaia.GaiaConstants.defaultTextureFormat, bool exportPNG = true, bool exportJPG = true)
//        {
//            int width = input.GetLength(0);
//            int height = input.GetLength(1);
//            int layers = input.GetLength(2);
//            int images = (layers + 3) / 4;

//            for (int image = 0; image < images; image++)
//            {
//                Texture2D exportTexture = new Texture2D(width, width, imageStorageFormat, false);
//                Color pixelColor = new Color();
//                int layer = image * 4;

//                for (int x = 0; x < width; x++)
//                {
//                    for (int y = 0; y < height; y++)
//                    {
//                        pixelColor.r = layer < layers ? input[x, y, layer] : 0f;
//                        pixelColor.g = (layer + 1) < layers ? input[x, y, (layer + 1)] : 0f;
//                        pixelColor.b = (layer + 2) < layers ? input[x, y, (layer + 2)] : 0f;
//                        pixelColor.a = (layer + 3) < layers ? input[x, y, (layer + 3)] : 0f;
//                        exportTexture.SetPixel(x, y, pixelColor);
//                    }
//                }
//                exportTexture.Apply();

//                // Write JPG
//                if (exportJPG)
//                {
//                    byte[] jpgBytes = exportTexture.EncodeToJPG();
//                    Gaia.Utils.WriteAllBytes(imageName + image + ".jpg", jpgBytes);
//                }

//                // Write PNG
//                if (exportPNG)
//                {
//                    byte[] pngBytes = exportTexture.EncodeToPNG();
//                    Gaia.Utils.WriteAllBytes(imageName + image + ".png", pngBytes);
//                }

//                //Lose the texture
//                DestroyImmediate(exportTexture);
//            }
//        }

//        /// <summary>
//        /// Compress / encode a multi layer map file to an image
//        /// </summary>
//        /// <param name="input">Multi layer map in format x,y,layer</param>
//        /// <param name="imageName">Output image name - image image index and extension will be added</param>
//        /// <param name="exportPNG">True if a png is wanted</param>
//        /// <param name="exportJPG">True if a jpg is wanted</param>
//        public static void CompressToMultiChannelFileImage(string imageName, HeightMap r, HeightMap g, HeightMap b, HeightMap a, TextureFormat imageStorageFormat, GaiaConstants.ImageFileType imageFileType)
//        {
//            int width = 0;
//            int height = 0;

//            if (r != null)
//            {
//                width = r.Width();
//                height = r.Depth();
//            }
//            else if (g != null)
//            {
//                width = g.Width();
//                height = g.Depth();
//            }
//            else if (b != null)
//            {
//                width = b.Width();
//                height = b.Depth();
//            }
//            else if (a != null)
//            {
//                width = a.Width();
//                height = a.Depth();
//            }

//            if (string.IsNullOrEmpty(imageName))
//            {
//                Debug.LogError("Cannot write image - no name supplied!");
//                return;
//            }

//            if (width == 0 || height == 0)
//            {
//                Debug.LogError("Cannot write image - invalid dimensions : " + width + ", " + height);
//                return;
//            }

//            Texture2D exportTexture = new Texture2D(width, height, imageStorageFormat, true, false);
//            Color pixelColor = new Color();
//            for (int x = 0; x < width; x++)
//            {
//                for (int y = 0; y < height; y++)
//                {
//                    pixelColor.r = r != null ? r[x, y] : 0f;
//                    pixelColor.g = g != null ? g[x, y] : 0f;
//                    pixelColor.b = b != null ? b[x, y] : 0f;
//                    pixelColor.a = a != null ? a[x, y] : 1f;
//                    exportTexture.SetPixel(x, y, pixelColor);
//                }
//            }
//            exportTexture.Apply();

//#if UNITY_2017_1_OR_NEWER
//            switch (imageFileType)
//            {
//                case GaiaConstants.ImageFileType.Jpg:
//                    byte[] jpgBytes = ImageConversion.EncodeToJPG(exportTexture, 100);
//                    Gaia.Utils.WriteAllBytes(imageName + ".jpg", jpgBytes);
//                    break;
//                case GaiaConstants.ImageFileType.Png:
//                    byte[] pngBytes = ImageConversion.EncodeToPNG(exportTexture);
//                    Gaia.Utils.WriteAllBytes(imageName + ".png", pngBytes);
//                    break;
//                case GaiaConstants.ImageFileType.Exr:
//                    byte[] exrBytes = ImageConversion.EncodeToEXR(exportTexture, Texture2D.EXRFlags.CompressZIP);
//                    Gaia.Utils.WriteAllBytes(imageName + ".exr", exrBytes);
//                    break;
//            }
//#else
//            switch (imageFileType)
//            {
//                case GaiaConstants.ImageFileType.Jpg:
//                    byte[] jpgBytes = exportTexture.EncodeToJPG();
//                    Gaia.Utils.WriteAllBytes(imageName + ".jpg", jpgBytes);
//                    break;
//                case GaiaConstants.ImageFileType.Png:
//                    byte[] pngBytes = exportTexture.EncodeToPNG();
//                    Gaia.Utils.WriteAllBytes(imageName + ".png", pngBytes);
//                    break;
//                case GaiaConstants.ImageFileType.Exr:
//                    byte[] exrBytes = exportTexture.EncodeToEXR(Texture2D.EXRFlags.CompressZIP);
//                    Gaia.Utils.WriteAllBytes(imageName + ".exr", exrBytes);
//                    break;
//            }
//#endif

//#if UNITY_EDITOR
//            AssetDatabase.Refresh();
//#endif

//            //Lose the texture
//            DestroyImmediate(exportTexture);
//        }


//        /// <summary>
//        /// Convert the supplied texture to an array based on grayscale value
//        /// </summary>
//        /// <param name="texture">Input texture - must be read enabled</param>
//        /// <returns>Texture as grayscale array</returns>
//        public static float[,] ConvertTextureToArray(Texture2D texture)
//        {
//            float[,] array = new float[texture.width, texture.height];
//            for (int x = 0; x < texture.width; x++)
//            {
//                for (int z = 0; z < texture.height; z++)
//                {
//                    array[x, z] = texture.GetPixel(x, z).grayscale;
//                }
//            }
//            return array;
//        }


//        /// <summary>
//        /// Decompress a single channel from the provided file into a float array.
//        /// </summary>
//        /// <param name="fileName">File to process</param>
//        /// <param name="channelR">Take data from R channel</param>
//        /// <param name="channelG">Take data from G channel</param>
//        /// <param name="channelB">Take data from B channel</param>
//        /// <param name="channelA">Take data from A channel</param>
//        /// <returns>Array of float values from the selected channel</returns>
//        public static float[,] DecompressFromSingleChannelFileImage(string fileName, int width, int height, TextureFormat imageStorageFormat = Gaia.GaiaConstants.defaultTextureFormat, bool channelR = true, bool channelG = false, bool channelB = false, bool channelA = false)
//        {
//            float[,] retArray = null;

//            if (System.IO.File.Exists(fileName))
//            {
//                byte[] bytes = Gaia.Utils.ReadAllBytes(fileName);
//                Texture2D importTexture = new Texture2D(width, height, imageStorageFormat, false);
//                importTexture.LoadImage(bytes);
//                retArray = new float[width, height];
//                for (int x = 0; x < width; x++)
//                {
//                    for (int y = 0; y < height; y++)
//                    {
//                        retArray[x, y] = importTexture.GetPixel(x, y).r;
//                    }
//                }
//                //Lose the texture
//                DestroyImmediate(importTexture);
//            }
//            else
//            {
//                Debug.LogError("Unable to find " + fileName);
//            }
//            return retArray;
//        }

//        /// <summary>
//        /// Decompress a single channel from the provided file into a float array.
//        /// </summary>
//        /// <param name="fileName">File to process</param>
//        /// <param name="channelR">Take data from R channel</param>
//        /// <param name="channelG">Take data from G channel</param>
//        /// <param name="channelB">Take data from B channel</param>
//        /// <param name="channelA">Take data from A channel</param>
//        /// <returns>Array of float values from the selected channel</returns>
//        public static float[,] DecompressFromSingleChannelTexture(Texture2D importTexture, bool channelR = true, bool channelG = false, bool channelB = false, bool channelA = false)
//        {
//            if ((importTexture == null) || importTexture.width <= 0 || importTexture.height <= 0)
//            {
//                Debug.LogError("Unable to import from texture");
//                return null;
//            }

//            float[,] retArray = new float[importTexture.width, importTexture.height];

//            if (channelR)
//            {
//                for (int x = 0; x < importTexture.width; x++)
//                {
//                    for (int y = 0; y < importTexture.height; y++)
//                    {
//                        retArray[x, y] = importTexture.GetPixel(x, y).r;
//                    }
//                }
//            }
//            else if (channelG)
//            {
//                for (int x = 0; x < importTexture.width; x++)
//                {
//                    for (int y = 0; y < importTexture.height; y++)
//                    {
//                        retArray[x, y] = importTexture.GetPixel(x, y).g;
//                    }
//                }
//            }
//            else if (channelB)
//            {
//                for (int x = 0; x < importTexture.width; x++)
//                {
//                    for (int y = 0; y < importTexture.height; y++)
//                    {
//                        retArray[x, y] = importTexture.GetPixel(x, y).b;
//                    }
//                }
//            }
//            if (channelA)
//            {
//                for (int x = 0; x < importTexture.width; x++)
//                {
//                    for (int y = 0; y < importTexture.height; y++)
//                    {
//                        retArray[x, y] = importTexture.GetPixel(x, y).a;
//                    }
//                }
//            }
//            return retArray;
//        }

//        /// <summary>
//        /// Export a texture to jpg
//        /// </summary>
//        /// <param name="fileName">File name to us - will have .jpg appended</param>
//        /// <param name="texture">Texture source</param>
//        public static void ExportJPG(string fileName, Texture2D texture)
//        {
//            byte[] bytes = texture.EncodeToJPG();
//            Gaia.Utils.WriteAllBytes(fileName + ".jpg", bytes);
//        }

//        /// <summary>
//        /// Export a texture to png
//        /// </summary>
//        /// <param name="fileName">File name to us - will have .png appended</param>
//        /// <param name="texture">Texture source</param>
//        public static void ExportPNG(string fileName, Texture2D texture)
//        {
//            byte[] bytes = texture.EncodeToPNG();
//            Gaia.Utils.WriteAllBytes(fileName + ".png", bytes);
//        }

//        /// <summary>
//        /// Will import the raw file provided - it assumes that it is in a square 16 bit PC format
//        /// </summary>
//        /// <param name="fileName">Fully qualified file name</param>
//        /// <returns>File contents or null</returns>
//        public static float[,] LoadRawFile(string fileName)
//        {
//            if (!System.IO.File.Exists(fileName))
//            {
//                Debug.LogError("Could not locate heightmap file : " + fileName);
//                return null;
//            }

//            float[,] heights = null;
//            using (FileStream fileStream = File.OpenRead(fileName))
//            {
//                using (BinaryReader br = new BinaryReader(fileStream))
//                {
//                    int mapSize = Mathf.CeilToInt(Mathf.Sqrt(fileStream.Length / 2));
//                    heights = new float[mapSize, mapSize];
//                    for (int x = 0; x < mapSize; x++)
//                    {
//                        for (int y = 0; y < mapSize; y++)
//                        {
//                            heights[x, y] = (float)(br.ReadUInt16() / 65535.0f);
//                        }
//                    }
//                }
//                fileStream.Close();
//            }

//            return heights;
//        }


//        #endregion

//        #region Mesh helpers

//        /// <summary>
//        /// Create a mesh for the heightmap
//        /// </summary>
//        /// <param name="heightmap"></param>
//        /// <param name="targetSize"></param>
//        /// <param name="resolution"></param>
//        /// <returns></returns>
//        public static Mesh CreateMesh(float[,] heightmap, Vector3 targetSize)
//        {
//            //Need to sample these to not blow unity mesh sizes
//            int width = heightmap.GetLength(0);
//            int height = heightmap.GetLength(1);
//            int targetRes = 1;

//            Vector3 targetOffset = Vector3.zero - (targetSize / 2f);
//            Vector2 uvScale = new Vector2(1.0f / (width - 1), 1.0f / (height - 1));

//            //Choose best possible target res
//            for (targetRes = 1; targetRes < 100; targetRes++)
//            {
//                if (((width / targetRes) * (height / targetRes)) < 65000)
//                {
//                    break;
//                }
//            }

//            targetSize = new Vector3(targetSize.x / (width - 1) * targetRes, targetSize.y, targetSize.z / (height - 1) * targetRes);
//            width = (width - 1) / targetRes + 1;
//            height = (height - 1) / targetRes + 1;

//            Vector3[] vertices = new Vector3[width * height];
//            Vector2[] uvs = new Vector2[width * height];
//            Vector3[] normals = new Vector3[width * height];
//            Color[] colors = new Color[width * height];
//            int[] triangles = new int[(width - 1) * (height - 1) * 6];

//            // Build vertices and UVs
//            for (int y = 0; y < height; y++)
//            {
//                for (int x = 0; x < width; x++)
//                {
//                    colors[y * width + x] = Color.black;
//                    normals[y * width + x] = Vector3.up;
//                    //vertices[y * w + x] = Vector3.Scale(targetSize, new Vector3(-y, heightmap[x * tRes, y * tRes], x)) + targetOffset;
//                    vertices[y * width + x] = Vector3.Scale(targetSize, new Vector3(x, heightmap[x * targetRes, y * targetRes], y)) + targetOffset;
//                    uvs[y * width + x] = Vector2.Scale(new Vector2(x * targetRes, y * targetRes), uvScale);
//                }
//            }

//            // Build triangle indices: 3 indices into vertex array for each triangle
//            int index = 0;
//            for (int y = 0; y < height - 1; y++)
//            {
//                for (int x = 0; x < width - 1; x++)
//                {
//                    triangles[index++] = (y * width) + x;
//                    triangles[index++] = ((y + 1) * width) + x;
//                    triangles[index++] = (y * width) + x + 1;
//                    triangles[index++] = ((y + 1) * width) + x;
//                    triangles[index++] = ((y + 1) * width) + x + 1;
//                    triangles[index++] = (y * width) + x + 1;
//                }
//            }

//            Mesh mesh = new Mesh();

//            mesh.vertices = vertices;
//            mesh.colors = colors;
//            mesh.normals = normals;
//            mesh.uv = uvs;
//            mesh.triangles = triangles;
//            mesh.RecalculateBounds();
//            mesh.RecalculateNormals();
//            return mesh;
//        }

//        /// <summary>
//        /// Return the bounds of both the object and any colliders it has
//        /// </summary>
//        /// <param name="go">Game object to check</param>
//        public static Bounds GetBounds(GameObject go)
//        {
//            Bounds bounds = new Bounds(go.transform.position, Vector3.zero);
//            foreach (Renderer r in go.GetComponentsInChildren<Renderer>())
//            {
//                bounds.Encapsulate(r.bounds);
//            }
//            foreach (Collider c in go.GetComponentsInChildren<Collider>())
//            {
//                bounds.Encapsulate(c.bounds);
//            }
//            return bounds;
//        }

//        #endregion

//        #region Direction helpers

//        /// <summary>
//        /// Rotate a direction vector left 90% around X axis
//        /// </summary>
//        /// <param name="input">Direction vector</param>
//        /// <returns>Rotated direction vector</returns>
//        Vector3 Rotate90LeftXAxis(Vector3 input)
//        {
//            return new Vector3(input.x, -input.z, input.y);
//        }

//        /// <summary>
//        /// Rotate a direction vector right 90% around X axis
//        /// </summary>
//        /// <param name="input">Direction vector</param>
//        /// <returns>Rotated direction vector</returns>
//        Vector3 Rotate90RightXAxis(Vector3 input)
//        {
//            return new Vector3(input.x, input.z, -input.y);
//        }

//        /// <summary>
//        /// Rotate a direction vector left 90% around Y axis
//        /// </summary>
//        /// <param name="input">Direction vector</param>
//        /// <returns>Rotated direction vector</returns>
//        Vector3 Rotate90LeftYAxis(Vector3 input)
//        {
//            return new Vector3(-input.z, input.y, input.x);
//        }

//        /// <summary>
//        /// Rotate a direction vector right 90% around Y axis
//        /// </summary>
//        /// <param name="input">Direction vector</param>
//        /// <returns>Rotated direction vector</returns>
//        Vector3 Rotate90RightYAxis(Vector3 input)
//        {
//            return new Vector3(input.z, input.y, -input.x);
//        }

//        /// <summary>
//        /// Rotate a direction vector left 90% around Z axis
//        /// </summary>
//        /// <param name="input">Direction vector</param>
//        /// <returns>Rotated direction vector</returns>
//        Vector3 Rotate90LeftZAxis(Vector3 input)
//        {
//            return new Vector3(input.y, -input.x, input.z);
//        }

//        /// <summary>
//        /// Rotate a direction vector right 90% around Y axis
//        /// </summary>
//        /// <param name="input">Direction vector</param>
//        /// <returns>Rotated direction vector</returns>
//        Vector3 Rotate90RightZAxis(Vector3 input)
//        {
//            return new Vector3(-input.y, input.x, input.z);
//        }

//        #endregion

//        #region Math helpers

//        /// <summary>
//        /// Return true if the values are approximately equal
//        /// </summary>
//        /// <param name="a">Parameter A</param>
//        /// <param name="b">Parameter B</param>
//        /// <param name="threshold">Threshold to test for</param>
//        /// <returns>True if approximately equal</returns>
//        public static bool Math_ApproximatelyEqual(float a, float b, float threshold)
//        {

//            if (a == b || Mathf.Abs(a - b) < threshold)
//            {
//                return true;
//            }
//            else
//            {
//                return false;
//            }
//        }

//        /// <summary>
//        /// Return true if the values are approximately equal
//        /// </summary>
//        /// <param name="a">Parameter A</param>
//        /// <param name="b">Parameter B</param>
//        /// <returns>True if approximately equal</returns>
//        public static bool Math_ApproximatelyEqual(float a, float b)
//        {
//            return Math_ApproximatelyEqual(a, b, float.Epsilon);
//        }

//        /// <summary>
//        /// Return true if the value is a power of 2
//        /// </summary>
//        /// <param name="value">Value to be checked</param>
//        /// <returns>True if a power of 2</returns>
//        public static bool Math_IsPowerOf2(int value)
//        {
//            return (value & (value - 1)) == 0;
//        }

//        /// <summary>
//        /// Returned value clamped in range of min to max
//        /// </summary>
//        /// <param name="min">Min value</param>
//        /// <param name="max">Max value</param>
//        /// <param name="value">Value to check</param>
//        /// <returns>Clamped value</returns>
//        public static float Math_Clamp(float min, float max, float value)
//        {
//            if (value < min)
//            {
//                return min;
//            }
//            if (value > max)
//            {
//                return max;
//            }
//            return value;
//        }

//        /// <summary>
//        /// Return mod of value
//        /// </summary>
//        /// <param name="value">Value</param>
//        /// <param name="mod">Mod value</param>
//        /// <returns>Mode of value</returns>
//        public static float Math_Modulo(float value, float mod)
//        {
//            return value - mod * (float)Math.Floor(value / mod);
//        }

//        /// <summary>
//        /// Return mod of value
//        /// </summary>
//        /// <param name="value">Value</param>
//        /// <param name="mod">Mod value</param>
//        /// <returns>Mode of value</returns>
//        public static int Math_Modulo(int value, int mod)
//        {
//            return (int)(value - mod * (float)Math.Floor((float)value / mod));
//        }

//        /// <summary>
//        /// Linear interpolation between two values
//        /// </summary>
//        /// <param name="value1">Value 1</param>
//        /// <param name="value2">Value 2</param>
//        /// <param name="fraction">Fraction</param>
//        /// <returns></returns>
//        public static float Math_InterpolateLinear(float value1, float value2, float fraction)
//        {
//            return value1 * (1f - fraction) + value2 * fraction;
//        }

//        /// <summary>
//        /// Smooth interpolation between two values
//        /// </summary>
//        /// <param name="value1">Value 1</param>
//        /// <param name="value2">Value 2</param>
//        /// <param name="fraction">Fraction</param>
//        /// <returns></returns>
//        public static float Math_InterpolateSmooth(float value1, float value2, float fraction)
//        {
//            if (fraction < 0.5f)
//            {
//                fraction = 2f * fraction * fraction;
//            }
//            else
//            {
//                fraction = 1f - 2f * (fraction - 1f) * (fraction - 1f);
//            }
//            return value1 * (1f - fraction) + value2 * fraction;
//        }

//        /// <summary>
//        /// Calculate the distance between two points
//        /// </summary>
//        /// <param name="x1">X1</param>
//        /// <param name="y1">Y1</param>
//        /// <param name="x2">X2</param>
//        /// <param name="y2">Y2</param>
//        /// <returns></returns>
//        public static float Math_Distance(float x1, float y1, float x2, float y2)
//        {
//            return Mathf.Sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2)));
//        }

//        public static float Math_InterpolateSmooth2(float v1, float v2, float fraction)
//        {
//            float fraction2 = fraction * fraction;
//            fraction = 3 * fraction2 - 2f * fraction * fraction2;
//            return v1 * (1f - fraction) + v2 * fraction;
//        }

//        public static float Math_InterpolateCubic(float v0, float v1, float v2, float v3, float fraction)
//        {
//            float p = (v3 - v2) - (v0 - v1);
//            float q = (v0 - v1) - p;
//            float r = v2 - v0;
//            float fraction2 = fraction * fraction;
//            return p * fraction * fraction2 + q * fraction2 + r * fraction + v1;
//        }


//        /// <summary>
//        /// Rotate the point around the pivot - used to handle rotation
//        /// </summary>
//        /// <param name="point">Point to move</param>
//        /// <param name="pivot">Pivot</param>
//        /// <param name="angle">Angle to pivot</param>
//        /// <returns>New location</returns>
//        public static Vector3 RotatePointAroundPivot(Vector3 point, Vector3 pivot, Vector3 angle)
//        {
//            Vector3 dir = point - pivot;
//            dir = Quaternion.Euler(angle) * dir;
//            point = dir + pivot;
//            return point;
//        }

//        #endregion

//        #region File helpers

//        /// <summary>
//        /// Remove any characters that could cause issues with files names from the source passed in
//        /// </summary>
//        /// <param name="sourceFileName">The source file name </param>
//        /// <returns>A destination string with rubbish removed</returns>
//        public static string FixFileName(string sourceFileName)
//        {
//            StringBuilder sb = new StringBuilder();
//            foreach (char c in sourceFileName)
//            {
//                if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
//                {
//                    sb.Append(c);
//                }
//            }
//            return sb.ToString();
//        }

//        /// <summary>
//        /// Open a file for reading
//        /// </summary>
//        /// <param name="path">File to open</param>
//        /// <returns>Filestream of the opened file</returns>
//        public static FileStream OpenRead(string path)
//        {
//            return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
//        }

//        /// <summary>
//        /// Returns the content of the file
//        /// </summary>
//        /// <param name="path">File to read</param>
//        /// <returns>Content of the file</returns>
//        public static string ReadAllText(String path)
//        {
//            if (path == null)
//                throw new ArgumentNullException("path");
//            if (path.Length == 0)
//                throw new ArgumentException("Argument_EmptyPath");
//            using (StreamReader sr = new StreamReader(path, Encoding.UTF8, true, 1024))
//                return sr.ReadToEnd();
//        }

//        /// <summary>
//        /// Write the content to a file
//        /// </summary>
//        /// <param name="path">File to write</param>
//        /// <param name="contents">Content to write</param>
//        public static void WriteAllText(String path, String contents)
//        {
//            if (path == null)
//                throw new ArgumentNullException("path");
//            if (path.Length == 0)
//                throw new ArgumentException("Argument_EmptyPath");
//            if (path == null)
//                throw new ArgumentNullException("contents");
//            if (contents.Length == 0)
//                throw new ArgumentException("Argument_EmptyContents");

//            using (StreamWriter sw = new StreamWriter(path, false, Encoding.UTF8, 1024))
//                sw.Write(contents);
//        }

//        /// <summary>
//        /// Read all bytes of the supplied file
//        /// </summary>
//        /// <param name="path">File to read</param>
//        /// <returns>Byte array of the files contents</returns>
//        public static byte[] ReadAllBytes(string path)
//        {
//#if UNITY_WEBPLAYER
//            var file = Resources.Load(path) as TextAsset;
//            if (file != null)
//            {
//                return file.bytes;
//            }
//            return new byte[0];
//#else
//            using (FileStream s = OpenRead(path))
//            {
//                long size = s.Length;
//                // limited to 2GB according to http://msdn.microsoft.com/en-us/library/system.io.file.readallbytes.aspx
//                if (size > Int32.MaxValue)
//                    throw new IOException("Reading more than 2GB with this call is not supported");

//                int pos = 0;
//                int count = (int)size;
//                byte[] result = new byte[size];
//                while (count > 0)
//                {
//                    int n = s.Read(result, pos, count);
//                    if (n == 0)
//                        throw new IOException("Unexpected end of stream");
//                    pos += n;
//                    count -= n;
//                }
//                return result;
//            }
//#endif
//        }

//        /// <summary>
//        /// Write the byte array to the supplied file
//        /// </summary>
//        /// <param name="path">File to write</param>
//        /// <param name="bytes">Byte array to write</param>
//        public static void WriteAllBytes(string path, byte[] bytes)
//        {
//            using (Stream stream = File.Create(path))
//            {
//                stream.Write(bytes, 0, bytes.Length);
//            }
//        }


//        /// <summary>
//        /// Write a scriptable object out into a new asset that can be shared
//        /// </summary>
//        /// <typeparam name="T">The scriptable object to be saved as an asset</typeparam>
//        public static void CreateAsset<T>() where T : ScriptableObject
//        {
//#if UNITY_EDITOR
//            T asset = ScriptableObject.CreateInstance<T>();

//            string path = AssetDatabase.GetAssetPath(Selection.activeObject);
//            if (path == "")
//            {
//                path = "Assets";
//            }
//            else if (Path.GetExtension(path) != "")
//            {
//                path = path.Replace(Path.GetFileName(AssetDatabase.GetAssetPath(Selection.activeObject)), "");
//            }

//            string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(path + "/New " + typeof(T).ToString() + ".asset");
//            AssetDatabase.CreateAsset(asset, assetPathAndName);
//            AssetDatabase.SaveAssets();
//            AssetDatabase.Refresh();
//            EditorUtility.FocusProjectWindow();
//            Selection.activeObject = asset;
//#endif
//        }

//        /// <summary>
//        /// Get the path of the unity object supplied
//        /// </summary>
//        /// <param name="uo"></param>
//        /// <returns></returns>
//        public static string GetAssetPath(UnityEngine.Object uo)
//        {
//            string path = "";
//#if UNITY_EDITOR
//            path = Path.Combine(Application.dataPath, AssetDatabase.GetAssetPath(uo));
//            path = path.Replace("/Assets", "");
//            path = path.Replace("\\", "/");
//#endif
//            return path;
//        }

//        /// <summary>
//        /// Wrap the scriptable object up so that it can be transferred without causing unity errors
//        /// </summary>
//        /// <param name="so"></param>
//        public static string WrapScriptableObject(ScriptableObject so)
//        {
//            string newpath = "";
//#if UNITY_EDITOR
//            string path = GetAssetPath(so);
//            if (File.Exists(path))
//            {
//                newpath = Path.ChangeExtension(path, "bytes");
//                UnityEditor.FileUtil.CopyFileOrDirectory(path, newpath);
//            }
//            else
//            {
//                Debug.LogError("There is no file at the path supplied: " + path);
//            }
//#endif
//            return newpath;
//        }


//        public static void UnwrapScriptableObject(string path, string newpath)
//        {
//#if UNITY_EDITOR
//            if (File.Exists(path))
//            {
//                if (!File.Exists(newpath))
//                {
//                    UnityEditor.FileUtil.CopyFileOrDirectory(path, newpath);
//                }
//                else
//                {
//                    Debug.LogError("There is already a file with this name at the path supplied: " + newpath);
//                }
//            }
//            else
//            {
//                Debug.LogError("There is no file at the path supplied: " + path);
//            }
//#endif
//        }

//        public static string WrapGameObjectAsPrefab(GameObject go)
//        {
//#if UNITY_EDITOR
//#if UNITY_2018_3_OR_NEWER
//            string name = go.name;
//            UnityEngine.Object prefab = PrefabUtility.SaveAsPrefabAsset(new GameObject(), "Assets/" + name + ".prefab");
//            PrefabUtility.SavePrefabAsset(go);
//            AssetDatabase.Refresh();
//            return AssetDatabase.GetAssetPath(prefab);
//#else
//            string name = go.name;
//            UnityEngine.Object prefab = PrefabUtility.CreateEmptyPrefab("Assets/" + name + ".prefab");
//            PrefabUtility.ReplacePrefab(go, prefab);
//            AssetDatabase.Refresh();
//            return AssetDatabase.GetAssetPath(prefab);
//#endif
//#else
//            return "";
//#endif
//        }


//        #endregion

//        #region Adhoc helpers

//        /// <summary>
//        /// Check to see if a game objects layer is in the layer mask supplied
//        /// </summary>
//        /// <param name="obj">Game object to check</param>
//        /// <param name="mask">Layer maskt to check</param>
//        /// <returns>True if it is in the mask</returns>
//        public static bool IsInLayerMask(GameObject obj, LayerMask mask)
//        {
//            return ((mask.value & (1 << obj.layer)) > 0);
//        }

//        /// <summary>
//        /// Check to see if the textures are the same based on the instance id
//        /// </summary>
//        /// <param name="tex1">First texture</param>
//        /// <param name="tex2">Second texture</param>
//        /// <param name="checkID">If true will do an instance ID check</param>
//        /// <returns>True if same instance id</returns>
//        public static bool IsSameTexture(Texture2D tex1, Texture2D tex2, bool checkID = false)
//        {
//            if (tex1 == null || tex2 == null)
//            {
//                return false;
//            }

//            if (checkID)
//            {
//                if (tex1.GetInstanceID() != tex2.GetInstanceID())
//                {
//                    return false;
//                }
//                return true;
//            }

//            if (tex1.name != tex2.name)
//            {
//                return false;
//            }

//            if (tex1.width != tex2.width)
//            {
//                return false;
//            }

//            if (tex1.height != tex2.height)
//            {
//                return false;
//            }

//            return true;
//        }

//        /// <summary>
//        /// Check to see if the game objects are the same based on the instance id
//        /// </summary>
//        /// <param name="go1">First game object</param>
//        /// <param name="go2">Second game object</param>
//        /// <param name="checkID">If true will do an instance ID check</param>
//        /// <returns>True if same instance id</returns>
//        public static bool IsSameGameObject(GameObject go1, GameObject go2, bool checkID = false)
//        {
//            if (go1 == null || go2 == null)
//            {
//                return false;
//            }

//            //Check the instance id
//            if (checkID)
//            {
//                if (go1.GetInstanceID() != go2.GetInstanceID())
//                {
//                    return false;
//                }
//                return true;
//            }

//            //Check the name
//            if (go1.name != go2.name)
//            {
//                return false;
//            }

//            return true;
//        }

//        /// <summary>
//        /// Get the asset path of the first thing that matches the name
//        /// </summary>
//        /// <param name="fileName">File name to search for</param>
//        /// <returns></returns>
//        public static string GetAssetPath(string fileName)
//        {
//#if UNITY_EDITOR
//            string fName = Path.GetFileNameWithoutExtension(fileName);
//            string[] assets = AssetDatabase.FindAssets(fName, null);
//            for (int idx = 0; idx < assets.Length; idx++)
//            {
//                string path = AssetDatabase.GUIDToAssetPath(assets[idx]);
//                if (Path.GetFileName(path) == fileName)
//                {
//                    return path;
//                }
//            }
//#endif
//            return "";
//        }

//        /// <summary>
//        /// Get the asset path of the first thing that matches the name
//        /// </summary>
//        /// <param name="name">Name to search for</param>
//        /// <param name="name">Type to search for</param>
//        /// <returns></returns>
//        public static string GetAssetPath(string name, string type)
//        {
//#if UNITY_EDITOR
//            string[] assets = AssetDatabase.FindAssets(name, null);
//            string[] file;
//            for (int idx = 0; idx < assets.Length; idx++)
//            {
//                string path = AssetDatabase.GUIDToAssetPath(assets[idx]);
//                //Make sure its an exact match
//                file = Path.GetFileName(path).Split('.');
//                if (file.GetLength(0) != 2)
//                {
//                    continue;
//                }
//                if (file[0] != name)
//                {
//                    continue;
//                }
//                if (file[1] != type)
//                {
//                    continue;
//                }
//                return path;
//            }
//#endif
//            return "";
//        }

//        /// <summary>
//        /// Return GaiaSettings or null;
//        /// </summary>
//        /// <returns>Gaia settings or null if not found</returns>
//        public static GaiaSettings GetGaiaSettings()
//        {
//            return GetAsset("GaiaSettings.asset", typeof(Gaia.GaiaSettings)) as Gaia.GaiaSettings;
//        }

//        /// <summary>
//        /// Returns the first asset that matches the file path and name passed. Will try
//        /// full path first, then will try just the file name.
//        /// </summary>
//        /// <param name="fileNameOrPath">File name as standalone or fully pathed</param>
//        /// <returns>Object or null if it was not found</returns>
//        public static UnityEngine.Object GetAsset(string fileNameOrPath, Type assetType)
//        {
//#if UNITY_EDITOR
//            if (!string.IsNullOrEmpty(fileNameOrPath))
//            {
//                UnityEngine.Object obj = AssetDatabase.LoadAssetAtPath(fileNameOrPath, assetType);
//                if (obj != null)
//                {
//                    return obj;
//                }
//                else
//                {
//                    string path = Utils.GetAssetPath(Path.GetFileName(fileNameOrPath));
//                    if (!string.IsNullOrEmpty(path))
//                    {
//                        return AssetDatabase.LoadAssetAtPath(path, assetType);
//                    }
//                }
//            }
//#endif
//            return null;
//        }

//        /// <summary>
//        /// Return the first prefab that exactly matches the given name from within the current project
//        /// </summary>
//        /// <param name="name">Asset to search for</param>
//        /// <returns>Returns the prefab or null</returns>
//        public static GameObject GetAssetPrefab(string name)
//        {
//#if UNITY_EDITOR
//            string path = Utils.GetAssetPath(name, "prefab");
//            if (!string.IsNullOrEmpty(path))
//            {
//                return AssetDatabase.LoadAssetAtPath<GameObject>(path);
//            }
//#endif
//            return null;
//        }

//        /// <summary>
//        /// Return the first scriptable that exactly matches the given name from within the current project
//        /// </summary>
//        /// <param name="name">Asset to search for</param>
//        /// <returns>Returns the prefab or null</returns>
//        public static ScriptableObject GetAssetScriptableObject(string name)
//        {
//#if UNITY_EDITOR
//            string path = Utils.GetAssetPath(name, "asset");
//            if (!string.IsNullOrEmpty(path))
//            {
//                return AssetDatabase.LoadAssetAtPath<ScriptableObject>(path);
//            }
//#endif
//            return null;
//        }

//        /// <summary>
//        /// Return the first texture that exactly matches the given name from within the current project
//        /// </summary>
//        /// <param name="name">Asset to search for</param>
//        /// <returns>Returns the texture or null</returns>
//        public static Texture2D GetAssetTexture2D(string name)
//        {
//#if UNITY_EDITOR
//            string[] assets = AssetDatabase.FindAssets(name, null);
//            for (int idx = 0; idx < assets.Length; idx++)
//            {
//                string path = AssetDatabase.GUIDToAssetPath(assets[idx]);
//                if (path.Contains(".jpg") || path.Contains(".psd") || path.Contains(".png"))
//                {
//                    //Make sure its an exact match
//                    string filename = Path.GetFileNameWithoutExtension(path);
//                    if (filename == name)
//                    {
//                        return AssetDatabase.LoadAssetAtPath<Texture2D>(path);
//                    }
//                }
//            }
//#endif
//            return null;
//        }

//        /// <summary>
//        /// Get the specified type if it exists
//        /// </summary>
//        /// <param name="TypeName">Name of the type to load</param>
//        /// <returns>Selected type or null</returns>
//        public static Type GetType(string TypeName)
//        {

//            // Try Type.GetType() first. This will work with types defined
//            // by the Mono runtime, in the same assembly as the caller, etc.
//            var type = Type.GetType(TypeName);

//            // If it worked, then we're done here
//            if (type != null)
//                return type;

//            // If the TypeName is a full name, then we can try loading the defining assembly directly
//            if (TypeName.Contains("."))
//            {
//                // Get the name of the assembly (Assumption is that we are using 
//                // fully-qualified type names)
//                var assemblyName = TypeName.Substring(0, TypeName.IndexOf('.'));

//                // Attempt to load the indicated Assembly
//                try
//                {
//                    var assembly = Assembly.Load(assemblyName);
//                    if (assembly == null)
//                        return null;

//                    // Ask that assembly to return the proper Type
//                    type = assembly.GetType(TypeName);
//                    if (type != null)
//                        return type;
//                }
//                catch (Exception)
//                {
//                    //Debug.Log("Unable to load assemmbly : " + ex.Message);
//                }
//            }

//            // If we still haven't found the proper type, we can enumerate all of the 
//            // loaded assemblies and see if any of them define the type
//            var currentAssembly = Assembly.GetCallingAssembly();
//            {
//                // Load the referenced assembly
//                if (currentAssembly != null)
//                {
//                    // See if that assembly defines the named type
//                    type = currentAssembly.GetType(TypeName);
//                    if (type != null)
//                        return type;
//                }

//            }

//            //All loaded assemblies
//            Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
//            for (int asyIdx = 0; asyIdx < assemblies.GetLength(0); asyIdx++)
//            {
//                type = assemblies[asyIdx].GetType(TypeName);
//                if (type != null)
//                {
//                    return type;
//                }
//            }

//            var referencedAssemblies = currentAssembly.GetReferencedAssemblies();
//            foreach (var assemblyName in referencedAssemblies)
//            {
//                // Load the referenced assembly
//                var assembly = Assembly.Load(assemblyName);
//                if (assembly != null)
//                {
//                    // See if that assembly defines the named type
//                    type = assembly.GetType(TypeName);
//                    if (type != null)
//                        return type;
//                }
//            }

//            // The type just couldn't be found...
//            return null;
//        }

//        #endregion

//    }
//}