/// <summary> /// Function to be used to force recomputing of character padding when Shader / Material properties have been changed via script. /// </summary> public override void UpdateMeshPadding() { m_padding = ShaderUtilities.GetPadding(m_sharedMaterial, m_enableExtraPadding, m_isUsingBold); m_isMaskingEnabled = ShaderUtilities.IsMaskingEnabled(m_sharedMaterial); m_havePropertiesChanged = true; checkPaddingRequired = false; // Return if text object is not awake yet. if (m_textInfo == null) { return; } // Update sub text objects for (int i = 1; i < m_textInfo.materialCount; i++) { m_subTextObjects[i].UpdateMeshPadding(m_enableExtraPadding, m_isUsingBold); } }
/// <summary> /// Create a material for the sprite asset. /// </summary> /// <returns></returns> Material GetDefaultSpriteMaterial() { //isEditingAsset = true; ShaderUtilities.GetShaderPropertyIDs(); // Add a new material Shader shader = Shader.Find("TextMeshPro/Sprite"); Material tempMaterial = new Material(shader); tempMaterial.SetTexture(ShaderUtilities.ID_MainTex, spriteSheet); tempMaterial.hideFlags = HideFlags.HideInHierarchy; #if UNITY_EDITOR UnityEditor.AssetDatabase.AddObjectToAsset(tempMaterial, this); UnityEditor.AssetDatabase.ImportAsset(UnityEditor.AssetDatabase.GetAssetPath(this)); #endif //isEditingAsset = false; return(tempMaterial); }
/// <summary> /// Create a Masking Material Instance for the given ID /// </summary> /// <param name="baseMaterial"></param> /// <param name="stencilID"></param> /// <returns></returns> public static Material GetStencilMaterial(Material baseMaterial, int stencilID) { // Check if Material supports masking if (!baseMaterial.HasProperty(ShaderUtilities.ID_StencilID)) { Debug.LogWarning("Selected Shader does not support Stencil Masking. Please select the Distance Field or Mobile Distance Field Shader."); return(baseMaterial); } int baseMaterialID = baseMaterial.GetInstanceID(); // If baseMaterial already has a corresponding masking material, return it. for (int i = 0; i < m_materialList.Count; i++) { if (m_materialList[i].baseMaterial.GetInstanceID() == baseMaterialID && m_materialList[i].stencilID == stencilID) { m_materialList[i].count += 1; #if TMP_DEBUG_MODE ListMaterials(); #endif return(m_materialList[i].stencilMaterial); } } // No matching masking material found. Create and return a new one. Material stencilMaterial; //Create new Masking Material Instance for this Base Material stencilMaterial = new Material(baseMaterial); stencilMaterial.hideFlags = HideFlags.HideAndDontSave; #if UNITY_EDITOR stencilMaterial.name += " Masking ID:" + stencilID; #endif stencilMaterial.shaderKeywords = baseMaterial.shaderKeywords; // Set Stencil Properties ShaderUtilities.GetShaderPropertyIDs(); stencilMaterial.SetFloat(ShaderUtilities.ID_StencilID, stencilID); //stencilMaterial.SetFloat(ShaderUtilities.ID_StencilOp, 0); stencilMaterial.SetFloat(ShaderUtilities.ID_StencilComp, 4); //stencilMaterial.SetFloat(ShaderUtilities.ID_StencilReadMask, stencilID); //stencilMaterial.SetFloat(ShaderUtilities.ID_StencilWriteMask, 0); MaskingMaterial temp = new MaskingMaterial(); temp.baseMaterial = baseMaterial; temp.stencilMaterial = stencilMaterial; temp.stencilID = stencilID; temp.count = 1; m_materialList.Add(temp); #if TMP_DEBUG_MODE ListMaterials(); #endif return(stencilMaterial); }
// 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); }
/// <summary> /// /// </summary> /// <param name="isExtraPadding"></param> /// <param name="isBold"></param> public void UpdateMeshPadding(bool isExtraPadding, bool isUsingBold) { m_padding = ShaderUtilities.GetPadding(m_sharedMaterial, isExtraPadding, isUsingBold); }
/// <summary> /// Function called when the padding value for the material needs to be re-calculated. /// </summary> /// <returns></returns> public float GetPaddingForMaterial(Material mat) { float padding = ShaderUtilities.GetPadding(mat, m_TextComponent.extraPadding, m_TextComponent.isUsingBold); return(padding); }