/// <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);
}