optimize TMPFont

Author: xiaoguzhu

Assets/Scripts/Core/Text/FontManager.cs

@@ -97,13 +97,6 @@ static public BaseFont GetFont(string name)
                 font.name = name;
                 sFontFactory.Add(name, font);
                 ((TMPFont)font).fontAsset = (TMPro.TMP_FontAsset)asset;
-
-                if (!_checkTextMeshPro)
-                {
-                    _checkTextMeshPro = true;
-                    if (ShaderConfig.Get("TextMeshPro/Distance Field") == null)
-                        Debug.LogWarning("Missing TMP_SDF.shader, please import the TMP essential resources.");
-                }
             }
 #endif
             else

Assets/Scripts/Extensions/TextMeshPro/TMPFont.cs

@@ -28,9 +28,13 @@ public class TMPFont : BaseFont
         TextFormat _format;
         TMP_Character _char;
         TMP_Character _lineChar;
-        Material _material;
         MaterialManager _manager;
 
+        float _gradientScale;
+        float _ratioA;
+        float _ratioB;
+        float _ratioC;
+
         public TMPFont()
         {
             this.canTint = true;
@@ -74,12 +78,6 @@ void Release()
                 mainTexture.Dispose();
                 mainTexture = null;
             }
-
-            if (_material != null)
-            {
-                Material.DestroyImmediate(_material);
-                _material = null;
-            }
         }
 
         void Init()
@@ -92,17 +90,11 @@ void Init()
             _manager = mainTexture.GetMaterialManager(this.shader);
             _manager.onCreateNewMaterial += OnCreateNewMaterial;
 
-            _material = new Material(_fontAsset.material); //copy
-            _material.SetFloat(ShaderUtilities.ID_TextureWidth, mainTexture.width);
-            _material.SetFloat(ShaderUtilities.ID_TextureHeight, mainTexture.height);
-            _material.SetFloat(ShaderUtilities.ID_GradientScale, fontAsset.atlasPadding + 1);
-            _material.SetFloat(ShaderUtilities.ID_WeightNormal, fontAsset.normalStyle);
-            _material.SetFloat(ShaderUtilities.ID_WeightBold, fontAsset.boldStyle);
-
             // _ascent = _fontAsset.faceInfo.ascentLine;
             // _lineHeight = _fontAsset.faceInfo.lineHeight;
             _ascent = _fontAsset.faceInfo.pointSize;
             _lineHeight = _fontAsset.faceInfo.pointSize * 1.25f;
+            _gradientScale = fontAsset.atlasPadding + 1;
 
             _lineChar = GetCharacterFromFontAsset('_', FontStyles.Normal);
         }
