public static APFont GetAPFontFromAssetGuid(string guid)
{
TrueTypeFontImporter importer = GetAssetImporterFromAssetGuid <TrueTypeFontImporter>(guid);
if (importer == null)
{
return(null);
}
string path = AssetDatabase.GUIDToAssetPath(guid);
APFont apFont = new APFont();
apFont.Icon = GetIconID(path);
apFont.Name = Utility.GetFileName(path);
apFont.Character = importer.fontTextureCase;
apFont.RenderingMode = importer.fontRenderingMode;
apFont.Path = path;
apFont.Hash = Utility.GetFileMd5(path);
apFont.FileSize = Utility.GetFileSize(path);
apFont.FontNames = importer.fontTTFName;
apFont.Id = guid;
return(apFont);
}
private bool IsEqual(TrueTypeFontImporter target, TrueTypeFontImporter reference)
{
if (target.ascentCalculationMode != reference.ascentCalculationMode)
{
return(false);
}
if (target.characterPadding != reference.characterPadding)
{
return(false);
}
if (target.characterSpacing != reference.characterSpacing)
{
return(false);
}
if (target.customCharacters != reference.customCharacters)
{
return(false);
}
if (target.fontNames.Length != reference.fontNames.Length)
{
return(false);
}
for (int i = 0; i < target.fontNames.Length; ++i)
{
if (target.fontNames [i] != reference.fontNames [i])
{
return(false);
}
}
if (target.fontReferences.Length != reference.fontReferences.Length)
{
return(false);
}
for (int i = 0; i < target.fontNames.Length; ++i)
{
if (!target.fontReferences [i].Equals(reference.fontReferences [i]))
{
return(false);
}
}
if (target.fontRenderingMode != reference.fontRenderingMode)
{
return(false);
}
if (target.fontSize != reference.fontSize)
{
return(false);
}
if (target.fontTextureCase != reference.fontTextureCase)
{
return(false);
}
// if (target.fontTTFName != reference.fontTTFName) {
// return false;
// }
#if UNITY_2018_1_OR_NEWER
if (target.shouldRoundAdvanceValue != reference.shouldRoundAdvanceValue)
{
return(false);
}
#endif
return(true);
}
/// <summary>
/// Create Soft Font, Soft Font Material, Soft Font Texture from SoftEffect Settings,
/// </summary>
/// <param name="font"></param>
private void CreateSoftFont(Font font, bool createNewFolder) // http://answers.unity3d.com/questions/485695/truetypefontimportergenerateeditablefont-does-not.html
{
// Mkey.Utils.Measure("<<<<<<<<<<<<Summary CreateSoftFontTexture>>>>>>>>>>>>>>>: ", () => {
gpuWorker = new GPUWorker(eShader);
string dirPath = Path.GetDirectoryName(AssetDatabase.GetAssetPath(font));
//1) load source font asset
string path = AssetDatabase.GetAssetPath(font);
Font f = font;
if (SoftEffects.debuglog)
{
Debug.Log("Path to Source font: " + path);
}
font = (Font)AssetDatabase.LoadMainAssetAtPath(path);
if (f && !font)
{
Debug.LogError("Can't use embedded font : " + f.name);
return;
}
//2) Remove old Editable font
if (SoftFont && !createNewFolder)
{
if (SoftEffects.debuglog)
{
Debug.Log("EditableFont folder: " + Path.GetDirectoryName(AssetDatabase.GetAssetPath(SoftFont)));
}
if (SoftEffects.debuglog)
{
Debug.Log("Remove old EditableFont: " + SoftFont.name);
}
if (SoftFont.material)
{
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(SoftFont.material.mainTexture));
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(SoftFont.material));
}
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(SoftFont));
AssetDatabase.Refresh();
}
//3) reimport source font as editable
TrueTypeFontImporter fontImporter = AssetImporter.GetAtPath(path) as TrueTypeFontImporter;
//source settings
int sourceSize = fontImporter.fontSize;
int sourcePadding = fontImporter.characterPadding;
int sourceSpacing = fontImporter.characterSpacing;
FontTextureCase sourceCase = fontImporter.fontTextureCase;
string chars = fontImporter.customCharacters;
fontImporter.fontSize = GetComponent <Text>().fontSize;
fontImporter.characterPadding = Mathf.Clamp(faceOptions.extPixels, 1, 100);
fontImporter.characterSpacing = 0;
// Mkey.Utils.Measure("Summary PreCreateFontTexture: ", () => {
// Mkey.Utils.Measure("Reimport font: ", () => {
if (SoftFontTextureCase == FontTextureCase.CustomSet)
{
if (customCharacters.Length == 0 || customCharacters == " ")
{
Debug.LogError("Custom Characters string is empty. Set default string.");
customCharacters = GetComponent <Text>().text;
if (customCharacters.Length == 0 || customCharacters == " ")
{
customCharacters = "New txt";
}
}
fontImporter.customCharacters = customCharacters;
}
else if (SoftFontTextureCase == FontTextureCase.Dynamic)
{
SoftFontTextureCase = FontTextureCase.ASCII;
}
fontImporter.fontTextureCase = SoftFontTextureCase;
fontImporter.SaveAndReimport();
// });
// Mkey.Utils.Measure("GenerateEditableFont: ", () => {
SoftFont = fontImporter.GenerateEditableFont(path);
// });
int maxSize = Mathf.Max(font.material.mainTexture.width, font.material.mainTexture.height);
// Mkey.Utils.Measure("RenameAsset: ", () => {
AssetDatabase.RenameAsset(AssetDatabase.GetAssetPath(SoftFont), font.name + key);
AssetDatabase.RenameAsset(AssetDatabase.GetAssetPath(SoftFont.material), font.name + key + "_edit");
AssetDatabase.RenameAsset(AssetDatabase.GetAssetPath(SoftFont.material.mainTexture), font.name + key);
AssetDatabase.Refresh();
// });
Shader softShader = Shader.Find("SoftEffects/SoftEditShader");
SoftFont.material.shader = softShader;
SoftMaterial = SoftFont.material;
if (SoftEffects.debuglog)
{
Debug.Log("Editable texture size: " + SoftFont.material.mainTexture.width + " x " + SoftFont.material.mainTexture.height);
}
// Mkey.Utils.Measure("Reimport texture: ", () => {
//5) Reimport EditableFont texture as readable
SoftFont.material.mainTexture.ReimportTexture(true, maxSize);
if (SoftEffects.debuglog)
{
Debug.Log("Editable texture size after reimport: " + SoftFont.material.mainTexture.width + " x " + SoftFont.material.mainTexture.height);
}
// });
// });
//5) Generate new Texture for editable font
// Mkey.Utils.Measure("faceOptions.RenderFontTexture: ", () => {
faceOptions.RenderFontTexture(gpuWorker, SoftFont, cb);
//});
// Mkey.Utils.Measure("AfterCreateFontTexture: ", () => {
faceOptions.CreateTextureFromRender_ARGB32(true, dirPath + "/" + font.name + key + "_edit" + ".png");
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(SoftFont.material.mainTexture)); // Remove old texture
Texture2D t = (Texture2D)AssetDatabase.LoadMainAssetAtPath(dirPath + "/" + font.name + key + "_edit" + ".png"); // load new texture asset
t.ReimportTexture(true);
//6 extend verts and uvs
// SoftFont.ExtendVertsAndUvs(faceOptions.extPixels);
faceOptions.mainTexture = t;
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
// 9) remove editable font to unique folder
string targetFolder = AssetDatabase.GUIDToAssetPath(FolderGUID);
string fontPath = AssetDatabase.GetAssetPath(SoftFont);
string materialPath = AssetDatabase.GetAssetPath(SoftFont.material);
string texturePath = AssetDatabase.GetAssetPath(t);
if (SoftEffects.debuglog)
{
Debug.Log("Move file: " + fontPath + " to : " + targetFolder + "/" + Path.GetFileName(fontPath));
}
AssetDatabase.MoveAsset(fontPath, targetFolder + "/" + Path.GetFileName(fontPath));// FileUtil.MoveFileOrDirectory(fontPath, targetFolder + "/"+ Path.GetFileName(fontPath));
AssetDatabase.MoveAsset(materialPath, targetFolder + "/" + Path.GetFileName(materialPath));
AssetDatabase.MoveAsset(texturePath, targetFolder + "/" + Path.GetFileName(texturePath));
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
faceOptions.IsCombinedDirty = true;
RenderNewTextures(gpuWorker, true);
/**/
EditorGUIUtility.PingObject(SoftFont);
EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
//revert source settings
fontImporter = AssetImporter.GetAtPath(path) as TrueTypeFontImporter;
fontImporter.fontSize = sourceSize;
fontImporter.fontTextureCase = sourceCase;
// fontImporter.characterPadding = sourcePadding;
// fontImporter.characterSpacing = sourceSpacing;
fontImporter.characterPadding = 1;
fontImporter.characterSpacing = 0;
if (sourceCase == FontTextureCase.CustomSet)
{
fontImporter.customCharacters = chars;
}
fontImporter.SaveAndReimport();
// });
// });
}
public static string PickAllCharsRangeFromFont(Font p_font)
{
string v_charsRange = "";
if (p_font != null)
{
TrueTypeFontImporter v_fontReimporter = null;
//A GLITCH: Unity's Font.CharacterInfo doesn't work
//properly on dynamic mode, we need to change it to Unicode first
if (p_font.dynamic)
{
var assetPath = AssetDatabase.GetAssetPath(p_font);
v_fontReimporter = (TrueTypeFontImporter)AssetImporter.GetAtPath(assetPath);
v_fontReimporter.fontTextureCase = FontTextureCase.Unicode;
v_fontReimporter.SaveAndReimport();
}
//Only Non-Dynamic Fonts define the characterInfo array
Vector2Int v_minMaxRange = new Vector2Int(-1, -1);
for (int i = 0; i < p_font.characterInfo.Length; i++)
{
var v_charInfo = p_font.characterInfo[i];
var v_apply = true;
if (v_minMaxRange.x < 0 || v_minMaxRange.y < 0)
{
v_apply = false;
v_minMaxRange = new Vector2Int(v_charInfo.index, v_charInfo.index);
}
else if (v_charInfo.index == v_minMaxRange.y + 1)
{
v_apply = false;
v_minMaxRange.y = v_charInfo.index;
}
if (v_apply || i == p_font.characterInfo.Length - 1)
{
if (!string.IsNullOrEmpty(v_charsRange))
{
v_charsRange += "\n,";
}
v_charsRange += v_minMaxRange.x + "-" + v_minMaxRange.y;
if (i == p_font.characterInfo.Length - 1)
{
if (v_charInfo.index >= 0 && (v_charInfo.index < v_minMaxRange.x || v_charInfo.index > v_minMaxRange.y))
{
v_charsRange += "\n," + v_charInfo.index + "-" + v_charInfo.index;
}
}
else
{
v_minMaxRange = new Vector2Int(v_charInfo.index, v_charInfo.index);
}
}
}
// Change back to dynamic font
if (v_fontReimporter != null)
{
v_fontReimporter.fontTextureCase = FontTextureCase.Dynamic;
v_fontReimporter.SaveAndReimport();
}
}
return(v_charsRange);
}
private void GenerateAtlas()
{
TrueTypeFontImporter fontImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(FontToConvert)) as TrueTypeFontImporter;
if (fontImporter == null)
{
Debug.LogError("Could not import mesh asset! Builtin Unity fonts like Arial don't work unless you put them in the project directory!");
}
fontImporter.characterSpacing = 4;
fontImporter.characterPadding = 2;
fontImporter.SaveAndReimport();
int tilemapsize = TileSize * 16;
Texture2D newAtlas = new Texture2D(tilemapsize, tilemapsize, TextureFormat.ARGB32, false, true);
for (int x = 0; x < newAtlas.width; ++x)
{
for (int y = 0; y < newAtlas.height; ++y)
{
newAtlas.SetPixel(x, y, Color.black);
}
}
for (int i = 1; i < 256; i++)
{
char c = (char)i;
if (!IncludeAllGlyphs && !FontToConvert.HasCharacter(c))
{
continue;
}
EditorUtility.DisplayProgressBar("Generating MSDF Tileset...", string.Format("Glyph {0}/256", i + 1), i / 255.0f);
Texture2D currentGlyphTex = GenerateGlyphTexture(i, TileSize - Padding, TileSize - Padding);
if (currentGlyphTex == null)
{
continue;
}
int tileindex = i - (OffByOne ? 1 : 0);
int rowoffset = TileSize * (tileindex / 16) + Padding / 2;
int columnoffset = TileSize * (tileindex % 16) + Padding / 2;
for (int y = 0; y < currentGlyphTex.height; ++y)
{
for (int x = 0; x < currentGlyphTex.width; ++x)
{
Color glyphCol = currentGlyphTex.GetPixel(x, currentGlyphTex.height - 1 - y);
newAtlas.SetPixel(columnoffset + x, tilemapsize - 1 - (rowoffset + y), glyphCol);
}
}
}
newAtlas.Apply(false);
if (UseTextureCompression)
{
EditorUtility.DisplayProgressBar("Generating MSDF Tileset...", "Compressing Tileset...", 1f);
EditorUtility.CompressTexture(newAtlas, TextureFormat.BC7, UnityEditor.TextureCompressionQuality.Best);
}
EditorUtility.ClearProgressBar();
string savePath = getResultPath() + ".asset";
AssetDatabase.CreateAsset(newAtlas, savePath);
/*Texture2D outtex = AssetDatabase.LoadAssetAtPath<Texture2D>(savePath);
* if (outtex != null)
* {
* outtex = newAtlas;
* AssetDatabase.ForceReserializeAssets();
* }
* else
* {
* AssetDatabase.CreateAsset(newAtlas, savePath);
* }*/
EditorGUIUtility.PingObject(newAtlas);
}
private void GenerateAtlas()
{
TrueTypeFontImporter fontImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(FontToConvert)) as TrueTypeFontImporter;
if (fontImporter == null)
{
Debug.LogError("Could not import mesh asset! Builtin Unity fonts like Arial don't work unless you put them in the project directory!");
}
fontImporter.characterSpacing = 4;
fontImporter.characterPadding = 2;
fontImporter.SaveAndReimport();
// Hacky method to get the generated font texture so that we can figure out where to put pixels
Texture2D fontTexture = AssetDatabase.LoadAssetAtPath <Texture2D>(AssetDatabase.GetAssetPath(FontToConvert));
Dictionary <CharacterInfo, Texture2D> characterGlyphMap = new Dictionary <CharacterInfo, Texture2D>();
CharacterInfo[] characterInfos = FontToConvert.characterInfo;
Texture2D newAtlas = new Texture2D(fontTexture.width, fontTexture.height, TextureFormat.ARGB32, false, true);
for (int x = 0; x < newAtlas.width; ++x)
{
for (int y = 0; y < newAtlas.height; ++y)
{
newAtlas.SetPixel(x, y, Color.black);
}
}
int charCount = 0;
foreach (CharacterInfo info in characterInfos)
{
charCount++;
EditorUtility.DisplayProgressBar("Generating MSDF Atlas...", string.Format("Glyph {0}/{1}", charCount, characterInfos.Length), charCount / (float)characterInfos.Length);
Texture2D currentGlyphTex = GenerateGlyphTexture(info.index, info.glyphWidth, info.glyphHeight);
if (currentGlyphTex == null)
{
continue;
}
for (int x = 0; x < currentGlyphTex.width; ++x)
{
for (int y = 0; y < currentGlyphTex.height; ++y)
{
float progressX = (x) / (float)(currentGlyphTex.width);
float progressY = (y) / (float)(currentGlyphTex.height);
float uvProgressX = Mathf.Lerp(info.uvTopLeft.x, info.uvTopRight.x, progressX) * fontTexture.width;
float uvProgressY = Mathf.Lerp(info.uvBottomLeft.y, info.uvTopLeft.y, progressY) * fontTexture.height;
// flipped iS dEpRiCaTeD uSiNg ThE Uv WiLl bE CoNSiStEnT. It's not consistent in my limited experience.
// Maybe I'm doing something wrong, but I don't want to try fighting with Unity trying to fix an issue that may be on their end.. I've wasted enough time on trusting Unity to do things correctly.
#pragma warning disable 0618
if (info.flipped)
#pragma warning restore 0618
{
uvProgressY = Mathf.Lerp(info.uvTopLeft.y, info.uvTopRight.y, progressX) * fontTexture.height;
uvProgressX = Mathf.Lerp(info.uvBottomLeft.x, info.uvTopLeft.x, progressY) * fontTexture.width;
}
int targetX = Mathf.RoundToInt(uvProgressX);
int targetY = Mathf.RoundToInt(uvProgressY) - 1;
Color glyphCol = currentGlyphTex.GetPixel(x, y);
newAtlas.SetPixel(targetX, targetY, glyphCol);
}
}
}
newAtlas.Apply(false);
if (UseTextureCompression)
{
EditorUtility.DisplayProgressBar("Generating MSDF Atlas...", "Compressing Atlas...", 1f);
EditorUtility.CompressTexture(newAtlas, TextureFormat.BC7, UnityEditor.TextureCompressionQuality.Best);
}
EditorUtility.ClearProgressBar();
string fontPath = AssetDatabase.GetAssetPath(FontToConvert);
string savePath = Path.Combine(Path.GetDirectoryName(fontPath), Path.GetFileNameWithoutExtension(fontPath) + "_msdfAtlas.asset");
AssetDatabase.CreateAsset(newAtlas, savePath);
EditorGUIUtility.PingObject(newAtlas);
}
private bool IsEqual(TrueTypeFontImporter target, TrueTypeFontImporter reference)
{
return(true);
}
//[MenuItem("Assets/Create Editable Copy Font")]
static void CreateFont()
{
var txts = UnityEngine.Object.FindObjectsOfType(typeof(Text));
return;
TextAsset sourceTextAsset = null;
try
{
sourceTextAsset = (TextAsset)Selection.activeObject;
} catch (InvalidCastException e)
{
Debug.Log("Selected Object is not a txt file: " + Environment.NewLine + e.Message);
}
if (sourceTextAsset == null)
{
EditorUtility.DisplayDialog("No Config selected", "Please select a TxtFile Config...\nSuch as Exsample.txt:\nname=Assets/GameAssets/Fonts/impact.ttf,size=40\n123456789abcdefghijk", "Cancel");
return;
}
int targetFontSize;
string sourceFontPath, targetFontPath, targetFontCharacters = "";
try
{
string sourceConfigPath = AssetDatabase.GetAssetPath(Selection.activeObject);
string[] sourceConfigInfos = sourceTextAsset.text.Split('\n');
string headInfo = sourceConfigInfos [0];
string[] headInfos = headInfo.Split(',');
sourceFontPath = headInfos [0].Split('=') [1];
targetFontPath = sourceConfigPath.Replace(".txt", "_copy");
targetFontSize = int.Parse(headInfos [1].Split('=') [1]);
for (int i = 1; i < sourceConfigInfos.Length; i++)
{
targetFontCharacters += sourceConfigInfos [i];
}
} catch (Exception ex)
{
EditorUtility.DisplayDialog("Config Error", "The config header data error...", "Cancel");
return;
}
// 重新生成字体文件会导致场景中已存在的丢失，
// 所以需要生成后再次赋值
string[] targetFontPathInfos = targetFontPath.Split('/');
string textCheckName = targetFontPathInfos [targetFontPathInfos.Length - 1];
var listTexts = new List <Text>();
foreach (Text text in UnityEngine.Object.FindObjectsOfType(typeof(Text)))
{
if (text.font.name == textCheckName)
{
listTexts.Add(text);
}
}
UnityEngine.Object f = AssetDatabase.LoadMainAssetAtPath(sourceFontPath);
string path = AssetDatabase.GetAssetPath(f);
TrueTypeFontImporter fontImporter = AssetImporter.GetAtPath(path) as TrueTypeFontImporter;
fontImporter.fontTextureCase = FontTextureCase.CustomSet;
fontImporter.customCharacters = targetFontCharacters;
fontImporter.fontSize = targetFontSize;
fontImporter.SaveAndReimport();
AssetDatabase.Refresh();
Font font = fontImporter.GenerateEditableFont(targetFontPath);
foreach (Text item in listTexts)
{
item.font = font;
}
// 还原ttf设置
fontImporter.fontTextureCase = FontTextureCase.Dynamic;
fontImporter.SaveAndReimport();
AssetDatabase.Refresh();
System.GC.Collect();
}
private void OverwriteImportSettings(TrueTypeFontImporter target, TrueTypeFontImporter reference)
{
}
// レイアウトを描画する
private void OnGUI()
{
string tPath = null;
string[] tId = AssetDatabase.FindAssets("FontFilter");
if (tId != null)
{
int i, l = tId.Length;
for (i = 0; i < l; i++)
{
tPath = AssetDatabase.GUIDToAssetPath(tId[i]);
if (Directory.Exists(tPath) == true)
{
break;
}
}
if (i >= l)
{
tPath = null;
}
}
if (string.IsNullOrEmpty(tPath) == true)
{
EditorGUILayout.HelpBox("状態が異常です", MessageType.Warning);
return;
}
tPath = tPath + "/Resources/uGUIHelper";
if (Directory.Exists(tPath) == false)
{
EditorGUILayout.HelpBox("保存フォルダが存在しません", MessageType.Warning);
return;
}
FontFilter tFF = null;
tPath = tPath + "/FontFilter.asset";
if (File.Exists(tPath) == false)
{
// ファイルが存在しない
tFF = ScriptableObject.CreateInstance <FontFilter>();
tFF.name = "FontFilter";
AssetDatabase.CreateAsset(tFF, tPath);
AssetDatabase.Refresh();
}
else
{
// ファイルが存在する
tFF = AssetDatabase.LoadAssetAtPath <FontFilter>(tPath);
}
Selection.activeObject = tFF;
//----------------------------------------------------------
bool tDirty = false;
// フォント
Font tFont = EditorGUILayout.ObjectField("Font", m_Font, typeof(Font), false) as Font;
if (tFont != m_Font)
{
m_Font = tFont;
}
if (m_Font != null)
{
if (GUILayout.Button("Create Or Update") == true)
{
tPath = AssetDatabase.GetAssetPath(m_Font.GetInstanceID());
TrueTypeFontImporter tFontData = ( TrueTypeFontImporter )AssetImporter.GetAtPath(tPath);
FontTextureCase tOldFontTextureCase = tFontData.fontTextureCase;
if (tFontData.fontTextureCase != FontTextureCase.Unicode)
{
tFontData.fontTextureCase = FontTextureCase.Unicode;
tFontData.SaveAndReimport();
}
//--------------------------------------------------------------------
if (tFF.flag == null || tFF.flag.Length < 8192)
{
tFF.flag = new byte[8192];
}
int v = 0;
byte f;
CharacterInfo tCI;
bool e;
char c;
int i, j, l = 65536;
for (i = 0; i < l; i = i + 8)
{
f = 0;
for (j = 0; j < 8; j++)
{
c = ( char )(i + j);
e = true;
if (c != ' ' && c != ' ')
{
if (m_Font.HasCharacter(c) == true)
{
if (m_Font.GetCharacterInfo(c, out tCI, 16) == true)
{
if (tCI.advance <= 0)
{
e = false;
}
}
else
{
e = false;
}
}
else
{
e = false;
}
}
if (e == true)
{
f = ( byte )(f | (1 << j));
v++;
}
}
tFF.flag[i >> 3] = f;
}
//--------------------------------------------------------------------
if (tOldFontTextureCase != FontTextureCase.Unicode)
{
tFontData.fontTextureCase = tOldFontTextureCase;
tFontData.SaveAndReimport();
}
//--------------------------------------------------------------------
tDirty = true;
EditorUtility.DisplayDialog("Font Filter", "Completed !! -> " + v, "OK");
}
}
//----------------------------------
// 更新判定
if (tDirty == true)
{
EditorUtility.SetDirty(tFF); // 更新実行
// AssetDatabase.Refresh() ;
}
}
public void PopulateCharacter()
{
//A GLITCH: Unity's Font.HasCharacter doesn't work properly on dynamic mode, we need to change it to Unicode first
TrueTypeFontImporter fontData = (TrueTypeFontImporter)AssetImporter.GetAtPath(assetPath);
if (!fontData)
{
assetPath = AssetDatabase.GetAssetPath(Font_Asset);
fontData = (TrueTypeFontImporter)AssetImporter.GetAtPath(assetPath);
}
fontData.customCharacters = parsedCatalogs == null || parsedCatalogs.Length == 0 ? null : new System.String(parsedCatalogs);
fontData.fontTextureCase = string.IsNullOrEmpty(fontData.customCharacters) ? FontTextureCase.Unicode : FontTextureCase.CustomSet;
fontData.SaveAndReimport();
chars = chars ?? new TexChar[0];
TexChar ch;
// Import all or on what parsedCatalogs says
var availableChars = Font_Asset.characterInfo;
var newChars = new TexChar[parsedCatalogs.Length == 0 ? availableChars.Length : parsedCatalogs.Length];
// Try to keep the character data not destroyed at all.
for (int i = 0; i < newChars.Length; i++)
{
if (parsedCatalogs.Length == 0)
{
ch = newChars[i] = chars.FirstOrDefault(x => x.characterIndex == availableChars[i].index) ?? new TexChar(this, i, (char)availableChars[i].index, true, 1);
}
else
{
ch = newChars[i] = chars.FirstOrDefault(x => x.characterIndex == parsedCatalogs[i]) ?? new TexChar(this, i, parsedCatalogs[i], Font_Asset.HasCharacter(parsedCatalogs[i]), 1);
}
if (!ch.supported)
{
continue;
}
CharacterInfo c;
Font_Asset.GetCharacterInfo(ch.characterIndex, out c, 0, FontStyle.Normal);
float factor = c.size == 0 ? Font_Asset.fontSize : c.size;
ch.depth = -c.minY / factor;
ch.height = c.maxY / factor;
ch.bearing = -c.minX / factor;
ch.italic = c.maxX / factor;
ch.width = c.advance / factor;
ch.fontIndex = index;
ch.index = i;
}
chars = newChars;
font_lineHeight = Mathf.Max(Font_Asset.lineHeight / Font_Asset.fontSize, 0.2f);
// Try to keep the character data not destroyed at all.
for (int i = 0; i < newChars.Length; i++)
{
chars = newChars;
}
fontData.fontTextureCase = FontTextureCase.Dynamic;
fontData.SaveAndReimport();
}
public void Apply(AssetImporter originalImporter, string assetPath, Property[] properties)
{
TrueTypeFontImporter importer = (TrueTypeFontImporter)originalImporter;
for (int i = 0; i < properties.Length; i++)
{
var property = properties [i];
switch (property.name)
{
case "fontSize":
importer.fontSize = int.Parse(property.value);
break;
case "fontTextureCase":
importer.fontTextureCase = (FontTextureCase)System.Enum.Parse(typeof(FontTextureCase), property.value, true);
break;
case "includeFontData":
importer.includeFontData = bool.Parse(property.value);
break;
case "ascentCalculationMode":
importer.ascentCalculationMode = (AscentCalculationMode)System.Enum.Parse(typeof(AscentCalculationMode), property.value, true);
break;
case "customCharacters":
importer.customCharacters = property.value;
break;
case "characterSpacing":
importer.characterSpacing = int.Parse(property.value);
break;
case "characterPadding":
importer.characterPadding = int.Parse(property.value);
break;
case "fontRenderingMode":
importer.fontRenderingMode = (FontRenderingMode)System.Enum.Parse(typeof(FontRenderingMode), property.value, true);
break;
case "userData":
importer.userData = property.value;
break;
case "assetBundleName":
importer.assetBundleName = property.value;
break;
case "assetBundleVariant":
importer.assetBundleVariant = property.value;
break;
case "name":
importer.name = property.value;
break;
case "hideFlags":
importer.hideFlags = (HideFlags)System.Enum.Parse(typeof(HideFlags), property.value, true);
break;
}
}
}
public static void DrawFonts()
{
var theme = Theme.active;
bool hasFontsets = ThemeFontset.all.Count > 0;
bool fontsetAltered = !theme.fontset.Matches(ThemeFontset.all[Theme.fontsetIndex]);
if (theme.customizableFontset && hasFontsets)
{
bool open = "Fonts".ToLabel().DrawFoldout("Theme.Fonts");
if (EditorGUIExtension.lastChanged)
{
GUI.changed = false;
}
if (!open)
{
return;
}
EditorGUI.indentLevel += 1;
var builtin = Resources.FindObjectsOfTypeAll <Font>().Where(x => AssetDatabase.GetAssetPath(x).Contains("Library/unity")).ToArray();
var fontFiles = FileManager.FindAll("Themes/Fonts/*.*tf");
var fonts = builtin.Concat(fontFiles.Select(x => x.GetAsset <Font>())).ToArray();
if (Theme.fontNames.Count < 1)
{
var fontPath = Theme.storagePath + "Fonts/";
Theme.fontNames = builtin.Select(x => "@Builtin/" + x.name).Concat(fontFiles.Select(x => x.path)).ToList();
Func <string, string> FixFontNames = (data) => {
data = data.Remove(fontPath, ".ttf", ".otf");
if (data.Contains("/"))
{
var folder = data.GetDirectory();
var folderPascal = folder.ToPascalCase();
data = folder + "/" + data.Split("/").Last().Remove(folderPascal + "-", folderPascal);
if (Theme.fontNames.Count(x => x.Contains(folder + "/")) == 1)
{
data = folder;
}
}
return(data.Trim("/"));
};
Theme.fontNames = Theme.fontNames.Select(x => FixFontNames(x)).ToList();
}
var fontNames = Theme.fontNames.Copy();
if (fontNames.Count < 1)
{
fontNames.Add("No fonts found.");
}
theme.fontset.rendering = theme.fontset.rendering.Draw("Rendering Mode").As <FontRenderingMode>();
EditorPrefs.SetInt("EditorTheme-FontRendering-" + theme.fontset.name, theme.fontset.rendering.ToInt());
if (EditorGUIExtension.lastChanged)
{
var path = Theme.storagePath + "Fonts";
AssetDatabase.StartAssetEditing();
foreach (var item in theme.fontset.fonts)
{
var font = item.Value.font;
path = AssetDatabase.GetAssetPath(font);
var importer = TrueTypeFontImporter.GetAtPath(path).As <TrueTypeFontImporter>();
importer.fontRenderingMode = theme.fontset.rendering;
AssetDatabase.WriteImportSettingsIfDirty(path);
}
AssetDatabase.StopAssetEditing();
AssetDatabase.Refresh();
}
GUIStyleExtension.autoLayout = false;
foreach (var item in theme.fontset.fonts)
{
if (item.Value.font.IsNull())
{
continue;
}
var themeFont = item.Value;
EditorGUILayout.BeginHorizontal();
var index = fonts.IndexOf(themeFont.font);
if (index == -1)
{
EditorGUILayout.EndHorizontal();
var message = "[" + themeFont.name + " not found]";
index = fontNames.Unshift(message).Draw(0, item.Key.ToTitleCase());
if (index != 0)
{
themeFont.font = fonts[index - 1];
}
continue;
}
var offsetStyle = EditorStyles.numberField.FixedWidth(35).Margin(0, 0, 2, 0);
themeFont.font = fonts[fontNames.Draw(index, item.Key.ToTitleCase())];
EditorGUIUtility.labelWidth = 38;
EditorGUIUtility.fieldWidth = 25;
themeFont.sizeOffset = themeFont.sizeOffset.DrawInt("Size", offsetStyle.FixedWidth(25), false);
EditorGUIUtility.labelWidth = 20;
EditorGUIUtility.fieldWidth = 35;
themeFont.offsetX = themeFont.offsetX.Draw("X", offsetStyle, false);
themeFont.offsetY = themeFont.offsetY.Draw("Y", offsetStyle, false);
EditorGUIUtility.labelWidth = 200;
EditorGUILayout.EndHorizontal();
}
GUIStyleExtension.autoLayout = true;
if (fontsetAltered)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Space(15);
if (GUILayout.Button("Save", GUILayout.Width(100)))
{
theme.fontset.Export();
}
if (GUILayout.Button("Reset", GUILayout.Width(100)))
{
Theme.LoadFontset(true);
}
if (GUILayout.Button("Apply", GUILayout.Width(100)))
{
theme.fontset.Export(theme.fontset.path);
}
EditorGUILayout.EndHorizontal();
}
EditorGUI.indentLevel -= 1;
if (GUI.changed)
{
Theme.SaveFontset();
}
GUILayout.Space(10);
}
}
