using UnityEngine; using System.Linq; using System.Collections; namespace TMPro { public static class ShaderUtilities { // Shader Property IDs public static int ID_MainTex; public static int ID_FaceTex; public static int ID_FaceColor; public static int ID_FaceDilate; public static int ID_Shininess; public static int ID_UnderlayColor; public static int ID_UnderlayOffsetX; public static int ID_UnderlayOffsetY; public static int ID_UnderlayDilate; public static int ID_UnderlaySoftness; /// /// Property ID for the _UnderlayOffset shader property used by URP and HDRP shaders /// public static int ID_UnderlayOffset; /// /// Property ID for the _UnderlayIsoPerimeter shader property used by URP and HDRP shaders /// public static int ID_UnderlayIsoPerimeter; public static int ID_WeightNormal; public static int ID_WeightBold; public static int ID_OutlineTex; public static int ID_OutlineWidth; public static int ID_OutlineSoftness; public static int ID_OutlineColor; public static int ID_Outline2Color; public static int ID_Outline2Width; public static int ID_Padding; public static int ID_GradientScale; public static int ID_ScaleX; public static int ID_ScaleY; public static int ID_PerspectiveFilter; public static int ID_Sharpness; public static int ID_TextureWidth; public static int ID_TextureHeight; public static int ID_BevelAmount; public static int ID_GlowColor; public static int ID_GlowOffset; public static int ID_GlowPower; public static int ID_GlowOuter; public static int ID_GlowInner; public static int ID_LightAngle; public static int ID_EnvMap; public static int ID_EnvMatrix; public static int ID_EnvMatrixRotation; //public static int ID_MaskID; public static int ID_MaskCoord; public static int ID_ClipRect; public static int ID_MaskSoftnessX; public static int ID_MaskSoftnessY; public static int ID_VertexOffsetX; public static int ID_VertexOffsetY; public static int ID_UseClipRect; public static int ID_StencilID; public static int ID_StencilOp; public static int ID_StencilComp; public static int ID_StencilReadMask; public static int ID_StencilWriteMask; public static int ID_ShaderFlags; public static int ID_ScaleRatio_A; public static int ID_ScaleRatio_B; public static int ID_ScaleRatio_C; public static string Keyword_Bevel = "BEVEL_ON"; public static string Keyword_Glow = "GLOW_ON"; public static string Keyword_Underlay = "UNDERLAY_ON"; public static string Keyword_Ratios = "RATIOS_OFF"; //public static string Keyword_MASK_OFF = "MASK_OFF"; public static string Keyword_MASK_SOFT = "MASK_SOFT"; public static string Keyword_MASK_HARD = "MASK_HARD"; public static string Keyword_MASK_TEX = "MASK_TEX"; public static string Keyword_Outline = "OUTLINE_ON"; public static string ShaderTag_ZTestMode = "unity_GUIZTestMode"; public static string ShaderTag_CullMode = "_CullMode"; private static float m_clamp = 1.0f; public static bool isInitialized = false; /// /// Returns a reference to the mobile distance field shader. /// internal static Shader ShaderRef_MobileSDF { get { if (k_ShaderRef_MobileSDF == null) k_ShaderRef_MobileSDF = Shader.Find("TextMeshPro/Mobile/Distance Field"); return k_ShaderRef_MobileSDF; } } static Shader k_ShaderRef_MobileSDF; /// /// Returns a reference to the mobile bitmap shader. /// internal static Shader ShaderRef_MobileBitmap { get { if (k_ShaderRef_MobileBitmap == null) k_ShaderRef_MobileBitmap = Shader.Find("TextMeshPro/Mobile/Bitmap"); return k_ShaderRef_MobileBitmap; } } static Shader k_ShaderRef_MobileBitmap; /// /// /// static ShaderUtilities() { GetShaderPropertyIDs(); } /// /// /// public static void GetShaderPropertyIDs() { if (isInitialized == false) { //Debug.Log("Getting Shader property IDs"); isInitialized = true; ID_MainTex = Shader.PropertyToID("_MainTex"); ID_FaceTex = Shader.PropertyToID("_FaceTex"); ID_FaceColor = Shader.PropertyToID("_FaceColor"); ID_FaceDilate = Shader.PropertyToID("_FaceDilate"); ID_Shininess = Shader.PropertyToID("_FaceShininess"); ID_UnderlayColor = Shader.PropertyToID("_UnderlayColor"); ID_UnderlayOffsetX = Shader.PropertyToID("_UnderlayOffsetX"); ID_UnderlayOffsetY = Shader.PropertyToID("_UnderlayOffsetY"); ID_UnderlayDilate = Shader.PropertyToID("_UnderlayDilate"); ID_UnderlaySoftness = Shader.PropertyToID("_UnderlaySoftness"); ID_UnderlayOffset = Shader.PropertyToID("_UnderlayOffset"); ID_UnderlayIsoPerimeter = Shader.PropertyToID("_UnderlayIsoPerimeter"); ID_WeightNormal = Shader.PropertyToID("_WeightNormal"); ID_WeightBold = Shader.PropertyToID("_WeightBold"); ID_OutlineTex = Shader.PropertyToID("_OutlineTex"); ID_OutlineWidth = Shader.PropertyToID("_OutlineWidth"); ID_OutlineSoftness = Shader.PropertyToID("_OutlineSoftness"); ID_OutlineColor = Shader.PropertyToID("_OutlineColor"); ID_Outline2Color = Shader.PropertyToID("_Outline2Color"); ID_Outline2Width = Shader.PropertyToID("_Outline2Width"); ID_Padding = Shader.PropertyToID("_Padding"); ID_GradientScale = Shader.PropertyToID("_GradientScale"); ID_ScaleX = Shader.PropertyToID("_ScaleX"); ID_ScaleY = Shader.PropertyToID("_ScaleY"); ID_PerspectiveFilter = Shader.PropertyToID("_PerspectiveFilter"); ID_Sharpness = Shader.PropertyToID("_Sharpness"); ID_TextureWidth = Shader.PropertyToID("_TextureWidth"); ID_TextureHeight = Shader.PropertyToID("_TextureHeight"); ID_BevelAmount = Shader.PropertyToID("_Bevel"); ID_LightAngle = Shader.PropertyToID("_LightAngle"); ID_EnvMap = Shader.PropertyToID("_Cube"); ID_EnvMatrix = Shader.PropertyToID("_EnvMatrix"); ID_EnvMatrixRotation = Shader.PropertyToID("_EnvMatrixRotation"); ID_GlowColor = Shader.PropertyToID("_GlowColor"); ID_GlowOffset = Shader.PropertyToID("_GlowOffset"); ID_GlowPower = Shader.PropertyToID("_GlowPower"); ID_GlowOuter = Shader.PropertyToID("_GlowOuter"); ID_GlowInner = Shader.PropertyToID("_GlowInner"); //ID_MaskID = Shader.PropertyToID("_MaskID"); ID_MaskCoord = Shader.PropertyToID("_MaskCoord"); ID_ClipRect = Shader.PropertyToID("_ClipRect"); ID_UseClipRect = Shader.PropertyToID("_UseClipRect"); ID_MaskSoftnessX = Shader.PropertyToID("_MaskSoftnessX"); ID_MaskSoftnessY = Shader.PropertyToID("_MaskSoftnessY"); ID_VertexOffsetX = Shader.PropertyToID("_VertexOffsetX"); ID_VertexOffsetY = Shader.PropertyToID("_VertexOffsetY"); ID_StencilID = Shader.PropertyToID("_Stencil"); ID_StencilOp = Shader.PropertyToID("_StencilOp"); ID_StencilComp = Shader.PropertyToID("_StencilComp"); ID_StencilReadMask = Shader.PropertyToID("_StencilReadMask"); ID_StencilWriteMask = Shader.PropertyToID("_StencilWriteMask"); ID_ShaderFlags = Shader.PropertyToID("_ShaderFlags"); ID_ScaleRatio_A = Shader.PropertyToID("_ScaleRatioA"); ID_ScaleRatio_B = Shader.PropertyToID("_ScaleRatioB"); ID_ScaleRatio_C = Shader.PropertyToID("_ScaleRatioC"); // Set internal shader references if (k_ShaderRef_MobileSDF == null) k_ShaderRef_MobileSDF = Shader.Find("TextMeshPro/Mobile/Distance Field"); if (k_ShaderRef_MobileBitmap == null) k_ShaderRef_MobileBitmap = Shader.Find("TextMeshPro/Mobile/Bitmap"); } } // Scale Ratios to ensure property ranges are optimum in Material Editor public static void UpdateShaderRatios(Material mat) { //Debug.Log("UpdateShaderRatios() called."); float ratio_A = 1; float ratio_B = 1; float ratio_C = 1; bool isRatioEnabled = !mat.shaderKeywords.Contains(Keyword_Ratios); if (!mat.HasProperty(ID_GradientScale) || !mat.HasProperty(ID_FaceDilate)) return; // Compute Ratio A float scale = mat.GetFloat(ID_GradientScale); float faceDilate = mat.GetFloat(ID_FaceDilate); float outlineThickness = mat.GetFloat(ID_OutlineWidth); float outlineSoftness = mat.GetFloat(ID_OutlineSoftness); float weight = Mathf.Max(mat.GetFloat(ID_WeightNormal), mat.GetFloat(ID_WeightBold)) / 4.0f; float t = Mathf.Max(1, weight + faceDilate + outlineThickness + outlineSoftness); ratio_A = isRatioEnabled ? (scale - m_clamp) / (scale * t) : 1; //float ratio_A_old = mat.GetFloat(ID_ScaleRatio_A); // Only set the ratio if it has changed. //if (ratio_A != ratio_A_old) mat.SetFloat(ID_ScaleRatio_A, ratio_A); // Compute Ratio B if (mat.HasProperty(ID_GlowOffset)) { float glowOffset = mat.GetFloat(ID_GlowOffset); float glowOuter = mat.GetFloat(ID_GlowOuter); float range = (weight + faceDilate) * (scale - m_clamp); t = Mathf.Max(1, glowOffset + glowOuter); ratio_B = isRatioEnabled ? Mathf.Max(0, scale - m_clamp - range) / (scale * t) : 1; //float ratio_B_old = mat.GetFloat(ID_ScaleRatio_B); // Only set the ratio if it has changed. //if (ratio_B != ratio_B_old) mat.SetFloat(ID_ScaleRatio_B, ratio_B); } // Compute Ratio C if (mat.HasProperty(ID_UnderlayOffsetX)) { float underlayOffsetX = mat.GetFloat(ID_UnderlayOffsetX); float underlayOffsetY = mat.GetFloat(ID_UnderlayOffsetY); float underlayDilate = mat.GetFloat(ID_UnderlayDilate); float underlaySoftness = mat.GetFloat(ID_UnderlaySoftness); float range = (weight + faceDilate) * (scale - m_clamp); t = Mathf.Max(1, Mathf.Max(Mathf.Abs(underlayOffsetX), Mathf.Abs(underlayOffsetY)) + underlayDilate + underlaySoftness); ratio_C = isRatioEnabled ? Mathf.Max(0, scale - m_clamp - range) / (scale * t) : 1; //float ratio_C_old = mat.GetFloat(ID_ScaleRatio_C); // Only set the ratio if it has changed. //if (ratio_C != ratio_C_old) mat.SetFloat(ID_ScaleRatio_C, ratio_C); } } // Function to calculate padding required for Outline Width & Dilation for proper text alignment public static Vector4 GetFontExtent(Material material) { // Revised implementation where style no longer affects alignment return Vector4.zero; /* if (material == null || !material.HasProperty(ShaderUtilities.ID_GradientScale)) return Vector4.zero; // We are using an non SDF Shader. float scaleRatioA = material.GetFloat(ID_ScaleRatio_A); float faceDilate = material.GetFloat(ID_FaceDilate) * scaleRatioA; float outlineThickness = material.GetFloat(ID_OutlineWidth) * scaleRatioA; float extent = Mathf.Min(1, faceDilate + outlineThickness); extent *= material.GetFloat(ID_GradientScale); return new Vector4(extent, extent, extent, extent); */ } // Function to check if Masking is enabled public static bool IsMaskingEnabled(Material material) { if (material == null || !material.HasProperty(ShaderUtilities.ID_ClipRect)) return false; if (material.shaderKeywords.Contains(ShaderUtilities.Keyword_MASK_SOFT) || material.shaderKeywords.Contains(ShaderUtilities.Keyword_MASK_HARD) || material.shaderKeywords.Contains(ShaderUtilities.Keyword_MASK_TEX)) return true; return false; } // Function to determine how much extra padding is required as a result of material properties like dilate, outline thickness, softness, glow, etc... public static float GetPadding(Material material, bool enableExtraPadding, bool isBold) { //Debug.Log("GetPadding() called."); if (isInitialized == false) GetShaderPropertyIDs(); // Return if Material is null if (material == null) return 0; int extraPadding = enableExtraPadding ? 4 : 0; // Check if we are using a non Distance Field Shader if (material.HasProperty(ID_GradientScale) == false) { if (material.HasProperty(ID_Padding)) extraPadding += (int)material.GetFloat(ID_Padding); return extraPadding + 1.0f; } Vector4 padding = Vector4.zero; Vector4 maxPadding = Vector4.zero; //float weight = 0; float faceDilate = 0; float faceSoftness = 0; float outlineThickness = 0; float scaleRatio_A = 0; float scaleRatio_B = 0; float scaleRatio_C = 0; float glowOffset = 0; float glowOuter = 0; float uniformPadding = 0; // Iterate through each of the assigned materials to find the max values to set the padding. // Update Shader Ratios prior to computing padding UpdateShaderRatios(material); string[] shaderKeywords = material.shaderKeywords; if (material.HasProperty(ID_ScaleRatio_A)) scaleRatio_A = material.GetFloat(ID_ScaleRatio_A); //weight = 0; // Mathf.Max(material.GetFloat(ID_WeightNormal), material.GetFloat(ID_WeightBold)) / 2.0f * scaleRatio_A; if (material.HasProperty(ID_FaceDilate)) faceDilate = material.GetFloat(ID_FaceDilate) * scaleRatio_A; if (material.HasProperty(ID_OutlineSoftness)) faceSoftness = material.GetFloat(ID_OutlineSoftness) * scaleRatio_A; if (material.HasProperty(ID_OutlineWidth)) outlineThickness = material.GetFloat(ID_OutlineWidth) * scaleRatio_A; uniformPadding = outlineThickness + faceSoftness + faceDilate; // Glow padding contribution if (material.HasProperty(ID_GlowOffset) && shaderKeywords.Contains(Keyword_Glow)) // Generates GC { if (material.HasProperty(ID_ScaleRatio_B)) scaleRatio_B = material.GetFloat(ID_ScaleRatio_B); glowOffset = material.GetFloat(ID_GlowOffset) * scaleRatio_B; glowOuter = material.GetFloat(ID_GlowOuter) * scaleRatio_B; } uniformPadding = Mathf.Max(uniformPadding, faceDilate + glowOffset + glowOuter); // Underlay padding contribution if (material.HasProperty(ID_UnderlaySoftness) && shaderKeywords.Contains(Keyword_Underlay)) // Generates GC { if (material.HasProperty(ID_ScaleRatio_C)) scaleRatio_C = material.GetFloat(ID_ScaleRatio_C); float offsetX = material.GetFloat(ID_UnderlayOffsetX) * scaleRatio_C; float offsetY = material.GetFloat(ID_UnderlayOffsetY) * scaleRatio_C; float dilate = material.GetFloat(ID_UnderlayDilate) * scaleRatio_C; float softness = material.GetFloat(ID_UnderlaySoftness) * scaleRatio_C; 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 += extraPadding; padding.y += extraPadding; padding.z += extraPadding; padding.w += extraPadding; 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; float gradientScale = material.GetFloat(ID_GradientScale); 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; } // Function to determine how much extra padding is required as a result of material properties like dilate, outline thickness, softness, glow, etc... public static float GetPadding(Material[] materials, bool enableExtraPadding, bool isBold) { //Debug.Log("GetPadding() called."); if (isInitialized == false) GetShaderPropertyIDs(); // Return if Material is null if (materials == null) return 0; int extraPadding = enableExtraPadding ? 4 : 0; // Check if we are using a Bitmap Shader if (materials[0].HasProperty(ID_Padding)) return extraPadding + materials[0].GetFloat(ID_Padding); Vector4 padding = Vector4.zero; Vector4 maxPadding = Vector4.zero; float faceDilate = 0; float faceSoftness = 0; float outlineThickness = 0; float scaleRatio_A = 0; float scaleRatio_B = 0; float scaleRatio_C = 0; float glowOffset = 0; float glowOuter = 0; float uniformPadding = 0; // Iterate through each of the assigned materials to find the max values to set the padding. for (int i = 0; i < materials.Length; i++) { // Update Shader Ratios prior to computing padding ShaderUtilities.UpdateShaderRatios(materials[i]); string[] shaderKeywords = materials[i].shaderKeywords; if (materials[i].HasProperty(ShaderUtilities.ID_ScaleRatio_A)) scaleRatio_A = materials[i].GetFloat(ShaderUtilities.ID_ScaleRatio_A); if (materials[i].HasProperty(ShaderUtilities.ID_FaceDilate)) faceDilate = materials[i].GetFloat(ShaderUtilities.ID_FaceDilate) * scaleRatio_A; if (materials[i].HasProperty(ShaderUtilities.ID_OutlineSoftness)) faceSoftness = materials[i].GetFloat(ShaderUtilities.ID_OutlineSoftness) * scaleRatio_A; if (materials[i].HasProperty(ShaderUtilities.ID_OutlineWidth)) outlineThickness = materials[i].GetFloat(ShaderUtilities.ID_OutlineWidth) * scaleRatio_A; uniformPadding = outlineThickness + faceSoftness + faceDilate; // Glow padding contribution if (materials[i].HasProperty(ShaderUtilities.ID_GlowOffset) && shaderKeywords.Contains(ShaderUtilities.Keyword_Glow)) { if (materials[i].HasProperty(ShaderUtilities.ID_ScaleRatio_B)) scaleRatio_B = materials[i].GetFloat(ShaderUtilities.ID_ScaleRatio_B); glowOffset = materials[i].GetFloat(ShaderUtilities.ID_GlowOffset) * scaleRatio_B; glowOuter = materials[i].GetFloat(ShaderUtilities.ID_GlowOuter) * scaleRatio_B; } uniformPadding = Mathf.Max(uniformPadding, faceDilate + glowOffset + glowOuter); // Underlay padding contribution if (materials[i].HasProperty(ShaderUtilities.ID_UnderlaySoftness) && shaderKeywords.Contains(ShaderUtilities.Keyword_Underlay)) { if (materials[i].HasProperty(ShaderUtilities.ID_ScaleRatio_C)) scaleRatio_C = materials[i].GetFloat(ShaderUtilities.ID_ScaleRatio_C); float offsetX = materials[i].GetFloat(ShaderUtilities.ID_UnderlayOffsetX) * scaleRatio_C; float offsetY = materials[i].GetFloat(ShaderUtilities.ID_UnderlayOffsetY) * scaleRatio_C; float dilate = materials[i].GetFloat(ShaderUtilities.ID_UnderlayDilate) * scaleRatio_C; float softness = materials[i].GetFloat(ShaderUtilities.ID_UnderlaySoftness) * scaleRatio_C; 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 += extraPadding; padding.y += extraPadding; padding.z += extraPadding; padding.w += extraPadding; 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; } float gradientScale = materials[0].GetFloat(ShaderUtilities.ID_GradientScale); 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 + 0.25f; } } }