@@ -111,34 +103,42 @@ void OnCreateNewMaterial(Material mat)
         {
             mat.SetFloat(ShaderUtilities.ID_TextureWidth, mainTexture.width);
             mat.SetFloat(ShaderUtilities.ID_TextureHeight, mainTexture.height);
-            mat.SetFloat(ShaderUtilities.ID_GradientScale, fontAsset.atlasPadding + 1);
+            mat.SetFloat(ShaderUtilities.ID_GradientScale, _gradientScale);
             mat.SetFloat(ShaderUtilities.ID_WeightNormal, fontAsset.normalStyle);
             mat.SetFloat(ShaderUtilities.ID_WeightBold, fontAsset.boldStyle);
         }
 
         override public void UpdateGraphics(NGraphics graphics)
         {
             MaterialPropertyBlock block = graphics.materialPropertyBlock;
+
+            UpdateShaderRatios();
+            _padding = GetPadding();
+
+            block.SetFloat(ShaderUtilities.ID_ScaleRatio_A, _ratioA);
+            block.SetFloat(ShaderUtilities.ID_ScaleRatio_B, _ratioB);
+            block.SetFloat(ShaderUtilities.ID_ScaleRatio_C, _ratioC);
+
+            block.SetFloat(ShaderUtilities.ID_FaceDilate, _format.faceDilate);
+            block.SetFloat(ShaderUtilities.ID_OutlineSoftness, _format.outlineSoftness);
+
             if (_format.outline > 0)
             {
                 graphics.ToggleKeyword("OUTLINE_ON", true);
-                _material.EnableKeyword("OUTLINE_ON");
 
                 block.SetFloat(ShaderUtilities.ID_OutlineWidth, _format.outline);
                 block.SetColor(ShaderUtilities.ID_OutlineColor, _format.outlineColor);
             }
             else
             {
                 graphics.ToggleKeyword("OUTLINE_ON", false);
-                _material.DisableKeyword("OUTLINE_ON");
 
                 block.SetFloat(ShaderUtilities.ID_OutlineWidth, 0);
             }
 
             if (_format.shadowOffset.x != 0 || _format.shadowOffset.y != 0)
             {
                 graphics.ToggleKeyword("UNDERLAY_ON", true);
-                _material.EnableKeyword("UNDERLAY_ON");
 
                 block.SetColor(ShaderUtilities.ID_UnderlayColor, _format.shadowColor);
                 block.SetFloat(ShaderUtilities.ID_UnderlayOffsetX, _format.shadowOffset.x);
@@ -148,78 +148,31 @@ override public void UpdateGraphics(NGraphics graphics)
             else
             {
                 graphics.ToggleKeyword("UNDERLAY_ON", false);
-                _material.DisableKeyword("UNDERLAY_ON");
 
                 block.SetFloat(ShaderUtilities.ID_UnderlayOffsetX, 0);
                 block.SetFloat(ShaderUtilities.ID_UnderlayOffsetY, 0);
                 block.SetFloat(ShaderUtilities.ID_UnderlaySoftness, 0);
             }
 
-            block.SetFloat(ShaderUtilities.ID_FaceDilate, _format.faceDilate);
-            block.SetFloat(ShaderUtilities.ID_OutlineSoftness, _format.outlineSoftness);
+            _stylePadding = (((_style & FontStyles.Bold) == FontStyles.Bold) ? _fontAsset.boldStyle : _fontAsset.normalStyle)
+                / 4.0f * _gradientScale * _ratioA;
 
-            if (_material.HasProperty(ShaderUtilities.ID_ScaleRatio_A))
-            {
-                //ShaderUtilities.GetPadding does not support handle materialproperyblock, we have to use a temp material
-                _material.SetFloat(ShaderUtilities.ID_OutlineWidth, block.GetFloat(ShaderUtilities.ID_OutlineWidth));
-                _material.SetFloat(ShaderUtilities.ID_UnderlayOffsetX, block.GetFloat(ShaderUtilities.ID_UnderlayOffsetX));
-                _material.SetFloat(ShaderUtilities.ID_UnderlayOffsetY, block.GetFloat(ShaderUtilities.ID_UnderlayOffsetY));
-                _material.SetFloat(ShaderUtilities.ID_UnderlaySoftness, block.GetFloat(ShaderUtilities.ID_UnderlaySoftness));
-                _material.SetFloat(ShaderUtilities.ID_FaceDilate, block.GetFloat(ShaderUtilities.ID_FaceDilate));
-                _material.SetFloat(ShaderUtilities.ID_OutlineSoftness, block.GetFloat(ShaderUtilities.ID_OutlineSoftness));
-
-                _padding = ShaderUtilities.GetPadding(_material, false, false);
-
-                //and then set back the properteis
-                block.SetFloat(ShaderUtilities.ID_ScaleRatio_A, _material.GetFloat(ShaderUtilities.ID_ScaleRatio_A));
-                block.SetFloat(ShaderUtilities.ID_ScaleRatio_B, _material.GetFloat(ShaderUtilities.ID_ScaleRatio_B));
-                block.SetFloat(ShaderUtilities.ID_ScaleRatio_C, _material.GetFloat(ShaderUtilities.ID_ScaleRatio_C));
-            }
-
-            // Set Padding based on selected font style
-            #region Handle Style Padding
-            if (((_style & FontStyles.Bold) == FontStyles.Bold)) // Checks for any combination of Bold Style.
-            {
-                if (_material.HasProperty(ShaderUtilities.ID_GradientScale))
-                {
-                    float gradientScale = _material.GetFloat(ShaderUtilities.ID_GradientScale);
-                    _stylePadding = _fontAsset.boldStyle / 4.0f * gradientScale * _material.GetFloat(ShaderUtilities.ID_ScaleRatio_A);
-
-                    // Clamp overall padding to Gradient Scale size.
-                    if (_stylePadding + _padding > gradientScale)
-                        _padding = gradientScale - _stylePadding;
-                }
-                else
-                    _stylePadding = 0;
-            }
-            else
-            {
-                if (_material.HasProperty(ShaderUtilities.ID_GradientScale))
-                {
-                    float gradientScale = _material.GetFloat(ShaderUtilities.ID_GradientScale);
-                    _stylePadding = _fontAsset.normalStyle / 4.0f * gradientScale * _material.GetFloat(ShaderUtilities.ID_ScaleRatio_A);
-
-                    // Clamp overall padding to Gradient Scale size.
-                    if (_stylePadding + _padding > gradientScale)
-                        _padding = gradientScale - _stylePadding;
-                }
-                else
-                    _stylePadding = 0;
-            }
-            #endregion Handle Style Padding
+            // Clamp overall padding to Gradient Scale size.
+            if (_stylePadding + _padding > _gradientScale)
+                _padding = _gradientScale - _stylePadding;
         }
 
         override public void SetFormat(TextFormat format, float fontSizeScale)
         {
             _format = format;
 
-            float size = format.size * fontSizeScale;
+            float size = _format.size * fontSizeScale;
             if (_format.specialStyle == TextFormat.SpecialStyle.Subscript || _format.specialStyle == TextFormat.SpecialStyle.Superscript)
                 size *= SupScale;
 
             _scale = size / _fontAsset.faceInfo.pointSize * _fontAsset.faceInfo.scale;
             _style = FontStyles.Normal;
-            if (format.bold)
+            if (_format.bold)
             {
                 _style |= FontStyles.Bold;
                 _fontWeight = FontWeight.Bold;
@@ -230,10 +183,10 @@ override public void SetFormat(TextFormat format, float fontSizeScale)
                 _fontWeight = _defaultFontWeight;
                 _boldMultiplier = 1.0f;
             }
-            if (format.italic)
+            if (_format.italic)
                 _style |= FontStyles.Italic;
 
-            format.FillVertexColors(vertexColors);
+            _format.FillVertexColors(vertexColors);
         }
 
         override public bool GetGlyph(char ch, out float width, out float height, out float baseline)
@@ -540,6 +493,82 @@ override public int GetLineHeight(int size)
         {
             return Mathf.RoundToInt(_lineHeight * ((float)size / _fontAsset.faceInfo.pointSize * _fontAsset.faceInfo.scale));
         }
+
+        float GetPadding()
+        {
+            Vector4 padding = Vector4.zero;
+            Vector4 maxPadding = Vector4.zero;
+
+            float faceDilate = _format.faceDilate * _ratioA;
+            float faceSoftness = _format.outlineSoftness * _ratioA;
+            float outlineThickness = _format.outline * _ratioA;
+
+            float uniformPadding = outlineThickness + faceSoftness + faceDilate;
+
+            // Underlay padding contribution
+            if (_format.shadowOffset.x != 0 || _format.shadowOffset.y != 0)
+            {
+                float offsetX = _format.shadowOffset.x * _ratioC;
+                float offsetY = -_format.shadowOffset.y * _ratioC;
+                float dilate = _format.faceDilate * _ratioC;
+                float softness = _format.underlaySoftness * _ratioC;
+
+                padding.x = Mathf.Max(padding.x, faceDilate + dilate + softness - offsetX);
+                padding.y = Mathf.Max(padding.y, faceDilate + dilate + softness - offsetY);
+                padding.z = Mathf.Max(padding.z, faceDilate + dilate + softness + offsetX);
+                padding.w = Mathf.Max(padding.w, faceDilate + dilate + softness + offsetY);
+            }
+
+            padding.x = Mathf.Max(padding.x, uniformPadding);
+            padding.y = Mathf.Max(padding.y, uniformPadding);
+            padding.z = Mathf.Max(padding.z, uniformPadding);
+            padding.w = Mathf.Max(padding.w, uniformPadding);
+
+            padding.x = Mathf.Min(padding.x, 1);
+            padding.y = Mathf.Min(padding.y, 1);
+            padding.z = Mathf.Min(padding.z, 1);
+            padding.w = Mathf.Min(padding.w, 1);
+
+            maxPadding.x = maxPadding.x < padding.x ? padding.x : maxPadding.x;
+            maxPadding.y = maxPadding.y < padding.y ? padding.y : maxPadding.y;
+            maxPadding.z = maxPadding.z < padding.z ? padding.z : maxPadding.z;
+            maxPadding.w = maxPadding.w < padding.w ? padding.w : maxPadding.w;
+
+            padding *= _gradientScale;
+
+            // Set UniformPadding to the maximum value of any of its components.
+            uniformPadding = Mathf.Max(padding.x, padding.y);
+            uniformPadding = Mathf.Max(padding.z, uniformPadding);
+            uniformPadding = Mathf.Max(padding.w, uniformPadding);
+
+            return uniformPadding + 1.25f;
+        }
+
+        // Scale Ratios to ensure property ranges are optimum in Material Editor
+        void UpdateShaderRatios()
+        {
+            _ratioA = _ratioB = _ratioC = 1;
+
+            bool isRatioEnabled = true;
+            float clamp = 1;
+
+            float weight = Mathf.Max(fontAsset.normalStyle, fontAsset.boldStyle) / 4.0f;
+            float range = (weight + _format.faceDilate) * (_gradientScale - clamp);
+
+            // Compute Ratio A
+            float t = Mathf.Max(1, weight + _format.faceDilate + _format.outline + _format.outlineSoftness);
+            _ratioA = isRatioEnabled ? (_gradientScale - clamp) / (_gradientScale * t) : 1;
+
+            // Compute Ratio B
+            // no glow support yet
+
+            // Compute Ratio C
+            if (_format.shadowOffset.x != 0 || _format.shadowOffset.y != 0)
+            {
+                t = Mathf.Max(1, Mathf.Max(Mathf.Abs(_format.shadowOffset.x), Mathf.Abs(-_format.shadowOffset.y)) + _format.faceDilate + _format.underlaySoftness);
+                _ratioC = isRatioEnabled ? Mathf.Max(0, _gradientScale - clamp - range) / (_gradientScale * t) : 1;
+            }
+        }
     }
 }