public void Export() { TEXPreference.Initialize(); var path = TEXPreference.main.MainFolderPath + "Core/Editor/Resources/" + id + ".json"; var json = JsonUtility.ToJson(this); Directory.CreateDirectory(path); File.WriteAllText(path, json); Debug.Log("Successfully written to " + path); }
static void LoadPrimaryDefinitionSubset(TEXPreference pref, List <TexFont> fontList, string folderPath, string typeStr, TexFontType typeEnum, int mode) { if (!AssetDatabase.IsValidFolder(folderPath)) { return; } string[] customF = AssetDatabase.FindAssets(typeStr, new string[] { folderPath }); for (int i = 0; i < customF.Length; i++) { if (fontList.Count >= 31) { Debug.LogWarning("Font/Sprite database count are beyond 31, ignoring any assets after " + fontList[fontList.Count - 1].id); break; } string realPath = AssetDatabase.GUIDToAssetPath(customF[i]); string id = Path.GetFileNameWithoutExtension(realPath).ToLower(); UpdateProgress(mode, id, i, customF.Length); if (!isNameValid(id)) { // We show this for information purpose, since *-Regular or *_ is very common mistake // We are not showing this for frequent update, since this behavior is 'intended' for giving an alternative styling if (id.Contains("-Regular") || id.Substring(id.Length - 1) == "_") { Debug.LogWarning("File " + id + " is ignored since it has invalid character in it's name"); } continue; } var metaPath = pref.MainFolderPath + resourceFontMetaPath + id + ".asset"; var metadata = AssetDatabase.LoadAssetAtPath <TexFont>(metaPath); if (!metadata) { metadata = ScriptableObject.CreateInstance <TexFont>(); AssetDatabase.CreateAsset(metadata, metaPath); metadata.importCatalog = TexCharPresets.legacyChars; } metadata.id = id; metadata.ClearAssetData(); metadata.index = fontList.Count; metadata.type = typeEnum; metadata.GrabAssetData(realPath); #if TEXDRAW_TMP string sdfPath = pref.MainFolderPath + "/Fonts/TMPro/" + id + ".asset"; if (typeEnum == TexFontType.Font && AssetDatabase.LoadAssetAtPath <TMPro.TMP_FontAsset>(sdfPath)) { metadata.type = TexFontType.Font_SDF; metadata.GrabAssetData(sdfPath); } #endif metadata.Populate(false); fontList.Add(metadata); } }
static public void Initialize() { #if UNITY_EDITOR if (!main) { //Get the Preference string[] targetData = AssetDatabase.FindAssets("t:TEXPreference"); if (targetData.Length > 0) { var path = AssetDatabase.GUIDToAssetPath(targetData[0]); main = AssetDatabase.LoadAssetAtPath <TEXPreference>(path); main.MainFolderPath = Path.GetDirectoryName(path); // TEXDraw preference now put into resources files after 3.0 if (main.MainFolderPath.Contains("Resources")) { main.MainFolderPath = Path.GetDirectoryName(main.MainFolderPath); } if (targetData.Length > 1) { Debug.LogWarning("You have more than one TEXDraw preference, ensure that only one Preference exist in your Project"); } } else { //Create New One main = CreateInstance <TEXPreference>(); if (AssetDatabase.IsValidFolder(DefaultTexFolder)) { AssetDatabase.CreateAsset(main, DefaultTexFolder + "/Resources/TEXDrawPreference.asset"); main.FirstInitialize(DefaultTexFolder); } else { //Find alternative path to the TEXPreference, that's it: Parent path of TEXPreference script. string AlternativePath = AssetDatabase.GetAssetPath(MonoScript.FromScriptableObject(main)); AlternativePath = Directory.GetParent(AlternativePath).Parent.FullName; AssetDatabase.CreateAsset(main, AlternativePath + "/Resources/TEXDrawPreference.asset"); main.FirstInitialize(AlternativePath); } } } #else if (!main) { // The only thing that we can found is in the Resource folder main = (TEXPreference)Resources.Load("TEXDrawPreference"); } #endif // also init the neighborhood TEXConfiguration.Initialize(); }
public static void ReadLegacyPreferences(TEXPreference pref, string XMLFontDef, string XMLConfigDef) { //Clean up first pref.glueTable = new int[100]; // pref.defaultTypefaces = new TexTypeFaceDictionary(); //Look up all font & sprites XmlDocument doc = new XmlDocument(); XmlNode cNode, configNodes; List <TEXConfigurationMember> configs = new List <TEXConfigurationMember>(); doc.LoadXml(XMLFontDef); //Load all configurations. (the thing with bunch of sliders) configNodes = doc.SelectSingleNode("/TexFont/Params"); for (int i = 0; i < configNodes.ChildNodes.Count; i++) { cNode = configNodes.ChildNodes[i]; configs.Add(new TEXConfigurationMember(cNode.Attributes["name"].Value, cNode.Attributes["desc"].Value, float.Parse(cNode.Attributes["value"].Value), float.Parse(cNode.Attributes["min"].Value), float.Parse(cNode.Attributes["max"].Value))); } //pref.configs = configs.ToArray(); doc.LoadXml(XMLConfigDef); // No longer importing config via XML /*XmlNode Params = doc.SelectSingleNode("/TEXConfigurations/Parameters"); * for (int i = 0; i < Params.ChildNodes.Count; i++) { * var att = Params.ChildNodes[i].Attributes[0]; * pref.preferences[att.Name] = float.Parse(att.Value); * pref.configs.First(x => x.name == att.Name).value = pref.preferences[att.Name]; * }*/ /* XmlNode Typefaces = doc.SelectSingleNode("/TEXConfigurations/DefaultTypefaces"); * foreach (XmlNode node in Typefaces.ChildNodes) { * pref.defaultTypefaces.Add((TexCharKind)int.Parse(node.Attributes["code"].Value), int.Parse(node.Attributes["fontId"].Value)); * }*/ XmlNode GlueTables = doc.SelectSingleNode("/TexConfigurations/GlueTable"); foreach (XmlNode node in GlueTables.ChildNodes) { pref.glueTable[int.Parse(node.Attributes["leftType"].Value) * 10 + int.Parse(node.Attributes["rightType"].Value)] = int.Parse(node.Attributes["glueSize"].Value); } pref.PushToDictionaries(); }
public static void ReadFromResources(TEXPreference pref) { var fontList = new List <TexAsset>(); if (!AssetDatabase.IsValidFolder(pref.MainFolderPath + "/Resources/TexFontMetaData")) { AssetDatabase.CreateFolder(pref.MainFolderPath + "/Resources", "TexFontMetaData"); } LoadPrimaryDefinitionSubset <TexFont>(pref, fontList, pref.MainFolderPath + "/Fonts/Math", "t:Font", TexAssetType.Font, 0); pref.header_mathCount = fontList.Count; LoadPrimaryDefinitionSubset <TexFont>(pref, fontList, pref.MainFolderPath + "/Fonts/User", "t:Font", TexAssetType.Font, 1); pref.header_userCount = fontList.Count; LoadPrimaryDefinitionSubset <TexSprite>(pref, fontList, pref.MainFolderPath + "/Fonts/Sprites", "t:Sprite", TexAssetType.Sprite, 2); EditorUtility.DisplayProgressBar("Reloading", "Preparing Stuff...", .93f); pref.fonts = fontList.ToArray(); }
static void LoadPrimaryDefinitionSubset <T>(TEXPreference pref, List <TexAsset> fontList, string folderPath, string typeStr, TexAssetType typeEnum, int mode) where T : TexAsset { if (!AssetDatabase.IsValidFolder(folderPath)) { return; } string[] customF = AssetDatabase.FindAssets(typeStr, new string[] { folderPath }); for (int i = 0; i < customF.Length; i++) { if (fontList.Count >= 31) { Debug.LogWarning("Font/Sprite database count are beyond 31, ignoring any assets after " + fontList[fontList.Count - 1].id); break; } string realPath = AssetDatabase.GUIDToAssetPath(customF[i]); string id = Path.GetFileNameWithoutExtension(realPath).ToLower(); if (fontList.Any((x) => x.id == id)) { continue; } if (!isNameValid(id)) { // We show this for information purpose, since *-Regular or *_ is very common mistake // We are not showing this for frequent update, since this behavior is 'intended' for giving an alternative styling if (id.Contains("-Regular") || id.Substring(id.Length - 1) == "_") { Debug.LogWarning("File " + id + " is ignored since it has invalid character(s) in its name"); } continue; } UpdateProgress(mode, id, i, customF.Length); string json = null; var metaPath = pref.MainFolderPath + resourceFontMetaPath + id + ".asset"; TexAsset metadata = AssetDatabase.LoadAssetAtPath <T>(metaPath); #if TEXDRAW_TMP string sdfPath = pref.MainFolderPath + "/Fonts/TMPro/" + id + ".asset"; if (typeEnum == TexAssetType.Font && File.Exists(sdfPath)) { metadata = AssetDatabase.LoadAssetAtPath <TexFontSigned>(metaPath); if (!metadata) { metadata = CreateAndRecover <TexFontSigned>(metaPath); ((TexFontSigned)metadata).rawpath = realPath; AssetDatabase.CreateAsset(metadata, metaPath); } realPath = sdfPath; } #endif if (!metadata) { metadata = CreateAndRecover <T>(metaPath); AssetDatabase.CreateAsset(metadata, metaPath); } else { json = JsonUtility.ToJson(metadata); } metadata.id = id; metadata.index = fontList.Count; metadata.ImportAsset(realPath); metadata.ImportDictionary(); if (json != JsonUtility.ToJson(metadata)) { // this is necessary to avoid messing with Git version control EditorUtility.SetDirty(metadata); } fontList.Add(metadata); } }
public static void ReadLegacyXMLSymbols(TEXPreference pref, bool isMath, string XMLData) { XmlDocument doc = new XmlDocument(); doc.LoadXml(XMLData); TexChar c; XmlNode SyncMap = doc.SelectSingleNode("/TexSymbols/FontIDs"); List <int> sMap = new List <int>(); for (int i = 0; i < SyncMap.ChildNodes.Count; i++) { XmlAttributeCollection attr = SyncMap.ChildNodes[i].Attributes; int idx = pref.GetFontIndexByID(attr["id"].Value); var max = int.Parse(attr["index"].Value); if (max > sMap.Count) { for (int j = 0; j < max; j++) { sMap.Add(j); } } sMap.Add(idx); if (idx >= 0) { var font = pref.fontData[idx]; bool catalogChange = false; for (int j = 0; j < attr.Count; j++) { switch (attr[j].Name) { case "xLength": font.sprite_xLength = int.Parse(attr[j].Value); break; case "yLength": font.sprite_yLength = int.Parse(attr[j].Value); break; case "scale": font.sprite_scale = float.Parse(attr[j].Value); break; case "lineOffset": font.sprite_lineOffset = float.Parse(attr[j].Value); break; case "alphaOnly": font.sprite_alphaOnly = int.Parse(attr[j].Value) > 0; break; case "importCatalog": if (catalogChange |= !string.IsNullOrEmpty(attr[j].Value)) { font.importCatalog = attr[j].Value; } break; } } font.importCatalog = font.importCatalog == null ? TexCharPresets.legacyChars : font.importCatalog; font.Populate(false); } } XmlNode SymbolMap = doc.SelectSingleNode("/TexSymbols/SymbolMap"); foreach (XmlNode node in SymbolMap.ChildNodes) { int hash = int.Parse(node.Attributes["hash"].Value); if (!isMath && hash >> 8 < pref.header_mathCount) { continue; } hash = SyncHash(hash, sMap); if (hash >= 0) { c = pref.GetChar(hash); var attr = node.Attributes; for (int j = 0; j < attr.Count; j++) { switch (attr[j].Name) { case "name": c.symbolName = attr[j].Value; break; case "nameAlt": c.symbolAlt = attr[j].Value; break; case "typeId": c.type = (CharType)int.Parse(attr[j].Value); break; } } // pref.symbolData.Add(c.symbolName, c.ToHash()); // if (!string.IsNullOrEmpty(c.symbolAlt)) // pref.symbolData.Add(c.symbolAlt, c.ToHash()); } } XmlNode LargerMap = doc.SelectSingleNode("/TexSymbols/LargerMap"); foreach (XmlNode node in LargerMap.ChildNodes) { int hash = int.Parse(node.Attributes["hash"].Value); if (!isMath && hash >> 8 < pref.header_mathCount) { continue; } hash = SyncHash(hash, sMap); if (hash >= 0) { c = pref.GetChar(hash); c.nextLarger = pref.GetChar(SyncHash(int.Parse(node.Attributes["targetHash"].Value), sMap)); } } XmlNode ExtensionMap = doc.SelectSingleNode("/TexSymbols/ExtensionMap"); foreach (XmlNode node in ExtensionMap.ChildNodes) { int hash = int.Parse(node.Attributes["hash"].Value); if (!isMath && hash >> 8 < pref.header_mathCount) { continue; } hash = SyncHash(hash, sMap); if (hash >= 0) { c = pref.GetChar(hash); c.extensionExist = true; var attr = node.Attributes; for (int j = 0; j < attr.Count; j++) { switch (attr[j].Name) { case "top": c.extentTopHash = SyncHash(int.Parse(attr[j].Value), sMap); break; case "middle": c.extentMiddleHash = SyncHash(int.Parse(attr[j].Value), sMap); break; case "bottom": c.extentBottomHash = SyncHash(int.Parse(attr[j].Value), sMap); break; case "repeat": c.extentRepeatHash = SyncHash(int.Parse(attr[j].Value), sMap); break; case "horizontal": c.extensionHorizontal = int.Parse(attr[j].Value) > 0; break; } } } } XmlNode CharMap = doc.SelectSingleNode("/TexSymbols/CharMap"); foreach (XmlNode node in CharMap.ChildNodes) { int hash = int.Parse(node.Attributes["hash"].Value); if (!isMath && hash >> 8 < pref.header_mathCount) { continue; } hash = SyncHash(hash, sMap); if (hash >= 0) { c = pref.GetChar(hash); c.characterMap = int.Parse(node.Attributes["char"].Value); // if (c.characterMap > 0) // pref.charMapData.Add(TexChar.possibleCharMaps[c.characterMap], c.ToHash()); } } pref.PushToDictionaries(); }