public static void ON_FONT_PROPERTY_CHANGED(bool isChanged, TextMeshProFont font) { if (FONT_PROPERTY_EVENT != null) { FONT_PROPERTY_EVENT(isChanged, font); } }
public static void ON_FONT_PROPERTY_CHANGED(bool isChanged, TextMeshProFont font) { if (TMPro_EventManager.FONT_PROPERTY_EVENT != null) { TMPro_EventManager.FONT_PROPERTY_EVENT(isChanged, font); } }
void Start() { // Add new TextMesh Pro Component m_textMeshPro = gameObject.AddComponent<TextMeshPro>(); //m_textContainer = GetComponent<TextContainer>(); // Load the Font Asset to be used. m_FontAsset = Resources.Load("Fonts & Materials/ARIAL SDF", typeof(TextMeshProFont)) as TextMeshProFont; m_textMeshPro.font = m_FontAsset; // Assign Material to TextMesh Pro Component //m_textMeshPro.fontSharedMaterial = Resources.Load("Fonts & Materials/ARIAL SDF Bevel", typeof(Material)) as Material; //m_textMeshPro.fontSharedMaterial.EnableKeyword("BEVEL_ON"); // Set various font settings. m_textMeshPro.fontSize = 48; //m_textMeshPro.anchor = AnchorPositions.Center; m_textMeshPro.alignment = TextAlignmentOptions.Center; m_textMeshPro.anchorDampening = true; //m_textMeshPro.enableAutoSizing = true; //textMeshPro.lineJustification = LineJustificationTypes.Center; //textMeshPro.characterSpacing = 0.2f; //m_textMeshPro.enableCulling = true; //textMeshPro.enableWordWrapping = true; //textMeshPro.lineLength = 60; //textMeshPro.fontColor = new Color32(255, 255, 255, 255); /* for (int i = 0; i <= 1000000; i++) { m_textMeshPro.SetText(label, i % 1000); // Example to test the .char function. //m_chars = (i % 100).ToString().ToCharArray(); //textMeshPro.chars = m_chars; yield return new WaitForSeconds(0.1f); } */ }
// Function which loads either the default font or a newly assigned font asset. This function also assigned the appropriate material to the renderer. void LoadFontAsset() { //Debug.Log("***** LoadFontAsset() *****"); //TextMeshPro LoadFontAsset() has been called."); // Current Font Asset is " + (font != null ? font.name: "Null") ); ShaderUtilities.GetShaderPropertyIDs(); if (m_fontAsset == null) { // Load TMP_Settings if (m_settings == null) m_settings = TMP_Settings.LoadDefaultSettings(); if (m_settings != null && m_settings.fontAsset != null) m_fontAsset = m_settings.fontAsset; else m_fontAsset = Resources.Load("Fonts & Materials/ARIAL SDF", typeof(TextMeshProFont)) as TextMeshProFont; if (m_fontAsset == null) { Debug.LogWarning("The ARIAL SDF Font Asset was not found. There is no Font Asset assigned to " + gameObject.name + ".", this); return; } if (m_fontAsset.characterDictionary == null) { Debug.Log("Dictionary is Null!"); } //m_uiRenderer.SetMaterial(m_fontAsset.material, null); m_baseMaterial = m_fontAsset.material; m_sharedMaterial = m_baseMaterial; m_isNewBaseMaterial = true; //m_renderer.receiveShadows = false; //m_renderer.castShadows = false; // true; // Get a Reference to the Shader } else { if (m_fontAsset.characterDictionary == null) { //Debug.Log("Reading Font Definition and Creating Character Dictionary."); m_fontAsset.ReadFontDefinition(); } // Force the use of the base material m_sharedMaterial = m_baseMaterial; m_isNewBaseMaterial = true; // If font atlas texture doesn't match the assigned material font atlas, switch back to default material specified in the Font Asset. if (m_sharedMaterial == null || m_sharedMaterial.mainTexture == null || m_fontAsset.atlas.GetInstanceID() != m_sharedMaterial.mainTexture.GetInstanceID()) { m_sharedMaterial = m_fontAsset.material; m_baseMaterial = m_sharedMaterial; m_isNewBaseMaterial = true; } } // Check & Assign Underline Character for use with the Underline tag. if (!m_fontAsset.characterDictionary.TryGetValue(95, out m_cached_Underline_GlyphInfo)) //95 Debug.LogWarning("Underscore character wasn't found in the current Font Asset. No characters assigned for Underline.", this); m_stencilID = MaterialManager.GetStencilID(gameObject); if (m_stencilID == 0) { if (m_maskingMaterial != null) { MaterialManager.ReleaseStencilMaterial(m_maskingMaterial); m_maskingMaterial = null; } m_sharedMaterial = m_baseMaterial; } else { if (m_maskingMaterial == null) m_maskingMaterial = MaterialManager.GetStencilMaterial(m_baseMaterial, m_stencilID); else if (m_maskingMaterial.GetInt(ShaderUtilities.ID_StencilID) != m_stencilID || m_isNewBaseMaterial) { MaterialManager.ReleaseStencilMaterial(m_maskingMaterial); m_maskingMaterial = MaterialManager.GetStencilMaterial(m_baseMaterial, m_stencilID); } m_sharedMaterial = m_maskingMaterial; } m_isNewBaseMaterial = false; //m_sharedMaterials.Add(m_sharedMaterial); SetShaderDepth(); // Set ZTestMode based on Canvas RenderMode. if (m_uiRenderer == null) m_uiRenderer = GetComponent<CanvasRenderer>(); m_uiRenderer.SetMaterial(m_sharedMaterial, m_sharedMaterial.mainTexture); m_padding = ShaderUtilities.GetPadding(m_sharedMaterial, m_enableExtraPadding, m_isUsingBold); //m_alignmentPadding = ShaderUtilities.GetFontExtent(m_sharedMaterial); }
// Event received when font asset properties are changed in Font Inspector void ON_FONT_PROPERTY_CHANGED(bool isChanged, TextMeshProFont font) { if (font == m_fontAsset) { //Debug.Log("ON_FONT_PROPERTY_CHANGED event received."); m_havePropertiesChanged = true; hasFontAssetChanged = true; /* ScheduleUpdate(); */ } }
// Function to identify and validate the rich tag. Returns the position of the > if the tag was valid. bool ValidateHtmlTag(int[] chars, int startIndex, out int endIndex) { Array.Clear(m_htmlTag, 0, m_htmlTag.Length); int tagCharCount = 0; int tagHashCode = 0; TagAttribute attribute_1 = new TagAttribute(); TagAttribute attribute_2 = new TagAttribute(); byte attributeFlag = 0; TagUnits tagUnits = TagUnits.Pixels; int numSequenceStart = 0; int numSequenceEnd = 0; int numSequenceDecimalPos = 0; int numSequenceUnitPos = 0; endIndex = startIndex; bool isValidHtmlTag = false; bool hasNumericalValue = false; for (int i = startIndex; i < chars.Length && chars[i] != 0 && tagCharCount < m_htmlTag.Length && chars[i] != 60; i++) { if (chars[i] == 62) // ASCII Code of End HTML tag '>' { isValidHtmlTag = true; endIndex = i; m_htmlTag[tagCharCount] = (char)0; if (numSequenceEnd == 0) numSequenceEnd = tagCharCount - 1; break; } m_htmlTag[tagCharCount] = (char)chars[i]; tagCharCount += 1; // Compute HashCode for 1st attribute if (attributeFlag == 1) { if (chars[i] != 34) // Exclude quotes from the HashCode. { if (attribute_1.startIndex == 0) attribute_1.startIndex = tagCharCount - 1; attribute_1.hashCode = (attribute_1.hashCode << 5) - attribute_1.hashCode + chars[i]; attribute_1.length += 1; } else if (attribute_1.startIndex != 0) attributeFlag = 2; } // Compute HashCode for 2st attribute if (attributeFlag == 3) { if (chars[i] != 34) // Exclude quotes from the HashCode. { if (attribute_2.startIndex == 0) attribute_2.startIndex = tagCharCount - 1; attribute_2.hashCode = (attribute_2.hashCode << 5) - attribute_2.hashCode + chars[i]; attribute_2.length += 1; } else if (attribute_2.startIndex != 0) attributeFlag = 0; } // Extract numerical value and unit type (px, em, %) if (chars[i] == 61) // '=' { numSequenceStart = tagCharCount; attributeFlag += 1; } else if (chars[i] == 46) // '.' numSequenceDecimalPos = tagCharCount - 1; else if (numSequenceStart != 00 && !hasNumericalValue && char.IsDigit((char)chars[i])) hasNumericalValue = true; else if (numSequenceStart != 0 && numSequenceUnitPos == 0 && (chars[i] == 112 || chars[i] == 101 || chars[i] == 37)) { numSequenceEnd = tagCharCount - 2; numSequenceUnitPos = tagCharCount - 1; if (chars[i] == 101) tagUnits = TagUnits.FontUnits; else if (chars[i] == 37) tagUnits = TagUnits.Percentage; } // Compute HashCode for the <tag> if (numSequenceStart == 0) tagHashCode = (tagHashCode << 3) - tagHashCode + chars[i]; } if (!isValidHtmlTag) { return false; } //Debug.Log("Tag is [" + m_htmlTag.ArrayToString() + "]. Tag HashCode: " + tagHashCode + " Attribute HashCode: " + attribute_1.hashCode); // Special handling of the NoParsing tag if (tag_NoParsing && tagHashCode != 53822163) return false; else if (tagHashCode == 53822163) { tag_NoParsing = false; return true; } // Color <#FF00FF> if (m_htmlTag[0] == 35 && tagCharCount == 7) // if Tag begins with # and contains 7 characters. { m_htmlColor = HexCharsToColor(m_htmlTag, tagCharCount); m_colorStack[m_colorStackIndex] = m_htmlColor; m_colorStackIndex += 1; return true; } // Color <#FF00FF00> with alpha else if (m_htmlTag[0] == 35 && tagCharCount == 9) // if Tag begins with # and contains 9 characters. { m_htmlColor = HexCharsToColor(m_htmlTag, tagCharCount); m_colorStack[m_colorStackIndex] = m_htmlColor; m_colorStackIndex += 1; return true; } else { float value = 0; switch (tagHashCode) { case 98: // <b> m_style |= FontStyles.Bold; return true; case 427: // </b> if ((m_fontStyle & FontStyles.Bold) != FontStyles.Bold) m_style &= ~FontStyles.Bold; return true; case 105: // <i> m_style |= FontStyles.Italic; return true; case 434: // </i> m_style &= ~FontStyles.Italic; return true; case 115: // <s> m_style |= FontStyles.Strikethrough; return true; case 444: // </s> if ((m_fontStyle & FontStyles.Strikethrough) != FontStyles.Strikethrough) m_style &= ~FontStyles.Strikethrough; return true; case 117: // <u> m_style |= FontStyles.Underline; return true; case 446: // </u> if ((m_fontStyle & FontStyles.Underline) != FontStyles.Underline) m_style &= ~FontStyles.Underline; return true; case 6552: // <sub> m_currentFontSize *= m_fontAsset.fontInfo.SubSize > 0 ? m_fontAsset.fontInfo.SubSize : 1; // Subscript characters are half size. m_fontScale = m_currentFontSize / m_fontAsset.fontInfo.PointSize; m_baselineOffset = m_fontAsset.fontInfo.SubscriptOffset * m_fontScale; m_style |= FontStyles.Subscript; //m_isRecalculateScaleRequired = true; return true; case 22673: // </sub> m_currentFontSize /= m_fontAsset.fontInfo.SubSize > 0 ? m_fontAsset.fontInfo.SubSize : 1; //m_fontSize / m_fontAsset.FontInfo.PointSize * .1f; m_baselineOffset = 0; m_fontScale = m_currentFontSize / m_fontAsset.fontInfo.PointSize; m_style &= ~FontStyles.Subscript; //m_isRecalculateScaleRequired = true; return true; case 6566: // <sup> m_currentFontSize *= m_fontAsset.fontInfo.SubSize > 0 ? m_fontAsset.fontInfo.SubSize : 1; m_fontScale = m_currentFontSize / m_fontAsset.fontInfo.PointSize; m_baselineOffset = m_fontAsset.fontInfo.SuperscriptOffset * m_fontScale; m_style |= FontStyles.Superscript; //m_isRecalculateScaleRequired = true; return true; case 22687: // </sup> m_currentFontSize /= m_fontAsset.fontInfo.SubSize > 0 ? m_fontAsset.fontInfo.SubSize : 1; //m_fontSize / m_fontAsset.FontInfo.PointSize * .1f; m_baselineOffset = 0; m_fontScale = m_currentFontSize / m_fontAsset.fontInfo.PointSize; m_style &= ~FontStyles.Superscript; //m_isRecalculateScaleRequired = true; return true; case 6380: // <pos=000.00px> <pos=0em> <pos=50%> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); if (value == -9999 || value == 0) return false; switch (tagUnits) { case TagUnits.Pixels: m_xAdvance = value; //m_isIgnoringAlignment = true; return true; case TagUnits.FontUnits: m_xAdvance = value * m_fontScale * m_fontAsset.fontInfo.TabWidth / m_fontAsset.TabSize; //m_isIgnoringAlignment = true; return true; case TagUnits.Percentage: m_xAdvance = m_marginWidth * value / 100; //m_isIgnoringAlignment = true; return true; } return false; case 22501: // </pos> m_isIgnoringAlignment = false; return true; case 16034505: // <voffset> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); if (value == -9999 || value == 0) return false; switch (tagUnits) { case TagUnits.Pixels: m_baselineOffset = value; return true; case TagUnits.FontUnits: m_baselineOffset = value * m_fontScale * m_fontAsset.fontInfo.Ascender; return true; case TagUnits.Percentage: //m_baselineOffset = m_marginHeight * val / 100; return false; } return false; case 54741026: // </voffset> m_baselineOffset = 0; return true; case 43991: // <page> // This tag only works when Overflow - Page mode is used. if (m_overflowMode == TextOverflowModes.Page) { m_xAdvance = 0 + tag_LineIndent + tag_Indent; //m_textInfo.lineInfo[m_lineNumber].marginLeft = m_xAdvance; m_lineOffset = 0; m_pageNumber += 1; m_isNewPage = true; } return true; case 43969: // <nobr> m_isNonBreakingSpace = true; return true; case 156816: // </nobr> m_isNonBreakingSpace = false; return true; case 45545: // <size=> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); if (value == -9999 || value == 0) return false; switch (tagUnits) { case TagUnits.Pixels: if (m_htmlTag[5] == 43) // <size=+00> { m_currentFontSize = m_fontSize + value; m_isRecalculateScaleRequired = true; return true; } else if (m_htmlTag[5] == 45) // <size=-00> { m_currentFontSize = m_fontSize + value; m_isRecalculateScaleRequired = true; return true; } else // <size=00.0> { m_currentFontSize = value; m_isRecalculateScaleRequired = true; return true; } case TagUnits.FontUnits: m_currentFontSize *= value; m_isRecalculateScaleRequired = true; return true; case TagUnits.Percentage: m_currentFontSize = m_fontSize * value / 100; m_isRecalculateScaleRequired = true; return true; } return false; case 158392: // </size> m_currentFontSize = m_fontSize; m_isRecalculateScaleRequired = true; //m_fontScale = m_fontSize / m_fontAsset.fontInfo.PointSize * .1f; return true; case 41311: // <font=xx> //Debug.Log("Font name: \"" + new string(m_htmlTag, attribute_1.startIndex, attribute_1.length) + "\" HashCode: " + attribute_1.hashCode + " Material Name: \"" + new string(m_htmlTag, attribute_2.startIndex, attribute_2.length) + "\" Hashcode: " + attribute_2.hashCode); int fontHashCode = attribute_1.hashCode; int materialHashCode = attribute_2.hashCode; TextMeshProFont tempFont; Material tempMaterial; // HANDLE NEW FONT ASSET if (m_fontAsset_Dict.TryGetValue(fontHashCode, out tempFont)) { if (tempFont != m_currentFontAsset) { //Debug.Log("Assigning Font Asset: " + tempFont.name); m_currentFontAsset = m_fontAsset_Dict[fontHashCode]; m_isRecalculateScaleRequired = true; } } else { // Load new font asset tempFont = Resources.Load("Fonts & Materials/" + new string(m_htmlTag, attribute_1.startIndex, attribute_1.length), typeof(TextMeshProFont)) as TextMeshProFont; if (tempFont != null) { //Debug.Log("Loading and Assigning Font Asset: " + tempFont.name); m_fontAsset_Dict.Add(fontHashCode, tempFont); m_currentFontAsset = tempFont; m_isRecalculateScaleRequired = true; } else return false; } // HANDLE NEW MATERIAL if (materialHashCode == 0) { if (!m_fontMaterial_Dict.TryGetValue(m_currentFontAsset.materialHashCode, out tempMaterial)) m_fontMaterial_Dict.Add(m_currentFontAsset.materialHashCode, m_currentFontAsset.material); if (m_currentMaterial != m_currentFontAsset.material) { //Debug.Log("Assigning Default Font Asset Material: " + m_currentFontAsset.material.name); m_currentMaterial = m_currentFontAsset.material; } } else if (m_fontMaterial_Dict.TryGetValue(materialHashCode, out tempMaterial)) { if (tempMaterial != m_currentMaterial) { //Debug.Log("Assigning Material: " + tempMaterial.name); m_currentMaterial = tempMaterial; } } else { // Load new material tempMaterial = Resources.Load("Fonts & Materials/" + new string(m_htmlTag, attribute_2.startIndex, attribute_2.length), typeof(Material)) as Material; if (tempMaterial != null) { //Debug.Log("Loading and Assigning Material: " + tempMaterial.name); m_fontMaterial_Dict.Add(materialHashCode, tempMaterial); m_currentMaterial = tempMaterial; } else return false; } return true; case 320078: // <space=000.00> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); if (value == -9999 || value == 0) return false; switch (tagUnits) { case TagUnits.Pixels: m_xAdvance += value; return true; case TagUnits.FontUnits: m_xAdvance += value * m_fontScale * m_fontAsset.fontInfo.TabWidth / m_fontAsset.TabSize; return true; case TagUnits.Percentage: // Not applicable return false; } return false; case 276254: // <alpha=#FF> m_htmlColor.a = (byte)(HexToInt(m_htmlTag[7]) * 16 + HexToInt(m_htmlTag[8])); return true; case 1750458: // <a name=" "> return true; case 426: // </a> return true; case 43066: // <link="name"> if (m_isParsingText) { tag_LinkInfo.hashCode = attribute_1.hashCode; tag_LinkInfo.firstCharacterIndex = m_characterCount; //Debug.Log("Link begin at Character # " + m_characterCount); } return true; case 155913: // </link> if (m_isParsingText) { tag_LinkInfo.lastCharacterIndex = m_characterCount - 1; tag_LinkInfo.characterCount = m_characterCount - tag_LinkInfo.firstCharacterIndex; m_textInfo.linkInfo.Add(tag_LinkInfo); m_textInfo.linkCount += 1; //Debug.Log("*** LinkInfo Element Added ***\nHashCode: " + tag_LinkInfo.hashCode + " First Index: " + tag_LinkInfo.firstCharacterIndex + " Last Index: " + tag_LinkInfo.lastCharacterIndex + " Link Count: " + m_textInfo.linkCount); } return true; case 275917: // <align=> switch (attribute_1.hashCode) { case 3317767: // <align=left> m_lineJustification = TextAlignmentOptions.Left; return true; case 108511772: // <align=right> m_lineJustification = TextAlignmentOptions.Right; return true; case -1364013995: // <align=center> m_lineJustification = TextAlignmentOptions.Center; return true; case 1838536479: // <align=justified> m_lineJustification = TextAlignmentOptions.Justified; return true; } return false; case 1065846: // </align> m_lineJustification = m_textAlignment; return true; case 327550: // <width=xx> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); if (value == -9999 || value == 0) return false; switch (tagUnits) { case TagUnits.Pixels: m_width = value; break; case TagUnits.FontUnits: return false; //break; case TagUnits.Percentage: m_width = m_marginWidth * value / 100; break; } return true; case 1117479: // </width> m_width = -1; return true; case 322689: // <style="name"> TMP_Style style = TMP_StyleSheet.Instance.GetStyle(attribute_1.hashCode); if (style == null) return false; m_styleStack[m_styleStackIndex] = style.hashCode; m_styleStackIndex += 1; //// Parse Style Macro for (int i = 0; i < style.styleOpeningTagArray.Length; i++) { if (style.styleOpeningTagArray[i] == 60) ValidateHtmlTag(style.styleOpeningTagArray, i + 1, out i); } return true; case 1112618: // </style> style = TMP_StyleSheet.Instance.GetStyle(attribute_1.hashCode); if (style == null) { // Get style from the Style Stack m_styleStackIndex = m_styleStackIndex > 0 ? m_styleStackIndex - 1 : 0; style = TMP_StyleSheet.Instance.GetStyle(m_styleStack[m_styleStackIndex]); } if (style == null) return false; //// Parse Style Macro for (int i = 0; i < style.styleClosingTagArray.Length; i++) { if (style.styleClosingTagArray[i] == 60) ValidateHtmlTag(style.styleClosingTagArray, i + 1, out i); } return true; case 281955: // <color=#FF00FF> or <color=#FF00FF00> // <color=#FF00FF> if (m_htmlTag[6] == 35 && tagCharCount == 13) { m_htmlColor = HexCharsToColor(m_htmlTag, tagCharCount); m_colorStack[m_colorStackIndex] = m_htmlColor; m_colorStackIndex += 1; return true; } // <color=#FF00FF00> else if (m_htmlTag[6] == 35 && tagCharCount == 15) { m_htmlColor = HexCharsToColor(m_htmlTag, tagCharCount); m_colorStack[m_colorStackIndex] = m_htmlColor; m_colorStackIndex += 1; return true; } // <color=name> switch (attribute_1.hashCode) { case 112785: // <color=red> m_htmlColor = Color.red; m_colorStack[m_colorStackIndex] = m_htmlColor; m_colorStackIndex += 1; return true; case 3027034: // <color=blue> m_htmlColor = Color.blue; m_colorStack[m_colorStackIndex] = m_htmlColor; m_colorStackIndex += 1; return true; case 93818879: // <color=black> m_htmlColor = Color.black; m_colorStack[m_colorStackIndex] = m_htmlColor; m_colorStackIndex += 1; return true; case 98619139: // <color=green> m_htmlColor = Color.green; m_colorStack[m_colorStackIndex] = m_htmlColor; m_colorStackIndex += 1; return true; case 113101865: // <color=white> m_htmlColor = Color.white; m_colorStack[m_colorStackIndex] = m_htmlColor; m_colorStackIndex += 1; return true; case -1008851410: // <color=orange> m_htmlColor = new Color32(255, 128, 0, 255); m_colorStack[m_colorStackIndex] = m_htmlColor; m_colorStackIndex += 1; return true; case -976943172: // <color=purple> m_htmlColor = new Color32(160, 32, 240, 255); m_colorStack[m_colorStackIndex] = m_htmlColor; m_colorStackIndex += 1; return true; case -734239628: // <color=yellow> m_htmlColor = Color.yellow; m_colorStack[m_colorStackIndex] = m_htmlColor; m_colorStackIndex += 1; return true; } return false; case 1983971: // <cspace=xx.x> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); if (value == -9999 || value == 0) return false; switch (tagUnits) { case TagUnits.Pixels: m_cSpacing = value; break; case TagUnits.FontUnits: m_cSpacing = value; m_cSpacing *= m_fontScale * m_fontAsset.fontInfo.TabWidth / m_fontAsset.TabSize; break; case TagUnits.Percentage: return false; } return true; case 7513474: // </cspace> m_cSpacing = 0; return true; case 2152041: // <mspace=xx.x> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); if (value == -9999 || value == 0) return false; switch (tagUnits) { case TagUnits.Pixels: m_monoSpacing = value; break; case TagUnits.FontUnits: m_monoSpacing = value; m_monoSpacing *= m_fontScale * m_fontAsset.fontInfo.TabWidth / m_fontAsset.TabSize; break; case TagUnits.Percentage: return false; } return true; case 7681544: // </mspace> m_monoSpacing = 0; return true; case 280416: // <class="name"> return false; case 1071884: // </color> m_colorStackIndex -= 1; if (m_colorStackIndex <= 0) { m_htmlColor = m_fontColor32; m_colorStackIndex = 0; } else { m_htmlColor = m_colorStack[m_colorStackIndex - 1]; } return true; case 2068980: // <indent=10px> <indent=10em> <indent=50%> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); if (value == -9999 || value == 0) return false; switch (tagUnits) { case TagUnits.Pixels: tag_Indent = value; break; case TagUnits.FontUnits: tag_Indent *= m_fontScale * m_fontAsset.fontInfo.TabWidth / m_fontAsset.TabSize; break; case TagUnits.Percentage: tag_Indent = m_marginWidth * tag_Indent / 100; break; } m_xAdvance = tag_Indent; return true; case 7598483: // </indent> tag_Indent = 0; return true; case 1109386397: // <line-indent> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); if (value == -9999 || value == 0) return false; switch (tagUnits) { case TagUnits.Pixels: tag_LineIndent = value; break; case TagUnits.FontUnits: tag_LineIndent = value; tag_LineIndent *= m_fontScale * m_fontAsset.fontInfo.TabWidth / m_fontAsset.TabSize; break; case TagUnits.Percentage: tag_LineIndent = m_marginWidth * tag_LineIndent / 100; break; } m_xAdvance += tag_LineIndent; return true; case -445537194: // </line-indent> tag_LineIndent = 0; return true; case 2246877: // <sprite=x> if (m_inlineGraphics == null) m_inlineGraphics = GetComponent<InlineGraphicManager>() ?? gameObject.AddComponent<InlineGraphicManager>(); if (char.IsDigit(m_htmlTag[7])) { int index = (int)ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); m_spriteIndex = m_inlineGraphics.GetSpriteIndexByIndex(index); if (m_spriteIndex == -1) return false; } else { // Get sprite index by looking it up by name. m_spriteIndex = m_inlineGraphics.GetSpriteIndexByHashCode(attribute_1.hashCode); if (m_spriteIndex == -1) return false; //Debug.Log("Sprite name is: \"" + new string(m_htmlTag, attribute_1.startIndex, attribute_1.length) + "\" with HashCode: " + attribute_1.hashCode); } m_isSprite = true; return true; case 13526026: // <allcaps> m_style |= FontStyles.UpperCase; return true; case 52232547: // </allcaps> m_style &= ~FontStyles.UpperCase; return true; case 766244328: // <smallcaps> m_style |= FontStyles.SmallCaps; return true; case -1632103439: // </smallcaps> m_style &= ~FontStyles.SmallCaps; m_isRecalculateScaleRequired = true; return true; case 2109854: // <margin=00.0> <margin=00em> <margin=50%> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); // px if (value == -9999 || value == 0) return false; m_marginLeft = value; switch (tagUnits) { case TagUnits.Pixels: // Default behavior break; case TagUnits.FontUnits: m_marginLeft *= m_fontScale * m_fontAsset.fontInfo.TabWidth / m_fontAsset.TabSize; break; case TagUnits.Percentage: m_marginLeft = (m_marginWidth - (m_width != -1 ? m_width : 0)) * m_marginLeft / 100; break; } m_marginLeft = m_marginLeft >= 0 ? m_marginLeft : 0; m_marginRight = m_marginLeft; return true; case 7639357: // </margin> m_marginLeft = 0; m_marginRight = 0; return true; case 1100728678: // <margin-left=xx.x> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); // px if (value == -9999 || value == 0) return false; m_marginLeft = value; switch (tagUnits) { case TagUnits.Pixels: // Default behavior break; case TagUnits.FontUnits: m_marginLeft *= m_fontScale * m_fontAsset.fontInfo.TabWidth / m_fontAsset.TabSize; break; case TagUnits.Percentage: m_marginLeft = (m_marginWidth - (m_width != -1 ? m_width : 0)) * m_marginLeft / 100; break; } m_marginLeft = m_marginLeft >= 0 ? m_marginLeft : 0; return true; case -884817987: // <margin-right=xx.x> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); // px if (value == -9999 || value == 0) return false; m_marginRight = value; switch (tagUnits) { case TagUnits.Pixels: // Default behavior break; case TagUnits.FontUnits: m_marginRight *= m_fontScale * m_fontAsset.fontInfo.TabWidth / m_fontAsset.TabSize; break; case TagUnits.Percentage: m_marginRight = (m_marginWidth - (m_width != -1 ? m_width : 0)) * m_marginRight / 100; break; } m_marginRight = m_marginRight >= 0 ? m_marginRight : 0; return true; case 1109349752: // <line-height=xx.x> value = ConvertToFloat(m_htmlTag, numSequenceStart, numSequenceEnd, numSequenceDecimalPos); if (value == -9999 || value == 0) return false; m_lineHeight = value; switch (tagUnits) { case TagUnits.Pixels: m_lineHeight /= m_fontScale; break; case TagUnits.FontUnits: m_lineHeight *= m_fontAsset.fontInfo.LineHeight; break; case TagUnits.Percentage: m_lineHeight = m_fontAsset.fontInfo.LineHeight * m_lineHeight / 100; break; } return true; case -445573839: // </line-height> m_lineHeight = 0; return true; case 15115642: // <noparse> tag_NoParsing = true; return true; } } return false; }
/// <summary> /// This is the main function that is responsible for creating / displaying the text. /// </summary> void GenerateTextMesh() { //Debug.Log("***** GenerateTextMesh() ***** Frame: " + Time.frameCount); // + ". Point Size: " + m_fontSize + ". Margins are (W) " + m_marginWidth + " (H) " + m_marginHeight); // ". Iteration Count: " + loopCountA + ". Min: " + m_minFontSize + " Max: " + m_maxFontSize + " Delta: " + (m_maxFontSize - m_minFontSize) + " Font size is " + m_fontSize); //called for Object with ID " + GetInstanceID()); // Assigned Material is " + m_uiRenderer.GetMaterial().name); // IncludeForMasking " + this.m_IncludeForMasking); // and text is " + m_text); //Debug.Log(this.defaultMaterial.GetInstanceID() + " " + m_sharedMaterial.GetInstanceID() + " " + m_uiRenderer.GetMaterial().GetInstanceID()); // Early exit if no font asset was assigned. This should not be needed since Arial SDF will be assigned by default. if (m_fontAsset.characterDictionary == null) { Debug.Log("Can't Generate Mesh! No Font Asset has been assigned to Object ID: " + this.GetInstanceID()); return; } // Reset TextInfo if (m_textInfo != null) m_textInfo.Clear(); // Early exit if we don't have any Text to generate. if (m_char_buffer == null || m_char_buffer.Length == 0 || m_char_buffer[0] == (char)0) { //Debug.Log("Early Out! No Text has been set."); //Vector3[] vertices = m_textInfo.meshInfo.vertices; m_uiRenderer.SetMesh(null); if (m_inlineGraphics != null) m_inlineGraphics.ClearUIVertex(); /* if (vertices != null) { Array.Clear(vertices, 0, vertices.Length); m_textInfo.meshInfo.mesh.vertices = vertices; } */ m_preferredWidth = 0; m_preferredHeight = 0; m_renderedWidth = 0; m_renderedHeight = 0; // This should only be called if there is a layout component attached LayoutRebuilder.MarkLayoutForRebuild(m_rectTransform); return; } m_currentFontAsset = m_fontAsset; m_currentMaterial = m_sharedMaterial; // Determine how many characters will be visible and make the necessary allocations (if needed). int totalCharacterCount = SetArraySizes(m_char_buffer); // Scale the font to approximately match the point size m_fontScale = (m_fontSize / m_currentFontAsset.fontInfo.PointSize); float baseScale = m_fontScale; // BaseScale keeps the character aligned vertically since <size=+000> results in font of different scale. m_maxFontScale = baseScale; float previousLineMaxScale = baseScale; float firstVisibleCharacterScale = 0; float spriteScale = 1; m_currentFontSize = m_fontSize; float fontSizeDelta = 0; int charCode = 0; // Holds the character code of the currently being processed character. //int prev_charCode = 0; bool isMissingCharacter; // Used to handle missing characters in the Font Atlas / Definition. m_style = m_fontStyle; // Set the default style. m_lineJustification = m_textAlignment; // Sets the line justification mode to match editor alignment. // GetPadding to adjust the size of the mesh due to border thickness, softness, glow, etc... if (checkPaddingRequired) { checkPaddingRequired = false; m_padding = ShaderUtilities.GetPadding(m_uiRenderer.GetMaterial(), m_enableExtraPadding, m_isUsingBold); //m_alignmentPadding = ShaderUtilities.GetFontExtent(m_sharedMaterial); m_isMaskingEnabled = ShaderUtilities.IsMaskingEnabled(m_sharedMaterial); } float style_padding = 0; // Extra padding required to accommodate Bold style. float xadvance_multiplier = 1; // Used to increase spacing between character when style is bold. m_baselineOffset = 0; // Used by subscript characters. // Underline bool beginUnderline = false; Vector3 underline_start = Vector3.zero; // Used to track where underline starts & ends. Vector3 underline_end = Vector3.zero; // Strike-through bool beginStrikethrough = false; Vector3 strikethrough_start = Vector3.zero; Vector3 strikethrough_end = Vector3.zero; m_fontColor32 = m_fontColor; Color32 vertexColor; m_htmlColor = m_fontColor32; m_colorStackIndex = 0; Array.Clear(m_colorStack, 0, m_colorStack.Length); m_styleStackIndex = 0; Array.Clear(m_styleStack, 0, m_styleStack.Length); m_lineOffset = 0; // Amount of space between lines (font line spacing + m_linespacing). m_lineHeight = 0; m_cSpacing = 0; // Amount of space added between characters as a result of the use of the <cspace> tag. m_monoSpacing = 0; float lineOffsetDelta = 0; m_xAdvance = 0; // Used to track the position of each character. m_maxXAdvance = 0; tag_LineIndent = 0; // Used for indentation of text. tag_Indent = 0; tag_NoParsing = false; m_isIgnoringAlignment = false; m_characterCount = 0; // Total characters in the char[] m_visibleCharacterCount = 0; // # of visible characters. m_visibleSpriteCount = 0; // Tracking of line information m_firstCharacterOfLine = 0; m_lastCharacterOfLine = 0; m_firstVisibleCharacterOfLine = 0; m_lastVisibleCharacterOfLine = 0; m_lineNumber = 0; bool isStartOfNewLine = true; m_pageNumber = 0; int pageToDisplay = Mathf.Clamp(m_pageToDisplay - 1, 0, m_textInfo.pageInfo.Length - 1); int ellipsisIndex = 0; m_rectTransform.GetLocalCorners(m_rectCorners); Vector4 margins = m_margin; float marginWidth = m_marginWidth; float marginHeight = m_marginHeight; m_marginLeft = 0; m_marginRight = 0; m_width = -1; // Used by Unity's Auto Layout system. m_renderedWidth = 0; m_renderedHeight = 0; // Initialize struct to track states of word wrapping bool isFirstWord = true; bool isLastBreakingChar = false; //bool isEastAsianLanguage = false; m_SavedLineState = new WordWrapState(); m_SavedWordWrapState = new WordWrapState(); int wrappingIndex = 0; // Need to initialize these Extents structures m_meshExtents = new Extents(k_InfinityVector, -k_InfinityVector); // Initialize lineInfo if (m_textInfo.lineInfo == null) m_textInfo.lineInfo = new TMP_LineInfo[2]; for (int i = 0; i < m_textInfo.lineInfo.Length; i++) { m_textInfo.lineInfo[i] = new TMP_LineInfo(); m_textInfo.lineInfo[i].lineExtents = new Extents(k_InfinityVector, -k_InfinityVector); m_textInfo.lineInfo[i].ascender = -k_InfinityVector.x; m_textInfo.lineInfo[i].descender = k_InfinityVector.x; } // Tracking of the highest Ascender m_maxAscender = 0; m_maxDescender = 0; float pageAscender = 0; float maxVisibleDescender = 0; bool isMaxVisibleDescenderSet = false; m_isNewPage = false; loopCountA += 1; int endTagIndex = 0; // Parse through Character buffer to read HTML tags and begin creating mesh. for (int i = 0; m_char_buffer[i] != 0; i++) { charCode = m_char_buffer[i]; m_isSprite = false; spriteScale = 1; //Debug.Log("i:" + i + " Character [" + (char)charCode + "] with ASCII of " + charCode); //if (m_characterCount >= m_maxVisibleCharacters || m_lineNumber >= m_maxVisibleLines) // break; // Parse Rich Text Tag #region Parse Rich Text Tag if (m_isRichText && charCode == 60) // '<' { m_isParsingText = true; // Check if Tag is valid. If valid, skip to the end of the validated tag. if (ValidateHtmlTag(m_char_buffer, i + 1, out endTagIndex)) { i = endTagIndex; if (m_isRecalculateScaleRequired) { m_fontScale = m_currentFontSize / m_currentFontAsset.fontInfo.PointSize; m_isRecalculateScaleRequired = false; } if (!m_isSprite) continue; } } #endregion End Parse Rich Text Tag m_isParsingText = false; isMissingCharacter = false; // Check if we should be using a different font asset //if (m_fontIndex != 0) //{ // // Check if we need to load the new font asset // if (m_currentFontAsset == null) // { // Debug.Log("Loading secondary font asset."); // m_currentFontAsset = Resources.Load("Fonts & Materials/Bangers SDF", typeof(TextMeshProFont)) as TextMeshProFont; // //m_sharedMaterials.Add(m_currentFontAsset.material); // //m_renderer.sharedMaterials = new Material[] { m_sharedMaterial, m_currentFontAsset.material }; // m_sharedMaterials.ToArray(); // } //} //Debug.Log("Char [" + (char)charCode + "] is using FontIndex: " + m_fontIndex); // Handle Font Styles like LowerCase, UpperCase and SmallCaps. #region Handling of LowerCase, UpperCase and SmallCaps Font Styles if ((m_style & FontStyles.UpperCase) == FontStyles.UpperCase) { // If this character is lowercase, switch to uppercase. if (char.IsLower((char)charCode)) charCode = char.ToUpper((char)charCode); } else if ((m_style & FontStyles.LowerCase) == FontStyles.LowerCase) { // If this character is uppercase, switch to lowercase. if (char.IsUpper((char)charCode)) charCode = char.ToLower((char)charCode); } else if ((m_fontStyle & FontStyles.SmallCaps) == FontStyles.SmallCaps || (m_style & FontStyles.SmallCaps) == FontStyles.SmallCaps) { if (char.IsLower((char)charCode)) { m_fontScale = m_currentFontSize * 0.8f / m_currentFontAsset.fontInfo.PointSize; charCode = char.ToUpper((char)charCode); } else m_fontScale = m_currentFontSize / m_currentFontAsset.fontInfo.PointSize; } #endregion // Look up Character Data from Dictionary and cache it. #region Look up Character Data if (m_isSprite) { SpriteInfo spriteInfo = m_inlineGraphics.GetSprite(m_spriteIndex); if (spriteInfo == null) continue; // Sprites are assigned in the E000 Private Area + sprite Index charCode = 57344 + m_spriteIndex; m_cached_GlyphInfo = new GlyphInfo(); // Generates 40 bytes m_cached_GlyphInfo.x = spriteInfo.x; m_cached_GlyphInfo.y = spriteInfo.y; m_cached_GlyphInfo.width = spriteInfo.width; m_cached_GlyphInfo.height = spriteInfo.height; m_cached_GlyphInfo.xOffset = spriteInfo.pivot.x + spriteInfo.xOffset; m_cached_GlyphInfo.yOffset = spriteInfo.pivot.y + spriteInfo.yOffset; spriteScale = m_fontAsset.fontInfo.Ascender / spriteInfo.height * spriteInfo.scale; m_cached_GlyphInfo.xAdvance = spriteInfo.xAdvance * spriteScale; m_textInfo.characterInfo[m_characterCount].type = TMP_CharacterType.Sprite; } else { m_currentFontAsset.characterDictionary.TryGetValue(charCode, out m_cached_GlyphInfo); if (m_cached_GlyphInfo == null) { // Character wasn't found in the Dictionary. if (char.IsLower((char)charCode)) { if (m_currentFontAsset.characterDictionary.TryGetValue(char.ToUpper((char)charCode), out m_cached_GlyphInfo)) charCode = char.ToUpper((char)charCode); } else if (char.IsUpper((char)charCode)) { if (m_currentFontAsset.characterDictionary.TryGetValue(char.ToLower((char)charCode), out m_cached_GlyphInfo)) charCode = char.ToLower((char)charCode); } // Still don't have a replacement? if (m_cached_GlyphInfo == null) { m_currentFontAsset.characterDictionary.TryGetValue(88, out m_cached_GlyphInfo); if (m_cached_GlyphInfo != null) { Debug.LogWarning("Character with ASCII value of " + charCode + " was not found in the Font Asset Glyph Table.", this); // Replace the missing character by X (if it is found) charCode = 88; isMissingCharacter = true; } else { // At this point the character isn't in the Dictionary, the replacement X isn't either so ... Debug.LogWarning("Character with ASCII value of " + charCode + " was not found in the Font Asset Glyph Table.", this); continue; } } } m_textInfo.characterInfo[m_characterCount].type = TMP_CharacterType.Character; } #endregion // Store some of the text object's information m_textInfo.characterInfo[m_characterCount].character = (char)charCode; m_textInfo.characterInfo[m_characterCount].pointSize = m_currentFontSize; m_textInfo.characterInfo[m_characterCount].color = m_htmlColor; m_textInfo.characterInfo[m_characterCount].style = m_style; m_textInfo.characterInfo[m_characterCount].index = (short)i; //m_textInfo.characterInfo[m_characterCount].isIgnoringAlignment = m_isIgnoringAlignment; // Handle Kerning if Enabled. #region Handle Kerning if (m_enableKerning && m_characterCount >= 1) { int prev_charCode = m_textInfo.characterInfo[m_characterCount - 1].character; KerningPairKey keyValue = new KerningPairKey(prev_charCode, charCode); KerningPair pair; m_currentFontAsset.kerningDictionary.TryGetValue(keyValue.key, out pair); if (pair != null) { m_xAdvance += pair.XadvanceOffset * m_fontScale; } } #endregion // Handle Mono Spacing #region Handle Mono Spacing float monoAdvance = 0; if (m_monoSpacing != 0) { monoAdvance = (m_monoSpacing / 2 - (m_cached_GlyphInfo.width / 2 + m_cached_GlyphInfo.xOffset) * m_fontScale) * (1 - m_charWidthAdjDelta); m_xAdvance += monoAdvance; } #endregion // Set Padding based on selected font style #region Handle Style Padding if ((m_style & FontStyles.Bold) == FontStyles.Bold || (m_fontStyle & FontStyles.Bold) == FontStyles.Bold) // Checks for any combination of Bold Style. { style_padding = m_currentFontAsset.BoldStyle * 2; xadvance_multiplier = 1 + m_currentFontAsset.boldSpacing * 0.01f; } else { style_padding = m_currentFontAsset.NormalStyle * 2; xadvance_multiplier = 1.0f; } #endregion Handle Style Padding // Set padding value if Character or Sprite float padding = m_isSprite ? 0 : m_padding; // Determine the position of the vertices of the Character or Sprite. Vector3 top_left = new Vector3(0 + m_xAdvance + ((m_cached_GlyphInfo.xOffset - padding - style_padding) * m_fontScale * spriteScale * (1 - m_charWidthAdjDelta)), (m_cached_GlyphInfo.yOffset + padding) * m_fontScale * spriteScale - m_lineOffset + m_baselineOffset, 0); Vector3 bottom_left = new Vector3(top_left.x, top_left.y - ((m_cached_GlyphInfo.height + padding * 2) * m_fontScale * spriteScale), 0); Vector3 top_right = new Vector3(bottom_left.x + ((m_cached_GlyphInfo.width + padding * 2 + style_padding * 2) * m_fontScale * spriteScale * (1 - m_charWidthAdjDelta)), top_left.y, 0); Vector3 bottom_right = new Vector3(top_right.x, bottom_left.y, 0); // Check if we need to Shear the rectangles for Italic styles #region Handle Italic & Shearing if ((m_style & FontStyles.Italic) == FontStyles.Italic || (m_fontStyle & FontStyles.Italic) == FontStyles.Italic) { // Shift Top vertices forward by half (Shear Value * height of character) and Bottom vertices back by same amount. float shear_value = m_currentFontAsset.ItalicStyle * 0.01f; Vector3 topShear = new Vector3(shear_value * ((m_cached_GlyphInfo.yOffset + padding + style_padding) * m_fontScale * spriteScale), 0, 0); Vector3 bottomShear = new Vector3(shear_value * (((m_cached_GlyphInfo.yOffset - m_cached_GlyphInfo.height - padding - style_padding)) * m_fontScale * spriteScale), 0, 0); top_left = top_left + topShear; bottom_left = bottom_left + bottomShear; top_right = top_right + topShear; bottom_right = bottom_right + bottomShear; } #endregion Handle Italics & Shearing // Store position of the vertices for the Character or Sprite. m_textInfo.characterInfo[m_characterCount].bottomLeft = bottom_left; m_textInfo.characterInfo[m_characterCount].topLeft = top_left; m_textInfo.characterInfo[m_characterCount].topRight = top_right; m_textInfo.characterInfo[m_characterCount].bottomRight = bottom_right; m_textInfo.characterInfo[m_characterCount].baseLine = 0 - m_lineOffset + m_baselineOffset; m_textInfo.characterInfo[m_characterCount].scale = m_fontScale; // Compute MaxAscender & MaxDescender which is used for AutoScaling & other type layout options float ascender = m_fontAsset.fontInfo.Ascender * m_fontScale + m_baselineOffset; if ((charCode == 10 || charCode == 13) && m_characterCount > m_firstVisibleCharacterOfLine) ascender = m_baselineOffset; float descender = m_fontAsset.fontInfo.Descender * m_fontScale - m_lineOffset + m_baselineOffset; // Check if Sprite exceeds the Ascender and Descender of the font and if so make the adjustment. if (m_isSprite) { ascender = Mathf.Max(ascender, top_left.y - padding * m_fontScale * spriteScale); descender = Mathf.Min(descender, bottom_right.y - padding * m_fontScale * spriteScale); } if (m_lineNumber == 0) m_maxAscender = m_maxAscender > ascender ? m_maxAscender : ascender; if (m_lineOffset == 0) pageAscender = pageAscender > ascender ? pageAscender : ascender; // Track Line Height //maxLineHeight = Mathf.Max(m_lineHeight, maxLineHeight); // Used to adjust line spacing when larger fonts or the size tag is used. if (m_baselineOffset == 0) m_maxFontScale = Mathf.Max(m_maxFontScale, m_fontScale); // Set Characters to not visible by default. m_textInfo.characterInfo[m_characterCount].isVisible = false; // Setup Mesh for visible characters or sprites. ie. not a SPACE / LINEFEED / CARRIAGE RETURN. #region Handle Visible Characters if (charCode != 10 && charCode != 13 && charCode != 32 && charCode != 160 || m_isSprite) { m_textInfo.characterInfo[m_characterCount].isVisible = true; //if (isStartOfNewLine) { isStartOfNewLine = false; m_firstVisibleCharacterOfLine = m_characterCount; } // Check if Character exceeds the width of the Text Container #region Check for Characters Exceeding Width of Text Container float width = m_width != -1 ? Mathf.Min(marginWidth + 0.0001f - m_marginLeft - m_marginRight, m_width) : marginWidth + 0.0001f - m_marginLeft - m_marginRight; m_textInfo.lineInfo[m_lineNumber].width = width; m_textInfo.lineInfo[m_lineNumber].marginLeft = m_marginLeft; if (m_xAdvance + m_cached_GlyphInfo.xAdvance * (1 - m_charWidthAdjDelta) * m_fontScale > width) { ellipsisIndex = m_characterCount - 1; // Last safely rendered character // Word Wrapping #region Handle Word Wrapping if (enableWordWrapping && m_characterCount != m_firstCharacterOfLine) { if (wrappingIndex == m_SavedWordWrapState.previous_WordBreak || isFirstWord) { // Word wrapping is no longer possible. Shrink size of text if auto-sizing is enabled. if (m_enableAutoSizing && m_fontSize > m_fontSizeMin) { // Handle Character Width Adjustments #region Character Width Adjustments if (m_charWidthAdjDelta < m_charWidthMaxAdj / 100) { loopCountA = 0; m_charWidthAdjDelta += 0.01f; GenerateTextMesh(); return; } #endregion // Adjust Point Size m_maxFontSize = m_fontSize; m_fontSize -= Mathf.Max((m_fontSize - m_minFontSize) / 2, 0.05f); m_fontSize = (int)(Mathf.Max(m_fontSize, m_fontSizeMin) * 20 + 0.5f) / 20f; if (loopCountA > 20) return; // Added to debug GenerateTextMesh(); return; } // Word wrapping is no longer possible, now breaking up individual words. if (m_isCharacterWrappingEnabled == false) { m_isCharacterWrappingEnabled = true; } else isLastBreakingChar = true; //Debug.Log("Wrapping Index " + wrappingIndex + ". Recursive Count: " + m_recursiveCount); m_recursiveCount += 1; if (m_recursiveCount > 20) { //Debug.Log("Recursive count exceeded!"); continue; } //Debug.Log("Line #" + m_lineNumber + " Character [" + (char)charCode + "] cannot be wrapped. WrappingIndex: " + wrappingIndex + " Saved Index: " + m_SavedWordWrapState.previous_WordBreak + ". Character Count is " + m_characterCount); } // Restore to previously stored state of last valid (space character or linefeed) i = RestoreWordWrappingState(ref m_SavedWordWrapState); wrappingIndex = i; // Used to detect when line length can no longer be reduced. //Debug.Log("Last Visible Character of line # " + m_lineNumber + " is [" + m_textInfo.characterInfo[m_lastVisibleCharacterOfLine].character + " Character Count: " + m_characterCount + " Last visible: " + m_lastVisibleCharacterOfLine); // Check if Line Spacing of previous line needs to be adjusted. FaceInfo face = m_currentFontAsset.fontInfo; float gap = m_lineHeight == 0 ? face.LineHeight - (face.Ascender - face.Descender) : m_lineHeight - (face.Ascender - face.Descender); if (m_lineNumber > 0 && m_maxFontScale != 0 && m_lineHeight == 0 && firstVisibleCharacterScale != m_maxFontScale && !m_isNewPage) { float offsetDelta = 0 - face.Descender * previousLineMaxScale + (face.Ascender + gap + m_lineSpacing + m_paragraphSpacing + m_lineSpacingDelta) * m_maxFontScale; m_lineOffset += offsetDelta - lineOffsetDelta; AdjustLineOffset(m_firstCharacterOfLine, m_characterCount - 1, offsetDelta - lineOffsetDelta); m_SavedWordWrapState.lineOffset = m_lineOffset; } m_isNewPage = false; // Calculate lineAscender & make sure if last character is superscript or subscript that we check that as well. float lineAscender = m_fontAsset.fontInfo.Ascender * m_maxFontScale - m_lineOffset; float lineAscender2 = m_fontAsset.fontInfo.Ascender * m_fontScale - m_lineOffset + m_baselineOffset; lineAscender = lineAscender > lineAscender2 ? lineAscender : lineAscender2; // Calculate lineDescender & make sure if last character is superscript or subscript that we check that as well. float lineDescender = m_fontAsset.fontInfo.Descender * m_maxFontScale - m_lineOffset; float lineDescender2 = m_fontAsset.fontInfo.Descender * m_fontScale - m_lineOffset + m_baselineOffset; lineDescender = lineDescender < lineDescender2 ? lineDescender : lineDescender2; // Update maxDescender and maxVisibleDescender m_maxDescender = m_maxDescender < lineDescender ? m_maxDescender : lineDescender; if (!isMaxVisibleDescenderSet) maxVisibleDescender = m_maxDescender; if (m_characterCount >= m_maxVisibleCharacters || m_lineNumber >= m_maxVisibleLines) isMaxVisibleDescenderSet = true; // Track & Store lineInfo for the new line m_textInfo.lineInfo[m_lineNumber].firstCharacterIndex = m_firstCharacterOfLine; m_textInfo.lineInfo[m_lineNumber].firstVisibleCharacterIndex = m_firstVisibleCharacterOfLine; m_textInfo.lineInfo[m_lineNumber].lastCharacterIndex = m_characterCount - 1 > 0 ? m_characterCount - 1 : 0; m_textInfo.lineInfo[m_lineNumber].lastVisibleCharacterIndex = m_lastVisibleCharacterOfLine; m_textInfo.lineInfo[m_lineNumber].characterCount = m_textInfo.lineInfo[m_lineNumber].lastCharacterIndex - m_textInfo.lineInfo[m_lineNumber].firstCharacterIndex + 1; m_textInfo.lineInfo[m_lineNumber].lineExtents.min = new Vector2(m_textInfo.characterInfo[m_firstVisibleCharacterOfLine].bottomLeft.x, lineDescender); m_textInfo.lineInfo[m_lineNumber].lineExtents.max = new Vector2(m_textInfo.characterInfo[m_lastVisibleCharacterOfLine].topRight.x, lineAscender); m_textInfo.lineInfo[m_lineNumber].lineLength = m_textInfo.lineInfo[m_lineNumber].lineExtents.max.x - padding * m_maxFontScale; m_textInfo.lineInfo[m_lineNumber].maxAdvance = m_textInfo.characterInfo[m_lastVisibleCharacterOfLine].xAdvance - m_characterSpacing * m_fontScale; m_textInfo.lineInfo[m_lineNumber].maxScale = m_maxFontScale; m_firstCharacterOfLine = m_characterCount; // Store first character of the next line. // Compute Preferred Width & Height m_renderedWidth += m_xAdvance; if (m_enableWordWrapping) m_renderedHeight = m_maxAscender - m_maxDescender; else m_renderedHeight = Mathf.Max(m_renderedHeight, lineAscender - lineDescender); //Debug.Log("Line # " + m_lineNumber + " Max Font Scale: " + m_maxFontScale + " Current Font Scale: " + currentFontScale); //Debug.Log("LineInfo for line # " + (m_lineNumber) + " First character [" + m_textInfo.characterInfo[m_textInfo.lineInfo[m_lineNumber].firstCharacterIndex].character + "] at Index: " + m_textInfo.lineInfo[m_lineNumber].firstCharacterIndex + // " First visible character [" + m_textInfo.characterInfo[m_textInfo.lineInfo[m_lineNumber].firstVisibleCharacterIndex].character + "] at Index: " + m_textInfo.lineInfo[m_lineNumber].firstVisibleCharacterIndex + // " Last character [" + m_textInfo.characterInfo[m_textInfo.lineInfo[m_lineNumber].lastCharacterIndex].character + "] at index: " + m_textInfo.lineInfo[m_lineNumber].lastCharacterIndex + // " Last Visible character [" + m_textInfo.characterInfo[m_textInfo.lineInfo[m_lineNumber].lastVisibleCharacterIndex].character + "] at index: " + m_textInfo.lineInfo[m_lineNumber].lastVisibleCharacterIndex + // " Character Count of " + m_textInfo.lineInfo[m_lineNumber].characterCount /* + " Line Length of " + m_textInfo.lineInfo[m_lineNumber].lineLength + // " MinX: " + m_textInfo.lineInfo[m_lineNumber].lineExtents.min.x + " MinY: " + m_textInfo.lineInfo[m_lineNumber].lineExtents.min.y + // " MaxX: " + m_textInfo.lineInfo[m_lineNumber].lineExtents.max.x + " MaxY: " + m_textInfo.lineInfo[m_lineNumber].lineExtents.max.y + // " Line Ascender: " + lineAscender + " Line Descender: " + lineDescender */ ); // Store the state of the line before starting on the new line. SaveWordWrappingState(ref m_SavedLineState, i, m_characterCount - 1); m_lineNumber += 1; isStartOfNewLine = true; // Check to make sure Array is large enough to hold a new line. if (m_lineNumber >= m_textInfo.lineInfo.Length) ResizeLineExtents(m_lineNumber); // Apply Line Spacing based on scale of the last character of the line. FontStyles style = m_textInfo.characterInfo[m_characterCount].style; float scale = (style & FontStyles.Subscript) == FontStyles.Subscript || (style & FontStyles.Superscript) == FontStyles.Superscript ? m_maxFontScale : m_textInfo.characterInfo[m_characterCount].scale; lineOffsetDelta = 0 - face.Descender * m_maxFontScale + (face.Ascender + gap + m_lineSpacing + m_lineSpacingDelta) * scale; m_lineOffset += lineOffsetDelta; previousLineMaxScale = m_maxFontScale; firstVisibleCharacterScale = scale; m_maxFontScale = 0; spriteScale = 1; m_xAdvance = 0 + tag_Indent; continue; } #endregion End Word Wrapping // Text Auto-Sizing (text exceeding Width of container. #region Handle Text Auto-Sizing if (m_enableAutoSizing && m_fontSize > m_fontSizeMin) { // Handle Character Width Adjustments #region Character Width Adjustments if (m_charWidthAdjDelta < m_charWidthMaxAdj / 100) { loopCountA = 0; m_charWidthAdjDelta += 0.01f; GenerateTextMesh(); return; } #endregion // Adjust Point Size m_maxFontSize = m_fontSize; m_fontSize -= Mathf.Max((m_fontSize - m_minFontSize) / 2, 0.05f); m_fontSize = (int)(Mathf.Max(m_fontSize, m_fontSizeMin) * 20 + 0.5f) / 20f; m_recursiveCount = 0; if (loopCountA > 20) return; // Added to debug GenerateTextMesh(); return; } #endregion End Text Auto-Sizing // Handle Text Overflow #region Handle Text Overflow switch (m_overflowMode) { case TextOverflowModes.Overflow: if (m_isMaskingEnabled) DisableMasking(); break; case TextOverflowModes.Ellipsis: if (m_isMaskingEnabled) DisableMasking(); m_isTextTruncated = true; if (m_characterCount < 1) { m_textInfo.characterInfo[m_characterCount].isVisible = false; m_visibleCharacterCount -= 1; break; } m_char_buffer[i - 1] = 8230; m_char_buffer[i] = (char)0; GenerateTextMesh(); return; case TextOverflowModes.Masking: if (!m_isMaskingEnabled) EnableMasking(); break; case TextOverflowModes.ScrollRect: if (!m_isMaskingEnabled) EnableMasking(); break; case TextOverflowModes.Truncate: if (m_isMaskingEnabled) DisableMasking(); m_textInfo.characterInfo[m_characterCount].isVisible = false; break; } #endregion End Text Overflow } #endregion End Check for Characters Exceeding Width of Text Container if (charCode != 9) { // Determine Vertex Color if (isMissingCharacter) vertexColor = Color.red; else if (m_overrideHtmlColors) vertexColor = m_fontColor32; else vertexColor = m_htmlColor; // Store Character & Sprite Vertex Information if (!m_isSprite) SaveGlyphVertexInfo(style_padding, vertexColor); else SaveSpriteVertexInfo(vertexColor); } else // If character is Tab { m_textInfo.characterInfo[m_characterCount].isVisible = false; m_lastVisibleCharacterOfLine = m_characterCount; m_textInfo.lineInfo[m_lineNumber].spaceCount += 1; m_textInfo.spaceCount += 1; } // Increase visible count for Characters. if (m_textInfo.characterInfo[m_characterCount].isVisible) { if (m_isSprite) m_visibleSpriteCount += 1; else m_visibleCharacterCount += 1; if (isStartOfNewLine) { isStartOfNewLine = false; m_firstVisibleCharacterOfLine = m_characterCount; } m_lastVisibleCharacterOfLine = m_characterCount; } } else { // This is a Space, Tab, LineFeed or Carriage Return // Track # of spaces per line which is used for line justification. if (charCode == 9 || charCode == 32 || charCode == 160) { m_textInfo.lineInfo[m_lineNumber].spaceCount += 1; m_textInfo.spaceCount += 1; } } #endregion Handle Visible Characters // Store Rectangle positions for each Character. #region Store Character Data m_textInfo.characterInfo[m_characterCount].lineNumber = (short)m_lineNumber; m_textInfo.characterInfo[m_characterCount].pageNumber = (short)m_pageNumber; if (charCode != 10 && charCode != 13 && charCode != 8230 || m_textInfo.lineInfo[m_lineNumber].characterCount == 1) m_textInfo.lineInfo[m_lineNumber].alignment = m_lineJustification; #endregion Store Character Data // Check if text Exceeds the vertical bounds of the margin area. #region Check Vertical Bounds & Auto-Sizing if (m_maxAscender - descender > marginHeight + 0.0001f) { //Debug.Log((m_maxAscender - descender + (m_alignmentPadding.w * 2 * m_fontScale)).ToString("f6") + " " + marginHeight.ToString("f6")); //Debug.Log("Character [" + (char)charCode + "] at Index: " + m_characterCount + " has exceeded the Height of the text container. Max Ascender: " + m_maxAscender + " Max Descender: " + m_maxDescender + " Margin Height: " + marginHeight + " Bottom Left: " + bottom_left.y); // Handle Line spacing adjustments #region Line Spacing Adjustments if (m_enableAutoSizing && m_lineSpacingDelta > m_lineSpacingMax && m_lineNumber > 0) { m_lineSpacingDelta -= 1; GenerateTextMesh(); return; } #endregion // Handle Text Auto-sizing resulting from text exceeding vertical bounds. #region Text Auto-Sizing (Text greater than vertical bounds) if (m_enableAutoSizing && m_fontSize > m_fontSizeMin) { m_maxFontSize = m_fontSize; m_fontSize -= Mathf.Max((m_fontSize - m_minFontSize) / 2, 0.05f); m_fontSize = (int)(Mathf.Max(m_fontSize, m_fontSizeMin) * 20 + 0.5f) / 20f; m_recursiveCount = 0; if (loopCountA > 20) return; // Added to debug GenerateTextMesh(); return; } #endregion Text Auto-Sizing // Handle Text Overflow #region Text Overflow switch (m_overflowMode) { case TextOverflowModes.Overflow: if (m_isMaskingEnabled) DisableMasking(); break; case TextOverflowModes.Ellipsis: if (m_isMaskingEnabled) DisableMasking(); if (m_lineNumber > 0) { m_char_buffer[m_textInfo.characterInfo[ellipsisIndex].index] = 8230; m_char_buffer[m_textInfo.characterInfo[ellipsisIndex].index + 1] = (char)0; GenerateTextMesh(); m_isTextTruncated = true; return; } else { m_char_buffer[0] = (char)0; GenerateTextMesh(); m_isTextTruncated = true; return; } case TextOverflowModes.Masking: if (!m_isMaskingEnabled) EnableMasking(); break; case TextOverflowModes.ScrollRect: if (!m_isMaskingEnabled) EnableMasking(); break; case TextOverflowModes.Truncate: if (m_isMaskingEnabled) DisableMasking(); // Alternative Implementation //if (m_lineNumber > 0) //{ // if (!m_isTextTruncated && m_textInfo.characterInfo[ellipsisIndex + 1].character != 10) // { // Debug.Log("Char [" + (char)charCode + "] on line " + m_lineNumber + " exceeds the vertical bounds. Last safe character was " + (int)m_textInfo.characterInfo[ellipsisIndex + 1].character); // i = RestoreWordWrappingState(ref m_SavedWordWrapState); // m_lineNumber -= 1; // m_isTextTruncated = true; // m_isCharacterWrappingEnabled = true; // continue; // } // else // { // //Debug.Log("Char [" + (char)charCode + "] on line " + m_lineNumber + " set to invisible."); // m_textInfo.characterInfo[m_characterCount].isVisible = false; // } //// m_char_buffer[m_textInfo.characterInfo[ellipsisIndex].index + 1] = (char)0; //// m_isTextTruncated = true; //// i = RestoreWordWrappingState(ref m_SavedLineState); //// m_lineNumber -= 1; //// continue; //} //break; // TODO : Optimize if (m_lineNumber > 0) { m_char_buffer[m_textInfo.characterInfo[ellipsisIndex].index + 1] = (char)0; GenerateTextMesh(); m_isTextTruncated = true; return; } else { m_char_buffer[0] = (char)0; GenerateTextMesh(); m_isTextTruncated = true; return; } case TextOverflowModes.Page: if (m_isMaskingEnabled) DisableMasking(); // Ignore Page Break, Linefeed or carriage return if (charCode == 13 || charCode == 10) break; //Debug.Log("Character is [" + (char)charCode + "] with ASCII (" + charCode + ") on Page " + m_pageNumber + ". Ascender: " + m_textInfo.pageInfo[m_pageNumber].ascender + " BaseLine: " + m_textInfo.pageInfo[m_pageNumber].baseLine + " Descender: " + m_textInfo.pageInfo[m_pageNumber].descender); // Go back to previous line and re-layout i = RestoreWordWrappingState(ref m_SavedLineState); if (i == 0) { m_char_buffer[0] = (char)0; GenerateTextMesh(); m_isTextTruncated = true; return; } m_isNewPage = true; m_xAdvance = 0 + tag_Indent; m_lineOffset = 0; m_lineNumber += 1; m_pageNumber += 1; continue; } #endregion End Text Overflow } #endregion Check Vertical Bounds // Handle xAdvance & Tabulation Stops. Tab stops at every 25% of Font Size. #region XAdvance, Tabulation & Stops if (charCode == 9) m_xAdvance += m_fontAsset.fontInfo.TabWidth * m_fontScale; else if (m_monoSpacing != 0) m_xAdvance += (m_monoSpacing - monoAdvance + (m_characterSpacing * m_fontScale) + m_cSpacing) * (1 - m_charWidthAdjDelta); else m_xAdvance += ((m_cached_GlyphInfo.xAdvance * xadvance_multiplier + m_characterSpacing) * m_fontScale + m_cSpacing) * (1 - m_charWidthAdjDelta); // Store xAdvance information m_textInfo.characterInfo[m_characterCount].xAdvance = m_xAdvance; #endregion Tabulation & Stops // Handle Carriage Return #region Carriage Return if (charCode == 13) { m_maxXAdvance = Mathf.Max(m_maxXAdvance, m_renderedWidth + m_xAdvance); m_renderedWidth = 0; m_xAdvance = 0 + tag_Indent; } #endregion Carriage Return // Handle Line Spacing Adjustments + Word Wrapping & special case for last line. #region Check for Line Feed and Last Character if (charCode == 10 || m_characterCount == totalCharacterCount - 1) { // Check if Line Spacing of previous line needs to be adjusted. FaceInfo face = m_currentFontAsset.fontInfo; float gap = m_lineHeight == 0 ? face.LineHeight - (face.Ascender - face.Descender) : m_lineHeight - (face.Ascender - face.Descender); if (m_lineNumber > 0 && m_maxFontScale != 0 && m_lineHeight == 0 && firstVisibleCharacterScale != m_maxFontScale && !m_isNewPage) { float offsetDelta = 0 - face.Descender * previousLineMaxScale + (face.Ascender + gap + m_lineSpacing + m_paragraphSpacing + m_lineSpacingDelta) * m_maxFontScale; m_lineOffset += offsetDelta - lineOffsetDelta; AdjustLineOffset(m_firstCharacterOfLine, m_characterCount, offsetDelta - lineOffsetDelta); } m_isNewPage = false; // Calculate lineAscender & make sure if last character is superscript or subscript that we check that as well. float lineAscender = m_fontAsset.fontInfo.Ascender * m_maxFontScale - m_lineOffset; float lineAscender2 = m_fontAsset.fontInfo.Ascender * m_fontScale - m_lineOffset + m_baselineOffset; lineAscender = lineAscender > lineAscender2 ? lineAscender : lineAscender2; // Calculate lineDescender & make sure if last character is superscript or subscript that we check that as well. float lineDescender = m_fontAsset.fontInfo.Descender * m_maxFontScale - m_lineOffset; float lineDescender2 = m_fontAsset.fontInfo.Descender * m_fontScale - m_lineOffset + m_baselineOffset; lineDescender = lineDescender < lineDescender2 ? lineDescender : lineDescender2; // Update maxDescender and maxVisibleDescender m_maxDescender = m_maxDescender < lineDescender ? m_maxDescender : lineDescender; if (!isMaxVisibleDescenderSet) maxVisibleDescender = m_maxDescender; if (m_characterCount >= m_maxVisibleCharacters || m_lineNumber >= m_maxVisibleLines) isMaxVisibleDescenderSet = true; // Save Line Information m_textInfo.lineInfo[m_lineNumber].firstCharacterIndex = m_firstCharacterOfLine; m_textInfo.lineInfo[m_lineNumber].firstVisibleCharacterIndex = m_firstVisibleCharacterOfLine; m_textInfo.lineInfo[m_lineNumber].lastCharacterIndex = m_characterCount; m_textInfo.lineInfo[m_lineNumber].lastVisibleCharacterIndex = m_lastVisibleCharacterOfLine >= m_firstVisibleCharacterOfLine ? m_lastVisibleCharacterOfLine : m_firstVisibleCharacterOfLine; m_textInfo.lineInfo[m_lineNumber].characterCount = m_textInfo.lineInfo[m_lineNumber].lastCharacterIndex - m_textInfo.lineInfo[m_lineNumber].firstCharacterIndex + 1; m_textInfo.lineInfo[m_lineNumber].lineExtents.min = new Vector2(m_textInfo.characterInfo[m_firstVisibleCharacterOfLine].bottomLeft.x, lineDescender); m_textInfo.lineInfo[m_lineNumber].lineExtents.max = new Vector2(m_textInfo.characterInfo[m_lastVisibleCharacterOfLine].topRight.x, lineAscender); m_textInfo.lineInfo[m_lineNumber].lineLength = m_textInfo.lineInfo[m_lineNumber].lineExtents.max.x - (padding * m_maxFontScale); m_textInfo.lineInfo[m_lineNumber].maxAdvance = m_textInfo.characterInfo[m_lastVisibleCharacterOfLine].xAdvance - m_characterSpacing * m_fontScale; m_textInfo.lineInfo[m_lineNumber].maxScale = m_maxFontScale; m_firstCharacterOfLine = m_characterCount + 1; // Store PreferredWidth paying attention to linefeed and last character of text. if (charCode == 10 && m_characterCount != totalCharacterCount - 1) { m_maxXAdvance = Mathf.Max(m_maxXAdvance, m_renderedWidth + m_xAdvance); m_renderedWidth = 0; } else m_renderedWidth = Mathf.Max(m_maxXAdvance, m_renderedWidth + m_xAdvance); m_renderedHeight = m_maxAscender - m_maxDescender; //Debug.Log("Line # " + m_lineNumber + " Max Font Scale: " + m_maxFontScale + " Next line Scale: " + m_fontScale); //Debug.Log("LineInfo for line # " + (m_lineNumber) + " First character [" + m_textInfo.characterInfo[m_textInfo.lineInfo[m_lineNumber].firstCharacterIndex].character + "] at Index: " + m_textInfo.lineInfo[m_lineNumber].firstCharacterIndex + // " First visible character [" + m_textInfo.characterInfo[m_textInfo.lineInfo[m_lineNumber].firstVisibleCharacterIndex].character + "] at Index: " + m_textInfo.lineInfo[m_lineNumber].firstVisibleCharacterIndex + // " Last character [" + m_textInfo.characterInfo[m_textInfo.lineInfo[m_lineNumber].lastCharacterIndex].character + "] at index: " + m_textInfo.lineInfo[m_lineNumber].lastCharacterIndex + // " Last Visible character [" + m_textInfo.characterInfo[m_textInfo.lineInfo[m_lineNumber].lastVisibleCharacterIndex].character + "] at index: " + m_textInfo.lineInfo[m_lineNumber].lastVisibleCharacterIndex + // " Character Count of " + m_textInfo.lineInfo[m_lineNumber].characterCount /* + " Line Length of " + m_textInfo.lineInfo[m_lineNumber].lineLength + // " MinX: " + m_textInfo.lineInfo[m_lineNumber].lineExtents.min.x + " MinY: " + m_textInfo.lineInfo[m_lineNumber].lineExtents.min.y + // " MaxX: " + m_textInfo.lineInfo[m_lineNumber].lineExtents.max.x + " MaxY: " + m_textInfo.lineInfo[m_lineNumber].lineExtents.max.y + // " Line Ascender: " + lineAscender + " Line Descender: " + lineDescender */ ); // Add new line if not last lines or character. if (charCode == 10) { // Store the state of the line before starting on the new line. SaveWordWrappingState(ref m_SavedLineState, i, m_characterCount); // Store the state of the last Character before the new line. SaveWordWrappingState(ref m_SavedWordWrapState, i, m_characterCount); m_lineNumber += 1; isStartOfNewLine = true; // Check to make sure Array is large enough to hold a new line. if (m_lineNumber >= m_textInfo.lineInfo.Length) ResizeLineExtents(m_lineNumber); // Apply Line Spacing float scale = (m_style & FontStyles.Subscript) == FontStyles.Subscript || (m_style & FontStyles.Superscript) == FontStyles.Superscript ? m_maxFontScale : m_fontScale; lineOffsetDelta = 0 - face.Descender * m_maxFontScale + (face.Ascender + gap + m_lineSpacing + m_paragraphSpacing + m_lineSpacingDelta) * scale; m_lineOffset += lineOffsetDelta; previousLineMaxScale = m_maxFontScale; firstVisibleCharacterScale = scale; m_maxFontScale = 0; spriteScale = 1; m_xAdvance = 0 + tag_LineIndent + tag_Indent; ellipsisIndex = m_characterCount - 1; } } #endregion Check for Linefeed or Last Character // Store Rectangle positions for each Character and Mesh Extents. #region Save CharacterInfo for the current character. m_textInfo.characterInfo[m_characterCount].topLine = m_textInfo.characterInfo[m_characterCount].baseLine + m_currentFontAsset.fontInfo.Ascender * m_fontScale; // Ascender m_textInfo.characterInfo[m_characterCount].bottomLine = m_textInfo.characterInfo[m_characterCount].baseLine + m_currentFontAsset.fontInfo.Descender * m_fontScale; // Descender m_textInfo.characterInfo[m_characterCount].padding = padding * m_fontScale; m_textInfo.characterInfo[m_characterCount].aspectRatio = m_cached_GlyphInfo.width / m_cached_GlyphInfo.height; //m_textInfo.characterInfo[m_characterCount].scale = m_fontScale; // Determine the bounds of the Mesh. if (m_textInfo.characterInfo[m_characterCount].isVisible) { m_meshExtents.min = new Vector2(Mathf.Min(m_meshExtents.min.x, m_textInfo.characterInfo[m_characterCount].vertex_BL.position.x), Mathf.Min(m_meshExtents.min.y, m_textInfo.characterInfo[m_characterCount].vertex_BL.position.y)); m_meshExtents.max = new Vector2(Mathf.Max(m_meshExtents.max.x, m_textInfo.characterInfo[m_characterCount].vertex_TR.position.x), Mathf.Max(m_meshExtents.max.y, m_textInfo.characterInfo[m_characterCount].vertex_TL.position.y)); } // Save pageInfo Data if (charCode != 13 && charCode != 10 && m_pageNumber < 16) { m_textInfo.pageInfo[m_pageNumber].ascender = pageAscender; m_textInfo.pageInfo[m_pageNumber].descender = descender < m_textInfo.pageInfo[m_pageNumber].descender ? descender : m_textInfo.pageInfo[m_pageNumber].descender; //Debug.Log("Char [" + (char)charCode + "] with ASCII (" + charCode + ") on Page # " + m_pageNumber + " with Ascender: " + m_textInfo.pageInfo[m_pageNumber].ascender + ". Descender: " + m_textInfo.pageInfo[m_pageNumber].descender); if (m_pageNumber == 0 && m_characterCount == 0) m_textInfo.pageInfo[m_pageNumber].firstCharacterIndex = m_characterCount; else if (m_characterCount > 0 && m_pageNumber != m_textInfo.characterInfo[m_characterCount - 1].pageNumber) { m_textInfo.pageInfo[m_pageNumber - 1].lastCharacterIndex = m_characterCount - 1; m_textInfo.pageInfo[m_pageNumber].firstCharacterIndex = m_characterCount; } else if (m_characterCount == totalCharacterCount - 1) m_textInfo.pageInfo[m_pageNumber].lastCharacterIndex = m_characterCount; } #endregion Saving CharacterInfo // Save State of Mesh Creation for handling of Word Wrapping #region Save Word Wrapping State if (m_enableWordWrapping || m_overflowMode == TextOverflowModes.Truncate || m_overflowMode == TextOverflowModes.Ellipsis) { if ((charCode == 9 || charCode == 32) && !m_isNonBreakingSpace) { // We store the state of numerous variables for the most recent Space, LineFeed or Carriage Return to enable them to be restored // for Word Wrapping. SaveWordWrappingState(ref m_SavedWordWrapState, i, m_characterCount); m_isCharacterWrappingEnabled = false; isFirstWord = false; } else if (charCode > 0x2e80 && charCode < 0x9fff || m_fontAsset.lineBreakingInfo.leadingCharacters.ContainsKey(charCode) || m_fontAsset.lineBreakingInfo.followingCharacters.ContainsKey(charCode)) { if (m_characterCount < totalCharacterCount - 1 && m_fontAsset.lineBreakingInfo.leadingCharacters.ContainsKey(charCode) == false && m_fontAsset.lineBreakingInfo.followingCharacters.ContainsKey(m_VisibleCharacters[m_characterCount + 1]) == false) { SaveWordWrappingState(ref m_SavedWordWrapState, i, m_characterCount); m_isCharacterWrappingEnabled = false; isFirstWord = false; } } else if ((isFirstWord || m_isCharacterWrappingEnabled == true || isLastBreakingChar)) SaveWordWrappingState(ref m_SavedWordWrapState, i, m_characterCount); } #endregion Save Word Wrapping State m_characterCount += 1; } // Check Auto Sizing and increase font size to fill text container. #region Check Auto-Sizing (Upper Font Size Bounds) fontSizeDelta = m_maxFontSize - m_minFontSize; if (!m_isCharacterWrappingEnabled && m_enableAutoSizing && fontSizeDelta > 0.051f && m_fontSize < m_fontSizeMax) { m_minFontSize = m_fontSize; m_fontSize += Mathf.Max((m_maxFontSize - m_fontSize) / 2, 0.05f); m_fontSize = (int)(Mathf.Min(m_fontSize, m_fontSizeMax) * 20 + 0.5f) / 20f; if (loopCountA > 20) return; // Added to debug GenerateTextMesh(); return; } #endregion End Auto-sizing Check m_isCharacterWrappingEnabled = false; // Adjust Preferred Height to account for Margins. m_renderedHeight += m_margin.y > 0 ? m_margin.y : 0; if (m_renderMode == TextRenderFlags.GetPreferredSizes) return; if (!IsRectTransformDriven) { m_preferredWidth = m_renderedWidth; m_preferredHeight = m_renderedHeight; } // DEBUG & PERFORMANCE CHECKS (0.006ms) //Debug.Log("Iteration Count: " + loopCountA + ". Final Point Size: " + m_fontSize); // + " B: " + loopCountB + " C: " + loopCountC + " D: " + loopCountD); // If there are no visible characters... no need to continue if (m_visibleCharacterCount == 0 && m_visibleSpriteCount == 0) { m_uiRenderer.SetMesh(null); //Vector3[] vertices = m_textInfo.meshInfo.vertices; //if (vertices != null) //{ // Array.Clear(vertices, 0, vertices.Length); // m_mesh.vertices = vertices; //} return; } int last_vert_index = m_visibleCharacterCount * 4; // Partial clear of the vertices array to mark unused vertices as degenerate. Array.Clear(m_textInfo.meshInfo.vertices, last_vert_index, m_textInfo.meshInfo.vertices.Length - last_vert_index); // Do we want to clear the sprite array? // Handle Text Alignment #region Text Alignment switch (m_textAlignment) { // Top Vertically case TextAlignmentOptions.Top: case TextAlignmentOptions.TopLeft: case TextAlignmentOptions.TopJustified: case TextAlignmentOptions.TopRight: if (m_overflowMode != TextOverflowModes.Page) m_anchorOffset = m_rectCorners[1] + new Vector3(0 + margins.x, 0 - m_maxAscender - margins.y, 0); else m_anchorOffset = m_rectCorners[1] + new Vector3(0 + margins.x, 0 - m_textInfo.pageInfo[pageToDisplay].ascender - margins.y, 0); break; // Middle Vertically case TextAlignmentOptions.Left: case TextAlignmentOptions.Right: case TextAlignmentOptions.Center: case TextAlignmentOptions.Justified: if (m_overflowMode != TextOverflowModes.Page) m_anchorOffset = (m_rectCorners[0] + m_rectCorners[1]) / 2 + new Vector3(0 + margins.x, 0 - (m_maxAscender + margins.y + maxVisibleDescender - margins.w) / 2, 0); else m_anchorOffset = (m_rectCorners[0] + m_rectCorners[1]) / 2 + new Vector3(0 + margins.x, 0 - (m_textInfo.pageInfo[pageToDisplay].ascender + margins.y + m_textInfo.pageInfo[pageToDisplay].descender - margins.w) / 2, 0); break; // Bottom Vertically case TextAlignmentOptions.Bottom: case TextAlignmentOptions.BottomLeft: case TextAlignmentOptions.BottomRight: case TextAlignmentOptions.BottomJustified: if (m_overflowMode != TextOverflowModes.Page) m_anchorOffset = m_rectCorners[0] + new Vector3(0 + margins.x, 0 - maxVisibleDescender + margins.w, 0); else m_anchorOffset = m_rectCorners[0] + new Vector3(0 + margins.x, 0 - m_textInfo.pageInfo[pageToDisplay].descender + margins.w, 0); break; // Baseline Vertically case TextAlignmentOptions.Baseline: case TextAlignmentOptions.BaselineLeft: case TextAlignmentOptions.BaselineRight: case TextAlignmentOptions.BaselineJustified: m_anchorOffset = (m_rectCorners[0] + m_rectCorners[1]) / 2 + new Vector3(0 + margins.x, 0, 0); break; // Midline Vertically case TextAlignmentOptions.MidlineLeft: case TextAlignmentOptions.Midline: case TextAlignmentOptions.MidlineRight: case TextAlignmentOptions.MidlineJustified: m_anchorOffset = (m_rectCorners[0] + m_rectCorners[1]) / 2 + new Vector3(0 + margins.x, 0 - (m_meshExtents.max.y + margins.y + m_meshExtents.min.y - margins.w) / 2, 0); break; } #endregion Text Alignment // Initialization for Second Pass Vector3 justificationOffset = Vector3.zero; Vector3 offset = Vector3.zero; int vert_index_X4 = 0; int sprite_index_X4 = 0; //Array.Clear(m_meshAllocCount, 0, 17); int wordCount = 0; int lineCount = 0; int lastLine = 0; bool isStartOfWord = false; int wordFirstChar = 0; int wordLastChar = 0; // Second Pass : Line Justification, UV Mapping, Character & Line Visibility & more. #region Handle Line Justification & UV Mapping & Character Visibility & More // Variables used to handle Canvas Render Modes and SDF Scaling bool isCameraAssigned = m_canvas.worldCamera == null ? false : true; float lossyScale = m_rectTransform.lossyScale.z; RenderMode canvasRenderMode = m_canvas.renderMode; float canvasScaleFactor = m_canvas.scaleFactor; int underlineSegmentCount = 0; Color32 underlineColor = Color.white; Color32 strikethroughColor = Color.white; float underlineStartScale = 0; float underlineEndScale = 0; float underlineMaxScale = 0; float underlineBaseLine = Mathf.Infinity; int lastPage = 0; float strikethroughPointSize = 0; float strikethroughScale = 0; float strikethroughBaseline = 0; TMP_CharacterInfo[] characterInfos = m_textInfo.characterInfo; for (int i = 0; i < m_characterCount; i++) { int currentLine = characterInfos[i].lineNumber; char currentCharacter = characterInfos[i].character; TMP_LineInfo lineInfo = m_textInfo.lineInfo[currentLine]; TextAlignmentOptions lineAlignment = lineInfo.alignment; lineCount = currentLine + 1; // Process Line Justification #region Handle Line Justification //if (!characterInfos[i].isIgnoringAlignment) //{ switch (lineAlignment) { case TextAlignmentOptions.TopLeft: case TextAlignmentOptions.Left: case TextAlignmentOptions.BottomLeft: case TextAlignmentOptions.BaselineLeft: case TextAlignmentOptions.MidlineLeft: justificationOffset = new Vector3 (0 + lineInfo.marginLeft, 0, 0); break; case TextAlignmentOptions.Top: case TextAlignmentOptions.Center: case TextAlignmentOptions.Bottom: case TextAlignmentOptions.Baseline: case TextAlignmentOptions.Midline: justificationOffset = new Vector3(lineInfo.marginLeft + lineInfo.width / 2 - lineInfo.maxAdvance / 2, 0, 0); break; case TextAlignmentOptions.TopRight: case TextAlignmentOptions.Right: case TextAlignmentOptions.BottomRight: case TextAlignmentOptions.BaselineRight: case TextAlignmentOptions.MidlineRight: justificationOffset = new Vector3(lineInfo.marginLeft + lineInfo.width - lineInfo.maxAdvance, 0, 0); break; case TextAlignmentOptions.TopJustified: case TextAlignmentOptions.Justified: case TextAlignmentOptions.BottomJustified: case TextAlignmentOptions.BaselineJustified: case TextAlignmentOptions.MidlineJustified: charCode = m_textInfo.characterInfo[i].character; char lastCharOfCurrentLine = m_textInfo.characterInfo[lineInfo.lastCharacterIndex].character; if (/*char.IsWhiteSpace(lastCharOfCurrentLine) &&*/ !char.IsControl(lastCharOfCurrentLine) && currentLine < m_lineNumber) { // All lines are justified accept the last one. float gap = lineInfo.width - lineInfo.maxAdvance; if (currentLine != lastLine || i == 0) justificationOffset = new Vector3(lineInfo.marginLeft, 0, 0); else { if (charCode == 9 || charCode == 32 || charCode == 160) { int spaces = lineInfo.spaceCount - 1 > 0 ? lineInfo.spaceCount - 1 : 1; justificationOffset += new Vector3(gap * (1 - m_wordWrappingRatios) / (spaces), 0, 0); } else { justificationOffset += new Vector3(gap * m_wordWrappingRatios / (lineInfo.characterCount - lineInfo.spaceCount - 1), 0, 0); } } } else justificationOffset = new Vector3(lineInfo.marginLeft, 0, 0); // Keep last line left justified. //Debug.Log("Char [" + (char)charCode + "] Code:" + charCode + " Line # " + currentLine + " Offset:" + justificationOffset + " # Spaces:" + lineInfo.spaceCount + " # Characters:" + lineInfo.characterCount); break; } //} #endregion End Text Justification offset = m_anchorOffset + justificationOffset; // Handle Visible Characters #region Handle Visible Characters if (characterInfos[i].isVisible) { TMP_CharacterType type = characterInfos[i].type; switch (type) { // CHARACTERS case TMP_CharacterType.Character: Extents lineExtents = lineInfo.lineExtents; float uvOffset = (m_uvLineOffset * currentLine) % 1 + m_uvOffset.x; // Setup UV2 based on Character Mapping Options Selected #region Handle UV Mapping Options switch (m_horizontalMapping) { case TextureMappingOptions.Character: characterInfos[i].vertex_BL.uv2.x = 0 + m_uvOffset.x; characterInfos[i].vertex_TL.uv2.x = 0 + m_uvOffset.x; characterInfos[i].vertex_TR.uv2.x = 1 + m_uvOffset.x; characterInfos[i].vertex_BR.uv2.x = 1 + m_uvOffset.x; break; case TextureMappingOptions.Line: if (m_textAlignment != TextAlignmentOptions.Justified) { characterInfos[i].vertex_BL.uv2.x = (characterInfos[i].vertex_BL.position.x - lineExtents.min.x) / (lineExtents.max.x - lineExtents.min.x) + uvOffset; characterInfos[i].vertex_TL.uv2.x = (characterInfos[i].vertex_TL.position.x - lineExtents.min.x) / (lineExtents.max.x - lineExtents.min.x) + uvOffset; characterInfos[i].vertex_TR.uv2.x = (characterInfos[i].vertex_TR.position.x - lineExtents.min.x) / (lineExtents.max.x - lineExtents.min.x) + uvOffset; characterInfos[i].vertex_BR.uv2.x = (characterInfos[i].vertex_BR.position.x - lineExtents.min.x) / (lineExtents.max.x - lineExtents.min.x) + uvOffset; break; } else // Special Case if Justified is used in Line Mode. { characterInfos[i].vertex_BL.uv2.x = (characterInfos[i].vertex_BL.position.x + justificationOffset.x - m_meshExtents.min.x) / (m_meshExtents.max.x - m_meshExtents.min.x) + uvOffset; characterInfos[i].vertex_TL.uv2.x = (characterInfos[i].vertex_TL.position.x + justificationOffset.x - m_meshExtents.min.x) / (m_meshExtents.max.x - m_meshExtents.min.x) + uvOffset; characterInfos[i].vertex_TR.uv2.x = (characterInfos[i].vertex_TR.position.x + justificationOffset.x - m_meshExtents.min.x) / (m_meshExtents.max.x - m_meshExtents.min.x) + uvOffset; characterInfos[i].vertex_BR.uv2.x = (characterInfos[i].vertex_BR.position.x + justificationOffset.x - m_meshExtents.min.x) / (m_meshExtents.max.x - m_meshExtents.min.x) + uvOffset; break; } case TextureMappingOptions.Paragraph: characterInfos[i].vertex_BL.uv2.x = (characterInfos[i].vertex_BL.position.x + justificationOffset.x - m_meshExtents.min.x) / (m_meshExtents.max.x - m_meshExtents.min.x) + uvOffset; characterInfos[i].vertex_TL.uv2.x = (characterInfos[i].vertex_TL.position.x + justificationOffset.x - m_meshExtents.min.x) / (m_meshExtents.max.x - m_meshExtents.min.x) + uvOffset; characterInfos[i].vertex_TR.uv2.x = (characterInfos[i].vertex_TR.position.x + justificationOffset.x - m_meshExtents.min.x) / (m_meshExtents.max.x - m_meshExtents.min.x) + uvOffset; characterInfos[i].vertex_BR.uv2.x = (characterInfos[i].vertex_BR.position.x + justificationOffset.x - m_meshExtents.min.x) / (m_meshExtents.max.x - m_meshExtents.min.x) + uvOffset; break; case TextureMappingOptions.MatchAspect: switch (m_verticalMapping) { case TextureMappingOptions.Character: characterInfos[i].vertex_BL.uv2.y = 0 + m_uvOffset.y; characterInfos[i].vertex_TL.uv2.y = 1 + m_uvOffset.y; characterInfos[i].vertex_TR.uv2.y = 0 + m_uvOffset.y; characterInfos[i].vertex_BR.uv2.y = 1 + m_uvOffset.y; break; case TextureMappingOptions.Line: characterInfos[i].vertex_BL.uv2.y = (characterInfos[i].vertex_BL.position.y - lineExtents.min.y) / (lineExtents.max.y - lineExtents.min.y) + uvOffset; characterInfos[i].vertex_TL.uv2.y = (characterInfos[i].vertex_TL.position.y - lineExtents.min.y) / (lineExtents.max.y - lineExtents.min.y) + uvOffset; characterInfos[i].vertex_TR.uv2.y = characterInfos[i].vertex_BL.uv2.y; characterInfos[i].vertex_BR.uv2.y = characterInfos[i].vertex_TL.uv2.y; break; case TextureMappingOptions.Paragraph: characterInfos[i].vertex_BL.uv2.y = (characterInfos[i].vertex_BL.position.y - m_meshExtents.min.y) / (m_meshExtents.max.y - m_meshExtents.min.y) + uvOffset; characterInfos[i].vertex_TL.uv2.y = (characterInfos[i].vertex_TL.position.y - m_meshExtents.min.y) / (m_meshExtents.max.y - m_meshExtents.min.y) + uvOffset; characterInfos[i].vertex_TR.uv2.y = characterInfos[i].vertex_BL.uv2.y; characterInfos[i].vertex_BR.uv2.y = characterInfos[i].vertex_TL.uv2.y; break; case TextureMappingOptions.MatchAspect: Debug.Log("ERROR: Cannot Match both Vertical & Horizontal."); break; } //float xDelta = 1 - (_uv2s[vert_index + 0].y * textMeshCharacterInfo[i].AspectRatio); // Left aligned float xDelta = (1 - ((characterInfos[i].vertex_BL.uv2.y + characterInfos[i].vertex_TL.uv2.y) * characterInfos[i].aspectRatio)) / 2; // Center of Rectangle characterInfos[i].vertex_BL.uv2.x = (characterInfos[i].vertex_BL.uv2.y * characterInfos[i].aspectRatio) + xDelta + uvOffset; characterInfos[i].vertex_TL.uv2.x = characterInfos[i].vertex_BL.uv2.x; characterInfos[i].vertex_TR.uv2.x = (characterInfos[i].vertex_TL.uv2.y * characterInfos[i].aspectRatio) + xDelta + uvOffset; characterInfos[i].vertex_BR.uv2.x = characterInfos[i].vertex_TR.uv2.x; break; } switch (m_verticalMapping) { case TextureMappingOptions.Character: characterInfos[i].vertex_BL.uv2.y = 0 + m_uvOffset.y; characterInfos[i].vertex_TL.uv2.y = 1 + m_uvOffset.y; characterInfos[i].vertex_TR.uv2.y = 1 + m_uvOffset.y; characterInfos[i].vertex_BR.uv2.y = 0 + m_uvOffset.y; break; case TextureMappingOptions.Line: characterInfos[i].vertex_BL.uv2.y = (characterInfos[i].vertex_BL.position.y - lineExtents.min.y) / (lineExtents.max.y - lineExtents.min.y) + m_uvOffset.y; characterInfos[i].vertex_TL.uv2.y = (characterInfos[i].vertex_TL.position.y - lineExtents.min.y) / (lineExtents.max.y - lineExtents.min.y) + m_uvOffset.y; characterInfos[i].vertex_BR.uv2.y = characterInfos[i].vertex_BL.uv2.y; characterInfos[i].vertex_TR.uv2.y = characterInfos[i].vertex_TL.uv2.y; break; case TextureMappingOptions.Paragraph: characterInfos[i].vertex_BL.uv2.y = (characterInfos[i].vertex_BL.position.y - m_meshExtents.min.y) / (m_meshExtents.max.y - m_meshExtents.min.y) + m_uvOffset.y; characterInfos[i].vertex_TL.uv2.y = (characterInfos[i].vertex_TL.position.y - m_meshExtents.min.y) / (m_meshExtents.max.y - m_meshExtents.min.y) + m_uvOffset.y; characterInfos[i].vertex_BR.uv2.y = characterInfos[i].vertex_BL.uv2.y; characterInfos[i].vertex_TR.uv2.y = characterInfos[i].vertex_TL.uv2.y; break; case TextureMappingOptions.MatchAspect: //float yDelta = 1 - (_uv2s[vert_index + 2].x / textMeshCharacterInfo[i].AspectRatio); // Top Corner float yDelta = (1 - ((characterInfos[i].vertex_BL.uv2.x + characterInfos[i].vertex_TR.uv2.x) / characterInfos[i].aspectRatio)) / 2; // Center of Rectangle //float yDelta = 0; characterInfos[i].vertex_BL.uv2.y = yDelta + (characterInfos[i].vertex_BL.uv2.x / characterInfos[i].aspectRatio) + m_uvOffset.y; characterInfos[i].vertex_TL.uv2.y = yDelta + (characterInfos[i].vertex_TR.uv2.x / characterInfos[i].aspectRatio) + m_uvOffset.y; characterInfos[i].vertex_BR.uv2.y = characterInfos[i].vertex_BL.uv2.y; characterInfos[i].vertex_TR.uv2.y = characterInfos[i].vertex_TL.uv2.y; break; } #endregion End UV Mapping Options // Pack UV's so that we can pass Xscale needed for Shader to maintain 1:1 ratio. #region Pack Scale into UV2 float xScale = characterInfos[i].scale * (1 - m_charWidthAdjDelta); if ((characterInfos[i].style & FontStyles.Bold) == FontStyles.Bold) xScale *= -1; switch (canvasRenderMode) { case RenderMode.ScreenSpaceOverlay: xScale *= lossyScale / canvasScaleFactor; break; case RenderMode.ScreenSpaceCamera: xScale *= isCameraAssigned ? lossyScale : 1; break; case RenderMode.WorldSpace: xScale *= lossyScale; break; } float x0 = characterInfos[i].vertex_BL.uv2.x; float y0 = characterInfos[i].vertex_BL.uv2.y; float x1 = characterInfos[i].vertex_TR.uv2.x; float y1 = characterInfos[i].vertex_TR.uv2.y; float dx = Mathf.Floor(x0); float dy = Mathf.Floor(y0); x0 = x0 - dx; x1 = x1 - dx; y0 = y0 - dy; y1 = y1 - dy; characterInfos[i].vertex_BL.uv2 = PackUV(x0, y0, xScale); characterInfos[i].vertex_TL.uv2 = PackUV(x0, y1, xScale); characterInfos[i].vertex_TR.uv2 = PackUV(x1, y1, xScale); characterInfos[i].vertex_BR.uv2 = PackUV(x1, y0, xScale); #endregion break; // SPRITES case TMP_CharacterType.Sprite: // Nothing right now break; } // Handle maxVisibleCharacters, maxVisibleLines and Overflow Page Mode. #region Handle maxVisibleCharacters / maxVisibleLines / Page Mode if (i < m_maxVisibleCharacters && currentLine < m_maxVisibleLines && m_overflowMode != TextOverflowModes.Page) { characterInfos[i].vertex_BL.position += offset; characterInfos[i].vertex_TL.position += offset; characterInfos[i].vertex_TR.position += offset; characterInfos[i].vertex_BR.position += offset; } else if (i < m_maxVisibleCharacters && currentLine < m_maxVisibleLines && m_overflowMode == TextOverflowModes.Page && characterInfos[i].pageNumber == pageToDisplay) { characterInfos[i].vertex_BL.position += offset; characterInfos[i].vertex_TL.position += offset; characterInfos[i].vertex_TR.position += offset; characterInfos[i].vertex_BR.position += offset; } else { characterInfos[i].vertex_BL.position *= 0; characterInfos[i].vertex_TL.position *= 0; characterInfos[i].vertex_TR.position *= 0; characterInfos[i].vertex_BR.position *= 0; } #endregion // Fill Vertex Buffers for the various types of element if (type == TMP_CharacterType.Character) { FillCharacterVertexBuffers(i, vert_index_X4); vert_index_X4 += 4; } else if (type == TMP_CharacterType.Sprite) { FillSpriteVertexBuffers(i, sprite_index_X4); sprite_index_X4 += 4; } } #endregion // Apply Alignment and Justification Offset m_textInfo.characterInfo[i].bottomLeft += offset; m_textInfo.characterInfo[i].topLeft += offset; m_textInfo.characterInfo[i].topRight += offset; m_textInfo.characterInfo[i].bottomRight += offset; // Need to add top left and bottom right. m_textInfo.characterInfo[i].topLine += offset.y; m_textInfo.characterInfo[i].bottomLine += offset.y; m_textInfo.characterInfo[i].baseLine += offset.y; // Store Max Ascender & Descender if (currentCharacter != 10 && currentCharacter != 13) { m_textInfo.lineInfo[currentLine].ascender = m_textInfo.characterInfo[i].topLine > m_textInfo.lineInfo[currentLine].ascender ? m_textInfo.characterInfo[i].topLine : m_textInfo.lineInfo[currentLine].ascender; m_textInfo.lineInfo[currentLine].descender = m_textInfo.characterInfo[i].bottomLine < m_textInfo.lineInfo[currentLine].descender ? m_textInfo.characterInfo[i].bottomLine : m_textInfo.lineInfo[currentLine].descender; } // Need to recompute lineExtent to account for the offset from justification. #region Adjust lineExtents resulting from alignment offset if (currentLine != lastLine || i == m_characterCount - 1) { // Update the previous line's extents if (currentLine != lastLine) { m_textInfo.lineInfo[lastLine].lineExtents.min = new Vector2(m_textInfo.characterInfo[m_textInfo.lineInfo[lastLine].firstCharacterIndex].bottomLeft.x, m_textInfo.lineInfo[lastLine].descender); m_textInfo.lineInfo[lastLine].lineExtents.max = new Vector2(m_textInfo.characterInfo[m_textInfo.lineInfo[lastLine].lastVisibleCharacterIndex].topRight.x, m_textInfo.lineInfo[lastLine].ascender); } // Update the current line's extents if (i == m_characterCount - 1) { m_textInfo.lineInfo[currentLine].lineExtents.min = new Vector2(m_textInfo.characterInfo[m_textInfo.lineInfo[currentLine].firstCharacterIndex].bottomLeft.x, m_textInfo.lineInfo[currentLine].descender); m_textInfo.lineInfo[currentLine].lineExtents.max = new Vector2(m_textInfo.characterInfo[m_textInfo.lineInfo[currentLine].lastVisibleCharacterIndex].topRight.x, m_textInfo.lineInfo[currentLine].ascender); } } #endregion // Track Word Count per line and for the object #region Track Word Count if (char.IsLetterOrDigit(currentCharacter) || currentCharacter == 39 || currentCharacter == 8217) { if (isStartOfWord == false) { isStartOfWord = true; wordFirstChar = i; } // If last character is a word if (isStartOfWord && i == m_characterCount - 1) { wordLastChar = i; wordCount += 1; m_textInfo.lineInfo[currentLine].wordCount += 1; TMP_WordInfo wordInfo = new TMP_WordInfo(); wordInfo.firstCharacterIndex = wordFirstChar; wordInfo.lastCharacterIndex = wordLastChar; wordInfo.characterCount = wordLastChar - wordFirstChar + 1; m_textInfo.wordInfo.Add(wordInfo); } } else if (isStartOfWord || i == 0 && (char.IsPunctuation(currentCharacter) || char.IsWhiteSpace(currentCharacter) || i == m_characterCount - 1)) { wordLastChar = i == m_characterCount - 1 && char.IsLetterOrDigit(currentCharacter) ? i : i - 1; isStartOfWord = false; wordCount += 1; m_textInfo.lineInfo[currentLine].wordCount += 1; TMP_WordInfo wordInfo = new TMP_WordInfo(); wordInfo.firstCharacterIndex = wordFirstChar; wordInfo.lastCharacterIndex = wordLastChar; wordInfo.characterCount = wordLastChar - wordFirstChar + 1; m_textInfo.wordInfo.Add(wordInfo); } #endregion // Setup & Handle Underline #region Underline // NOTE: Need to figure out how underline will be handled with multiple fonts and which font will be used for the underline. bool isUnderline = (m_textInfo.characterInfo[i].style & FontStyles.Underline) == FontStyles.Underline; if (isUnderline) { bool isUnderlineVisible = true; int currentPage = m_textInfo.characterInfo[i].pageNumber; if (i > m_maxVisibleCharacters || currentLine > m_maxVisibleLines || (m_overflowMode == TextOverflowModes.Page && currentPage + 1 != m_pageToDisplay)) isUnderlineVisible = false; // We only use the scale of visible characters. if (currentCharacter != 10 && currentCharacter != 13 && currentCharacter != 32 && currentCharacter != 160) { underlineMaxScale = Mathf.Max(underlineMaxScale, m_textInfo.characterInfo[i].scale); underlineBaseLine = Mathf.Min(currentPage == lastPage ? underlineBaseLine : Mathf.Infinity, m_textInfo.characterInfo[i].baseLine + font.fontInfo.Underline * underlineMaxScale); lastPage = currentPage; // Need to track pages to ensure we reset baseline for the new pages. } if (beginUnderline == false && isUnderlineVisible == true && i <= lineInfo.lastVisibleCharacterIndex && currentCharacter != 10 && currentCharacter != 13) { if (i == lineInfo.lastVisibleCharacterIndex && (currentCharacter == 32 || currentCharacter == 160)) { } else { beginUnderline = true; underlineStartScale = m_textInfo.characterInfo[i].scale; if (underlineMaxScale == 0) underlineMaxScale = underlineStartScale; underline_start = new Vector3(m_textInfo.characterInfo[i].bottomLeft.x, underlineBaseLine, 0); underlineColor = m_textInfo.characterInfo[i].color; } } // End Underline if text only contains one character. if (beginUnderline && m_characterCount == 1) { beginUnderline = false; underline_end = new Vector3(m_textInfo.characterInfo[i].topRight.x, underlineBaseLine, 0); underlineEndScale = m_textInfo.characterInfo[i].scale; DrawUnderlineMesh(underline_start, underline_end, ref last_vert_index, underlineStartScale, underlineEndScale, underlineMaxScale, underlineColor); underlineSegmentCount += 1; underlineMaxScale = 0; underlineBaseLine = Mathf.Infinity; } else if (beginUnderline && (i == lineInfo.lastCharacterIndex || i >= lineInfo.lastVisibleCharacterIndex)) { // Terminate underline at previous visible character if space or carriage return. if (currentCharacter == 10 || currentCharacter == 13 || currentCharacter == 32 || currentCharacter == 160) { int lastVisibleCharacterIndex = lineInfo.lastVisibleCharacterIndex; underline_end = new Vector3(m_textInfo.characterInfo[lastVisibleCharacterIndex].topRight.x, underlineBaseLine, 0); underlineEndScale = m_textInfo.characterInfo[lastVisibleCharacterIndex].scale; } else { // End underline if last character of the line. underline_end = new Vector3(m_textInfo.characterInfo[i].topRight.x, underlineBaseLine, 0); underlineEndScale = m_textInfo.characterInfo[i].scale; } beginUnderline = false; DrawUnderlineMesh(underline_start, underline_end, ref last_vert_index, underlineStartScale, underlineEndScale, underlineMaxScale, underlineColor); underlineSegmentCount += 1; underlineMaxScale = 0; underlineBaseLine = Mathf.Infinity; } else if (beginUnderline && !isUnderlineVisible) { beginUnderline = false; underline_end = new Vector3(m_textInfo.characterInfo[i - 1].topRight.x, underlineBaseLine, 0); underlineEndScale = m_textInfo.characterInfo[i - 1].scale; DrawUnderlineMesh(underline_start, underline_end, ref last_vert_index, underlineStartScale, underlineEndScale, underlineMaxScale, underlineColor); underlineSegmentCount += 1; underlineMaxScale = 0; underlineBaseLine = Mathf.Infinity; } } else { // End Underline if (beginUnderline == true) { beginUnderline = false; underline_end = new Vector3(m_textInfo.characterInfo[i - 1].topRight.x, underlineBaseLine, 0); underlineEndScale = m_textInfo.characterInfo[i - 1].scale; DrawUnderlineMesh(underline_start, underline_end, ref last_vert_index, underlineStartScale, underlineEndScale, underlineMaxScale, underlineColor); underlineSegmentCount += 1; underlineMaxScale = 0; underlineBaseLine = Mathf.Infinity; } } #endregion // Setup & Handle Strikethrough #region Strikethrough // NOTE: Need to figure out how underline will be handled with multiple fonts and which font will be used for the underline. bool isStrikethrough = (m_textInfo.characterInfo[i].style & FontStyles.Strikethrough) == FontStyles.Strikethrough; if (isStrikethrough) { bool isStrikeThroughVisible = true; if (i > m_maxVisibleCharacters || currentLine > m_maxVisibleLines || (m_overflowMode == TextOverflowModes.Page && m_textInfo.characterInfo[i].pageNumber + 1 != m_pageToDisplay)) isStrikeThroughVisible = false; if (beginStrikethrough == false && isStrikeThroughVisible && i <= lineInfo.lastVisibleCharacterIndex && currentCharacter != 10 && currentCharacter != 13) { if (i == lineInfo.lastVisibleCharacterIndex && (currentCharacter == 32 || currentCharacter == 160)) { } else { beginStrikethrough = true; strikethroughPointSize = m_textInfo.characterInfo[i].pointSize; strikethroughScale = m_textInfo.characterInfo[i].scale; strikethrough_start = new Vector3(m_textInfo.characterInfo[i].bottomLeft.x, m_textInfo.characterInfo[i].baseLine + (font.fontInfo.Ascender + font.fontInfo.Descender) / 2.75f * strikethroughScale, 0); strikethroughColor = m_textInfo.characterInfo[i].color; strikethroughBaseline = m_textInfo.characterInfo[i].baseLine; //Debug.Log("Char [" + currentCharacter + "] Start Strikethrough POS: " + strikethrough_start); } } // End Strikethrough if text only contains one character. if (beginStrikethrough && m_characterCount == 1) { beginStrikethrough = false; strikethrough_end = new Vector3(m_textInfo.characterInfo[i].topRight.x, m_textInfo.characterInfo[i].baseLine + (font.fontInfo.Ascender + font.fontInfo.Descender) / 2 * strikethroughScale, 0); DrawUnderlineMesh(strikethrough_start, strikethrough_end, ref last_vert_index, strikethroughScale, strikethroughScale, strikethroughScale, strikethroughColor); underlineSegmentCount += 1; } else if (beginStrikethrough && i == lineInfo.lastCharacterIndex) { // Terminate Strikethrough at previous visible character if space or carriage return. if (currentCharacter == 10 || currentCharacter == 13 || currentCharacter == 32 || currentCharacter == 160) { int lastVisibleCharacterIndex = lineInfo.lastVisibleCharacterIndex; strikethrough_end = new Vector3(m_textInfo.characterInfo[lastVisibleCharacterIndex].topRight.x, m_textInfo.characterInfo[lastVisibleCharacterIndex].baseLine + (font.fontInfo.Ascender + font.fontInfo.Descender) / 2 * strikethroughScale, 0); } else { // Terminate Strikethrough at last character of line. strikethrough_end = new Vector3(m_textInfo.characterInfo[i].topRight.x, m_textInfo.characterInfo[i].baseLine + (font.fontInfo.Ascender + font.fontInfo.Descender) / 2 * strikethroughScale, 0); } beginStrikethrough = false; DrawUnderlineMesh(strikethrough_start, strikethrough_end, ref last_vert_index, strikethroughScale, strikethroughScale, strikethroughScale, strikethroughColor); underlineSegmentCount += 1; } else if (beginStrikethrough && i < m_characterCount && (m_textInfo.characterInfo[i + 1].pointSize != strikethroughPointSize || !TMP_Math.Equals(m_textInfo.characterInfo[i + 1].baseLine + offset.y, strikethroughBaseline))) { // Terminate Strikethrough if scale changes. beginStrikethrough = false; int lastVisibleCharacterIndex = lineInfo.lastVisibleCharacterIndex; if (i > lastVisibleCharacterIndex) strikethrough_end = new Vector3(m_textInfo.characterInfo[lastVisibleCharacterIndex].topRight.x, m_textInfo.characterInfo[lastVisibleCharacterIndex].baseLine + (font.fontInfo.Ascender + font.fontInfo.Descender) / 2 * strikethroughScale, 0); else strikethrough_end = new Vector3(m_textInfo.characterInfo[i].topRight.x, m_textInfo.characterInfo[i].baseLine + (font.fontInfo.Ascender + font.fontInfo.Descender) / 2 * strikethroughScale, 0); DrawUnderlineMesh(strikethrough_start, strikethrough_end, ref last_vert_index, strikethroughScale, strikethroughScale, strikethroughScale, strikethroughColor); underlineSegmentCount += 1; //Debug.Log("Char [" + currentCharacter + "] at Index: " + i + " End Strikethrough POS: " + strikethrough_end + " Baseline: " + m_textInfo.characterInfo[i].baseLine.ToString("f3")); } else if (beginStrikethrough && !isStrikeThroughVisible) { // Terminate Strikethrough if character is not visible. beginStrikethrough = false; strikethrough_end = new Vector3(m_textInfo.characterInfo[i - 1].topRight.x, m_textInfo.characterInfo[i - 1].baseLine + (font.fontInfo.Ascender + font.fontInfo.Descender) / 2 * strikethroughScale, 0); DrawUnderlineMesh(strikethrough_start, strikethrough_end, ref last_vert_index, strikethroughScale, strikethroughScale, strikethroughScale, strikethroughColor); underlineSegmentCount += 1; } } else { // End Underline if (beginStrikethrough == true) { beginStrikethrough = false; strikethrough_end = new Vector3(m_textInfo.characterInfo[i - 1].topRight.x, m_textInfo.characterInfo[i - 1].baseLine + (font.fontInfo.Ascender + font.fontInfo.Descender) / 2 * m_fontScale, 0); DrawUnderlineMesh(strikethrough_start, strikethrough_end, ref last_vert_index, strikethroughScale, strikethroughScale, strikethroughScale, strikethroughColor); underlineSegmentCount += 1; } } #endregion lastLine = currentLine; } #endregion // METRICS ABOUT THE TEXT OBJECT m_textInfo.characterCount = (short)m_characterCount; m_textInfo.spriteCount = m_spriteCount; m_textInfo.lineCount = (short)lineCount; m_textInfo.wordCount = wordCount != 0 && m_characterCount > 0 ? (short)wordCount : (short)1; m_textInfo.pageCount = m_pageNumber + 1; // If Advanced Layout Component is present, don't upload the mesh. if (m_renderMode == TextRenderFlags.Render) // m_isAdvanceLayoutComponentPresent == false || m_advancedLayoutComponent.isEnabled == false) { //Debug.Log("Uploading Mesh normally."); // Upload Mesh Data m_mesh.vertices = m_textInfo.meshInfo.vertices; m_mesh.uv = m_textInfo.meshInfo.uvs0; m_mesh.uv2 = m_textInfo.meshInfo.uvs2; m_mesh.colors32 = m_textInfo.meshInfo.colors32; m_mesh.RecalculateBounds(); // Replace by manual bound calculation to improve performance. m_uiRenderer.SetMesh(m_mesh); if (m_inlineGraphics != null) m_inlineGraphics.DrawSprite(m_inlineGraphics.uiVertex, m_visibleSpriteCount); } // Compute Bounds for the mesh. Manual computation is more efficient then using Mesh.recalcualteBounds. m_bounds = new Bounds(new Vector3((m_meshExtents.max.x + m_meshExtents.min.x) / 2, (m_meshExtents.max.y + m_meshExtents.min.y) / 2, 0) + offset, new Vector3(m_meshExtents.max.x - m_meshExtents.min.x, m_meshExtents.max.y - m_meshExtents.min.y, 0)); // Has Text Container's Width or Height been specified by the user? /* if (m_rectTransform.sizeDelta.x == 0 || m_rectTransform.sizeDelta.y == 0) { //Debug.Log("Auto-fitting Text. Default Width:" + m_textContainer.isDefaultWidth + " Default Height:" + m_textContainer.isDefaultHeight); if (marginWidth == 0) m_rectTransform.sizeDelta = new Vector2(m_preferredWidth + margins.x + margins.z, m_rectTransform.sizeDelta.y); if (marginHeight == 0) m_rectTransform.sizeDelta = new Vector2(m_rectTransform.sizeDelta.x, m_preferredHeight + margins.y + margins.w); Debug.Log("Auto-fitting Text. Default Width:" + m_preferredWidth + " Default Height:" + m_preferredHeight); GenerateTextMesh(); return; } */ //for (int i = 0; i < m_lineNumber + 1; i++) //{ // Debug.Log("Line: " + (i + 1) + " Character Count: " + m_textInfo.lineInfo[i].characterCount // + " Word Count: " + m_textInfo.lineInfo[i].wordCount // + " Space Count: " + m_textInfo.lineInfo[i].spaceCount // + " First: [" + m_textInfo.characterInfo[m_textInfo.lineInfo[i].firstCharacterIndex].character + "] at Index: " + m_textInfo.lineInfo[i].firstCharacterIndex // + " First Visible: [" + m_textInfo.characterInfo[m_textInfo.lineInfo[i].firstVisibleCharacterIndex].character + "] at Index: " + m_textInfo.lineInfo[i].firstVisibleCharacterIndex // + " Last [" + m_textInfo.characterInfo[m_textInfo.lineInfo[i].lastCharacterIndex].character + "] at Index: " + m_textInfo.lineInfo[i].lastCharacterIndex // + " Last visible [" + m_textInfo.characterInfo[m_textInfo.lineInfo[i].lastVisibleCharacterIndex].character + "] at Index: " + m_textInfo.lineInfo[i].lastVisibleCharacterIndex // + " Length: " + m_textInfo.lineInfo[i].lineLength // + " Line Extents: " + m_textInfo.lineInfo[i].lineExtents); //} //Debug.Log("Done rendering text. Character Count is " + m_textInfo.characterCount); //Debug.Log("Done rendering text. Preferred Width:" + m_preferredWidth + " Preferred Height:" + m_preferredHeight); // Event indicating the text has been regenerated. TMPro_EventManager.ON_TEXT_CHANGED(this); //Debug.Log(m_minWidth); //Profiler.EndSample(); //m_StopWatch.Stop(); //Debug.Log("Done Rendering Text."); //Debug.Log("TimeElapsed is:" + (m_StopWatch.ElapsedTicks / 10000f).ToString("f4")); //m_StopWatch.Reset(); }
public static void ON_FONT_PROPERTY_CHANGED(bool isChanged, TextMeshProFont font) { FONT_PROPERTY_EVENT.Call(isChanged, font); }
public static void ON_FONT_PROPERTY_CHANGED(bool isChanged, TextMeshProFont font) { if (FONT_PROPERTY_EVENT != null) FONT_PROPERTY_EVENT(isChanged, font); }
//void OnPrefabUpdated(GameObject obj) //{ // Debug.Log("Prefab ID " + obj.name + " has been updated. Mesh ID " + m_mesh.GetInstanceID()); // //if (obj.GetInstanceID() == gameObject.GetInstanceID()) // //{ // // if (m_meshFilter.sharedMesh.GetInstanceID() != m_mesh.GetInstanceID()) // // m_mesh = m_meshFilter.sharedMesh; // //} //} // Function which loads either the default font or a newly assigned font asset. This function also assigned the appropriate material to the renderer. void LoadFontAsset() { //Debug.Log("TextMeshPro LoadFontAsset() has been called."); // Current Font Asset is " + (font != null ? font.name: "Null") ); ShaderUtilities.GetShaderPropertyIDs(); // Initialize & Get shader property IDs. if (m_fontAsset == null) { // Load TMP_Settings TMP_Settings settings = Resources.Load("TMP Settings") as TMP_Settings; if (settings != null && settings.fontAsset != null) m_fontAsset = settings.fontAsset; else m_fontAsset = Resources.Load("Fonts & Materials/ARIAL SDF", typeof(TextMeshProFont)) as TextMeshProFont; if (m_fontAsset == null) { Debug.LogWarning("The ARIAL SDF Font Asset was not found. There is no Font Asset assigned to " + gameObject.name + ".", this); return; } if (m_fontAsset.characterDictionary == null) { Debug.Log("Dictionary is Null!"); } m_renderer.sharedMaterial = m_fontAsset.material; m_sharedMaterial = m_fontAsset.material; m_sharedMaterial.SetFloat("_CullMode", 0); m_sharedMaterial.SetFloat("_ZTestMode", 4); m_renderer.receiveShadows = false; m_renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; // true; // Get a Reference to the Shader } else { if (m_fontAsset.characterDictionary == null) { //Debug.Log("Reading Font Definition and Creating Character Dictionary."); m_fontAsset.ReadFontDefinition(); } //Debug.Log("Font Asset name:" + font.material.name); // If font atlas texture doesn't match the assigned material font atlas, switch back to default material specified in the Font Asset. if (m_renderer.sharedMaterial == null || m_renderer.sharedMaterial.mainTexture == null || m_fontAsset.atlas.GetInstanceID() != m_renderer.sharedMaterial.GetTexture(ShaderUtilities.ID_MainTex).GetInstanceID()) { m_renderer.sharedMaterial = m_fontAsset.material; m_sharedMaterial = m_fontAsset.material; } else { m_sharedMaterial = m_renderer.sharedMaterial; } //m_sharedMaterial.SetFloat("_CullMode", 0); m_sharedMaterial.SetFloat("_ZTestMode", 4); // Check if we are using the SDF Surface Shader if (m_sharedMaterial.passCount > 1) { m_renderer.receiveShadows = true; m_renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On; } else { m_renderer.receiveShadows = false; m_renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; } } m_padding = ShaderUtilities.GetPadding(m_renderer.sharedMaterials, m_enableExtraPadding, m_isUsingBold); //m_alignmentPadding = ShaderUtilities.GetFontExtent(m_sharedMaterial); m_isMaskingEnabled = ShaderUtilities.IsMaskingEnabled(m_sharedMaterial); if (!m_fontAsset.characterDictionary.TryGetValue(95, out m_cached_Underline_GlyphInfo)) //95 Debug.LogWarning("Underscore character wasn't found in the current Font Asset. No characters assigned for Underline.", this); // Add Font Asset and Material to dictionaries if (!m_fontAsset_Dict.ContainsKey(m_fontAsset.fontHashCode)) m_fontAsset_Dict.Add(m_fontAsset.fontHashCode, m_fontAsset); int materialHashCode = TMP_TextUtilities.GetSimpleHashCode(m_sharedMaterial.name); if (!m_fontMaterial_Dict.ContainsKey(materialHashCode)) m_fontMaterial_Dict.Add(materialHashCode, m_sharedMaterial); m_sharedMaterials.Add(m_sharedMaterial); // Hide Material Editor Component //m_renderer.sharedMaterial.hideFlags = HideFlags.None; }
// Function which loads either the default font or a newly assigned font asset. This function also assigned the appropriate material to the renderer. void LoadFontAsset() { //Debug.Log("***** LoadFontAsset() *****"); //TextMeshPro LoadFontAsset() has been called."); // Current Font Asset is " + (font != null ? font.name: "Null") ); ShaderUtilities.GetShaderPropertyIDs(); if (m_fontAsset == null) { //Debug.LogWarning("No Font Asset has been assigned. Loading Default Arial SDF Font."); m_fontAsset = Resources.Load("Fonts & Materials/ARIAL SDF", typeof(TextMeshProFont)) as TextMeshProFont; if (m_fontAsset == null) { Debug.LogWarning("There is no Font Asset assigned to " + gameObject.name + "."); return; } if (m_fontAsset.characterDictionary == null) { Debug.Log("Dictionary is Null!"); } //m_uiRenderer.SetMaterial(m_fontAsset.material, null); m_sharedMaterial = m_fontAsset.material; m_baseMaterial = m_sharedMaterial; m_isNewBaseMaterial = true; //m_renderer.receiveShadows = false; //m_renderer.castShadows = false; // true; // Get a Reference to the Shader } else { if (m_fontAsset.characterDictionary == null) { //Debug.Log("Reading Font Definition and Creating Character Dictionary."); m_fontAsset.ReadFontDefinition(); } // Force the use of the base material m_sharedMaterial = m_baseMaterial; m_isNewBaseMaterial = true; // If font atlas texture doesn't match the assigned material font atlas, switch back to default material specified in the Font Asset. if (m_sharedMaterial == null || m_sharedMaterial.mainTexture == null || m_fontAsset.atlas.GetInstanceID() != m_sharedMaterial.mainTexture.GetInstanceID()) { m_sharedMaterial = m_fontAsset.material; m_baseMaterial = m_sharedMaterial; m_isNewBaseMaterial = true; } else { // Loading the same font asset. //m_sharedMaterial = m_baseMaterial; } //m_sharedMaterial.SetFloat("_CullMode", 0); //m_sharedMaterial.SetFloat("_ZTestMode", 4); // Check if we are using the SDF Surface Shader if (m_sharedMaterial.passCount > 1) { //m_renderer.receiveShadows = false; //m_renderer.castShadows = true; } else { //m_renderer.receiveShadows = false; //m_renderer.castShadows = false; } } // Check & Assign Underline Character for use with the Underline tag. if (!m_fontAsset.characterDictionary.TryGetValue(95, out m_cached_Underline_GlyphInfo)) //95 Debug.LogWarning("Underscore character wasn't found in the current Font Asset. No characters assigned for Underline."); fontSharedMaterial = m_sharedMaterial; m_sharedMaterials.Add(m_sharedMaterial); // Might be Redundant m_padding = ShaderUtilities.GetPadding(m_sharedMaterial, m_enableExtraPadding, m_isUsingBold); m_alignmentPadding = ShaderUtilities.GetFontExtent(m_sharedMaterial); //Debug.Log("Base Material is " + m_baseMaterial.name + " with ID " + m_baseMaterial.GetInstanceID() + ". Shared Material is " + m_sharedMaterial.name + " with ID " + m_sharedMaterial.GetInstanceID()); //Debug.Log("Shared Material is " + m_sharedMaterial + ". Base Material is " + m_baseMaterial + ". Masking Material is " + m_maskingMaterial); //m_uiRenderer.SetMaterial(this.material, null); // Hide Material Editor Component //m_renderer.sharedMaterial.hideFlags = HideFlags.None; }
// Function which loads either the default font or a newly assigned font asset. This function also assigned the appropriate material to the renderer. void LoadFontAsset() { //Debug.Log("TextMeshPro LoadFontAsset() has been called."); // Current Font Asset is " + (font != null ? font.name: "Null") ); if (m_fontAsset == null) { //Debug.Log("Font Asset are Null. Trying to Load Default Arial SDF Font."); m_fontAsset = Resources.Load("Fonts/ARIAL SDF", typeof(TextMeshProFont)) as TextMeshProFont; if (m_fontAsset == null) { Debug.LogWarning("There is no Font Asset assigned to " + gameObject.name + "."); return; } if (m_fontAsset.characterDictionary == null) { Debug.Log("Dictionary is Null!"); } m_renderer.sharedMaterial = m_fontAsset.material; m_sharedMaterial = m_fontAsset.material; m_sharedMaterial.SetFloat("_ZTestMode", 4); m_renderer.receiveShadows = false; m_renderer.castShadows = false; // true; // Get a Reference to the Shader } else { if (m_fontAsset.characterDictionary == null) { //Debug.Log("Reading Font Definition and Creating Character Dictionary."); m_fontAsset.ReadFontDefinition(); } //Debug.Log("Font Asset name:" + font.material.name); // If font atlas texture doesn't match the assigned material font atlas, switch back to default material specified in the Font Asset. if (m_renderer.sharedMaterial == null || m_renderer.sharedMaterial.mainTexture == null || m_fontAsset.atlas.GetInstanceID() != m_renderer.sharedMaterial.GetTexture(ShaderUtilities.ID_MainTex).GetInstanceID()) { m_renderer.sharedMaterial = m_fontAsset.material; m_sharedMaterial = m_fontAsset.material; } else { m_sharedMaterial = m_renderer.sharedMaterial; } m_sharedMaterial.SetFloat("_ZTestMode", 4); // Check if we are using the SDF Surface Shader if (m_sharedMaterial.passCount > 1) { m_renderer.receiveShadows = false; m_renderer.castShadows = true; } else { m_renderer.receiveShadows = false; m_renderer.castShadows = false; } } m_padding = ShaderUtilities.GetPadding(m_renderer.sharedMaterials, m_enableExtraPadding, m_isUsingBold); m_alignmentPadding = ShaderUtilities.GetFontExtent(m_sharedMaterial); if (!m_fontAsset.characterDictionary.TryGetValue(95, out m_cached_Underline_GlyphInfo)) //95 Debug.Log("Underscore character wasn't found in the current Font Asset. No characters assigned for Underline."); m_sharedMaterials.Add(m_sharedMaterial); // Hide Material Editor Component //m_renderer.sharedMaterial.hideFlags = HideFlags.None; }