public static Material GetStencilMaterial(Material baseMaterial, int stencilID)
{
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;
}
Material material = null;
int num = m_materialList.FindIndex((MaskingMaterial item) => item.baseMaterial == baseMaterial && item.stencilID == stencilID);
if (num == -1)
{
material = new Material(baseMaterial);
material.hideFlags = HideFlags.HideAndDontSave;
Material material2 = material;
material2.name = material2.name + " Masking ID:" + stencilID;
material.shaderKeywords = baseMaterial.shaderKeywords;
ShaderUtilities.GetShaderPropertyIDs();
material.SetFloat(ShaderUtilities.ID_StencilID, (float)stencilID);
material.SetFloat(ShaderUtilities.ID_StencilComp, 4f);
MaskingMaterial maskingMaterial = new MaskingMaterial();
maskingMaterial.baseMaterial = baseMaterial;
maskingMaterial.stencilMaterial = material;
maskingMaterial.stencilID = stencilID;
maskingMaterial.count = 1;
m_materialList.Add(maskingMaterial);
}
else
{
material = m_materialList[num].stencilMaterial;
m_materialList[num].count++;
}
ListMaterials();
return material;
}
/// <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);
}
public static Material GetStencilMaterial(Material baseMaterial, int stencilID)
{
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 instanceID = baseMaterial.GetInstanceID();
for (int i = 0; i < TMP_MaterialManager.m_materialList.Count; i++)
{
if (TMP_MaterialManager.m_materialList[i].baseMaterial.GetInstanceID() == instanceID && TMP_MaterialManager.m_materialList[i].stencilID == stencilID)
{
TMP_MaterialManager.m_materialList[i].count++;
return(TMP_MaterialManager.m_materialList[i].stencilMaterial);
}
}
Material material = new Material(baseMaterial);
material.hideFlags = HideFlags.HideAndDontSave;
material.shaderKeywords = baseMaterial.shaderKeywords;
ShaderUtilities.GetShaderPropertyIDs();
material.SetFloat(ShaderUtilities.ID_StencilID, (float)stencilID);
material.SetFloat(ShaderUtilities.ID_StencilComp, 4f);
TMP_MaterialManager.MaskingMaterial maskingMaterial = new TMP_MaterialManager.MaskingMaterial();
maskingMaterial.baseMaterial = baseMaterial;
maskingMaterial.stencilMaterial = material;
maskingMaterial.stencilID = stencilID;
maskingMaterial.count = 1;
TMP_MaterialManager.m_materialList.Add(maskingMaterial);
return(material);
}
public static void UpdateShaderRatios(Material mat, bool isBold)
{
bool flag = !ShaderUtilities.StringContains(mat.shaderKeywords, ShaderUtilities.Keyword_Ratios);
float @float = mat.GetFloat(ShaderUtilities.ID_GradientScale);
float float2 = mat.GetFloat(ShaderUtilities.ID_FaceDilate);
float float3 = mat.GetFloat(ShaderUtilities.ID_OutlineWidth);
float float4 = mat.GetFloat(ShaderUtilities.ID_OutlineSoftness);
float num = (!isBold) ? (mat.GetFloat(ShaderUtilities.ID_WeightNormal) * 2f / @float) : (mat.GetFloat(ShaderUtilities.ID_WeightBold) * 2f / @float);
float num2 = Mathf.Max(1f, num + float2 + float3 + float4);
float value = flag ? ((@float - ShaderUtilities.m_clamp) / (@float * num2)) : 1f;
mat.SetFloat(ShaderUtilities.ID_ScaleRatio_A, value);
if (mat.HasProperty(ShaderUtilities.ID_GlowOffset))
{
float float5 = mat.GetFloat(ShaderUtilities.ID_GlowOffset);
float float6 = mat.GetFloat(ShaderUtilities.ID_GlowOuter);
float num3 = (num + float2) * (@float - ShaderUtilities.m_clamp);
num2 = Mathf.Max(1f, float5 + float6);
float value2 = flag ? (Mathf.Max(0f, @float - ShaderUtilities.m_clamp - num3) / (@float * num2)) : 1f;
mat.SetFloat(ShaderUtilities.ID_ScaleRatio_B, value2);
}
if (mat.HasProperty(ShaderUtilities.ID_UnderlayOffsetX))
{
float float7 = mat.GetFloat(ShaderUtilities.ID_UnderlayOffsetX);
float float8 = mat.GetFloat(ShaderUtilities.ID_UnderlayOffsetY);
float float9 = mat.GetFloat(ShaderUtilities.ID_UnderlayDilate);
float float10 = mat.GetFloat(ShaderUtilities.ID_UnderlaySoftness);
float num4 = (num + float2) * (@float - ShaderUtilities.m_clamp);
num2 = Mathf.Max(1f, Mathf.Max(Mathf.Abs(float7), Mathf.Abs(float8)) + float9 + float10);
float value3 = flag ? (Mathf.Max(0f, @float - ShaderUtilities.m_clamp - num4) / (@float * num2)) : 1f;
mat.SetFloat(ShaderUtilities.ID_ScaleRatio_C, value3);
}
}
public static Material GetStencilMaterial(Material baseMaterial, int stencilID)
{
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 num = MaterialManager.m_materialList.FindIndex((MaterialManager.MaskingMaterial item) => item.baseMaterial == baseMaterial && item.stencilID == stencilID);
Material material;
if (num == -1)
{
material = new Material(baseMaterial);
material.hideFlags = (HideFlags.HideInHierarchy | HideFlags.DontSaveInEditor | HideFlags.NotEditable);
Material expr_6F = material;
expr_6F.name = expr_6F.name + " Masking ID:" + stencilID;
material.shaderKeywords = baseMaterial.shaderKeywords;
ShaderUtilities.GetShaderPropertyIDs();
material.SetFloat(ShaderUtilities.ID_StencilID, (float)stencilID);
material.SetFloat(ShaderUtilities.ID_StencilComp, 3f);
MaterialManager.MaskingMaterial maskingMaterial = new MaterialManager.MaskingMaterial();
maskingMaterial.baseMaterial = baseMaterial;
maskingMaterial.stencilMaterial = material;
maskingMaterial.stencilID = stencilID;
maskingMaterial.count = 1;
MaterialManager.m_materialList.Add(maskingMaterial);
}
else
{
material = MaterialManager.m_materialList.get_Item(num).stencilMaterial;
MaterialManager.m_materialList.get_Item(num).count++;
}
MaterialManager.ListMaterials();
return(material);
}
/// <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 DEBUG_ON
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;
stencilMaterial.name += " Masking ID:" + stencilID;
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 DEBUG_ON
ListMaterials();
#endif
return(stencilMaterial);
}
/// <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);
}
private Material GetDefaultSpriteMaterial()
{
ShaderUtilities.GetShaderPropertyIDs();
Shader shader = Shader.Find("TextMeshPro/Sprite");
Material material = new Material(shader);
material.SetTexture(ShaderUtilities.ID_MainTex, this.spriteSheet);
material.hideFlags = HideFlags.HideInHierarchy;
return(material);
}
//protected override void UpdateGeometry()
//{
// //Debug.Log("UpdateGeometry");
// //base.UpdateGeometry();
//}
//protected override void UpdateMaterial()
//{
// //Debug.Log("UpdateMaterial called.");
//// base.UpdateMaterial();
//}
/*
/// <summary>
/// Sets the mask type
/// </summary>
public MaskingTypes mask
{
get { return m_mask; }
set { m_mask = value; havePropertiesChanged = true; isMaskUpdateRequired = true; }
}
/// <summary>
/// Set the masking offset mode (as percentage or pixels)
/// </summary>
public MaskingOffsetMode maskOffsetMode
{
get { return m_maskOffsetMode; }
set { m_maskOffsetMode = value; havePropertiesChanged = true; isMaskUpdateRequired = true; }
}
*/
/*
/// <summary>
/// Sets the softness of the mask
/// </summary>
public Vector2 maskSoftness
{
get { return m_maskSoftness; }
set { m_maskSoftness = value; havePropertiesChanged = true; isMaskUpdateRequired = true; }
}
/// <summary>
/// Allows to move / offset the mesh vertices by a set amount
/// </summary>
public Vector2 vertexOffset
{
get { return m_vertexOffset; }
set { m_vertexOffset = value; havePropertiesChanged = true; isMaskUpdateRequired = true; }
}
*/
/// <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;
// Update sub text objects
for (int i = 1; i < m_textInfo.materialCount; i++)
m_subTextObjects[i].UpdateMeshPadding(m_enableExtraPadding, m_isUsingBold);
}
/// <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);
}
Material stencilMaterial = null;
// Check if baseMaterial already has a masking material associated with it.
int index = m_materialList.FindIndex(item => item.baseMaterial == baseMaterial && item.stencilID == stencilID);
if (index == -1)
{
//Create new Masking Material Instance for this Base Material
stencilMaterial = new Material(baseMaterial);
stencilMaterial.hideFlags = HideFlags.HideAndDontSave;
stencilMaterial.name += " Masking ID:" + stencilID;
stencilMaterial.shaderKeywords = baseMaterial.shaderKeywords;
// Set Stencil Properties
ShaderUtilities.GetShaderPropertyIDs();
stencilMaterial.SetFloat(ShaderUtilities.ID_StencilID, stencilID);
stencilMaterial.SetFloat(ShaderUtilities.ID_StencilComp, 4);
MaskingMaterial temp = new MaskingMaterial();
temp.baseMaterial = baseMaterial;
temp.stencilMaterial = stencilMaterial;
temp.stencilID = stencilID;
temp.count = 1;
m_materialList.Add(temp);
//Debug.Log("Masking material for " + baseMaterial.name + " DOES NOT exists. Creating new " + maskingMaterial.name + " with ID " + maskingMaterial.GetInstanceID() + " which is used " + temp.count + " time(s).");
}
else
{
stencilMaterial = m_materialList[index].stencilMaterial;
m_materialList[index].count += 1;
//Debug.Log("Masking material for " + baseMaterial.name + " already exists. Passing reference to " + maskingMaterial.name + " with ID " + maskingMaterial.GetInstanceID() + " which is used " + m_materialList[index].count + " time(s).");
}
// Used for Debug
ListMaterials();
return(stencilMaterial);
}
private Material GetDefaultSpriteMaterial()
{
ShaderUtilities.GetShaderPropertyIDs();
Shader shader = Shader.Find("TextMeshPro/Sprite");
Material material = new Material(shader);
material.SetTexture(ShaderUtilities.ID_MainTex, spriteSheet);
material.hideFlags = HideFlags.HideInHierarchy;
#if UNITY_EDITOR
/*AssetDatabase.AddObjectToAsset(material, this);
* AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(this));*/
#endif
return(material);
}
public void UpdateMeshPadding(bool isExtraPadding, bool isUsingBold)
{
m_padding = ShaderUtilities.GetPadding(m_sharedMaterial, isExtraPadding, isUsingBold);
}
public float GetPaddingForMaterial()
{
return(ShaderUtilities.GetPadding(m_sharedMaterial, m_TextComponent.extraPadding, m_TextComponent.isUsingBold));
}
// 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;
if (!materials[0].HasProperty(ShaderUtilities.ID_GradientScale))
{
return(extraPadding); // We are using an non SDF Shader.
}
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], isBold);
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>
/// Method called when Stencil Mask needs to be updated on this element and parents.
/// </summary>
public override void RecalculateMasking()
{
//Debug.Log("***** RecalculateMasking() *****");
if (m_fontAsset == null)
{
return;
}
//if (m_canvas == null) m_canvas = GetComponentInParent<Canvas>();
if (!m_isAwake)
{
return;
}
m_stencilID = MaterialManager.GetStencilID(gameObject);
//m_stencilID = MaskUtilities.GetStencilDepth(this.transform, m_canvas.transform);
//Debug.Log("Stencil ID: " + m_stencilID + " Stencil ID (2): " + MaskUtilities.GetStencilDepth(this.transform, m_canvas.transform));
if (m_stencilID == 0)
{
if (m_maskingMaterial != null)
{
MaterialManager.ReleaseStencilMaterial(m_maskingMaterial);
m_maskingMaterial = null;
m_sharedMaterial = m_baseMaterial;
}
else if (m_fontMaterial != null)
{
m_sharedMaterial = MaterialManager.SetStencil(m_fontMaterial, 0);
}
else
{
m_sharedMaterial = m_baseMaterial;
}
}
else
{
ShaderUtilities.GetShaderPropertyIDs();
if (m_fontMaterial != null)
{
m_sharedMaterial = MaterialManager.SetStencil(m_fontMaterial, m_stencilID);
}
else if (m_maskingMaterial == null)
{
m_maskingMaterial = MaterialManager.GetStencilMaterial(m_baseMaterial, m_stencilID);
m_sharedMaterial = m_maskingMaterial;
}
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;
}
if (m_isMaskingEnabled)
{
EnableMasking();
}
//Debug.Log("Masking Enabled. Assigning " + m_maskingMaterial.name + " with ID " + m_maskingMaterial.GetInstanceID());
}
m_uiRenderer.SetMaterial(m_sharedMaterial, m_sharedMaterial.mainTexture);
m_padding = ShaderUtilities.GetPadding(m_sharedMaterial, m_enableExtraPadding, m_isUsingBold);
//m_alignmentPadding = ShaderUtilities.GetFontExtent(m_sharedMaterial);
}
//public TMP_CharacterInfo[] characterInfo
//{
// get { return m_textInfo.characterInfo; }
//
//}
/// <summary>
/// Function to be used to force recomputing of character padding when Shader / Material properties have been changed via script.
/// </summary>
public void UpdateMeshPadding()
{
m_padding = ShaderUtilities.GetPadding(new Material[] { m_uiRenderer.GetMaterial() }, m_enableExtraPadding, m_isUsingBold);
m_havePropertiesChanged = true;
/* ScheduleUpdate(); */
}
/// <summary>
/// Function to be used to force recomputing of character padding when Shader / Material properties have been changed via script.
/// </summary>
public void UpdateMeshPadding()
{
m_padding = ShaderUtilities.GetPadding(m_renderer.sharedMaterials, m_enableExtraPadding, m_isUsingBold);
m_havePropertiesChanged = true;
/* ScheduleUpdate(); */
}
public static float GetPadding(Material[] materials, bool enableExtraPadding, bool isBold)
{
if (!ShaderUtilities.isInitialized)
{
ShaderUtilities.GetShaderPropertyIDs();
}
if (materials == null)
{
return(0f);
}
int num = (!enableExtraPadding) ? 0 : 4;
if (!materials[0].HasProperty(ShaderUtilities.ID_GradientScale))
{
return((float)num);
}
Vector4 a = Vector4.zero;
Vector4 zero = Vector4.zero;
float num2 = 0f;
float num3 = 0f;
float num4 = 0f;
float num5 = 0f;
float num6 = 0f;
float num7 = 0f;
float num8 = 0f;
float num9 = 0f;
float num10;
for (int i = 0; i < materials.Length; i++)
{
ShaderUtilities.UpdateShaderRatios(materials[i]);
string[] shaderKeywords = materials[i].shaderKeywords;
if (materials[i].HasProperty(ShaderUtilities.ID_ScaleRatio_A))
{
num5 = materials[i].GetFloat(ShaderUtilities.ID_ScaleRatio_A);
}
if (materials[i].HasProperty(ShaderUtilities.ID_FaceDilate))
{
num2 = materials[i].GetFloat(ShaderUtilities.ID_FaceDilate) * num5;
}
if (materials[i].HasProperty(ShaderUtilities.ID_OutlineSoftness))
{
num3 = materials[i].GetFloat(ShaderUtilities.ID_OutlineSoftness) * num5;
}
if (materials[i].HasProperty(ShaderUtilities.ID_OutlineWidth))
{
num4 = materials[i].GetFloat(ShaderUtilities.ID_OutlineWidth) * num5;
}
num10 = num4 + num3 + num2;
if (materials[i].HasProperty(ShaderUtilities.ID_GlowOffset) && shaderKeywords.Contains(ShaderUtilities.Keyword_Glow))
{
if (materials[i].HasProperty(ShaderUtilities.ID_ScaleRatio_B))
{
num6 = materials[i].GetFloat(ShaderUtilities.ID_ScaleRatio_B);
}
num8 = materials[i].GetFloat(ShaderUtilities.ID_GlowOffset) * num6;
num9 = materials[i].GetFloat(ShaderUtilities.ID_GlowOuter) * num6;
}
num10 = Mathf.Max(num10, num2 + num8 + num9);
if (materials[i].HasProperty(ShaderUtilities.ID_UnderlaySoftness) && shaderKeywords.Contains(ShaderUtilities.Keyword_Underlay))
{
if (materials[i].HasProperty(ShaderUtilities.ID_ScaleRatio_C))
{
num7 = materials[i].GetFloat(ShaderUtilities.ID_ScaleRatio_C);
}
float num11 = materials[i].GetFloat(ShaderUtilities.ID_UnderlayOffsetX) * num7;
float num12 = materials[i].GetFloat(ShaderUtilities.ID_UnderlayOffsetY) * num7;
float num13 = materials[i].GetFloat(ShaderUtilities.ID_UnderlayDilate) * num7;
float num14 = materials[i].GetFloat(ShaderUtilities.ID_UnderlaySoftness) * num7;
a.x = Mathf.Max(a.x, num2 + num13 + num14 - num11);
a.y = Mathf.Max(a.y, num2 + num13 + num14 - num12);
a.z = Mathf.Max(a.z, num2 + num13 + num14 + num11);
a.w = Mathf.Max(a.w, num2 + num13 + num14 + num12);
}
a.x = Mathf.Max(a.x, num10);
a.y = Mathf.Max(a.y, num10);
a.z = Mathf.Max(a.z, num10);
a.w = Mathf.Max(a.w, num10);
a.x += (float)num;
a.y += (float)num;
a.z += (float)num;
a.w += (float)num;
a.x = Mathf.Min(a.x, 1f);
a.y = Mathf.Min(a.y, 1f);
a.z = Mathf.Min(a.z, 1f);
a.w = Mathf.Min(a.w, 1f);
zero.x = ((zero.x >= a.x) ? zero.x : a.x);
zero.y = ((zero.y >= a.y) ? zero.y : a.y);
zero.z = ((zero.z >= a.z) ? zero.z : a.z);
zero.w = ((zero.w >= a.w) ? zero.w : a.w);
}
float @float = materials[0].GetFloat(ShaderUtilities.ID_GradientScale);
a *= @float;
num10 = Mathf.Max(a.x, a.y);
num10 = Mathf.Max(a.z, num10);
num10 = Mathf.Max(a.w, num10);
return(num10 + 0.25f);
}
static ShaderUtilities()
{
ShaderUtilities.GetShaderPropertyIDs();
}
public static bool IsMaskingEnabled(Material material)
{
return(!(material == null) && material.HasProperty(ShaderUtilities.ID_MaskCoord) && (ShaderUtilities.StringContains(material.shaderKeywords, ShaderUtilities.Keyword_MASK_SOFT) || ShaderUtilities.StringContains(material.shaderKeywords, ShaderUtilities.Keyword_MASK_HARD)));
}
//public override Material defaultMaterial
//{
// get { Debug.Log("Default Material called."); return m_sharedMaterial; }
//}
//public bool MaskEnabled()
//{
// Debug.Log("MaskEnabled() called.");
// return true;
//}
public void ParentMaskStateChanged()
{
//Debug.Log("***** PARENT MASK STATE CHANGED *****");
if (m_fontAsset == null)
{
return;
}
m_stencilID = MaterialManager.GetStencilID(gameObject);
if (!m_isAwake)
{
return;
}
if (m_stencilID == 0)
{
if (m_maskingMaterial != null)
{
MaterialManager.ReleaseStencilMaterial(m_maskingMaterial);
m_maskingMaterial = null;
m_sharedMaterial = m_baseMaterial;
}
else if (m_fontMaterial != null)
{
m_sharedMaterial = MaterialManager.SetStencil(m_fontMaterial, 0);
}
}
else
{
ShaderUtilities.GetShaderPropertyIDs();
if (m_fontMaterial != null)
{
m_sharedMaterial = MaterialManager.SetStencil(m_fontMaterial, m_stencilID);
}
else if (m_maskingMaterial == null)
{
m_maskingMaterial = MaterialManager.GetStencilMaterial(m_baseMaterial, m_stencilID);
m_sharedMaterial = m_maskingMaterial;
}
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;
}
if (m_isMaskingEnabled)
{
EnableMasking();
}
//Debug.Log("Masking Enabled. Assigning " + m_maskingMaterial.name + " with ID " + m_maskingMaterial.GetInstanceID());
}
m_uiRenderer.SetMaterial(m_sharedMaterial, null);
m_padding = ShaderUtilities.GetPadding(m_sharedMaterial, m_enableExtraPadding, m_isUsingBold);
m_alignmentPadding = ShaderUtilities.GetFontExtent(m_sharedMaterial);
}
public float GetPaddingForMaterial(Material mat)
{
return(ShaderUtilities.GetPadding(mat, this.m_TextComponent.extraPadding, this.m_TextComponent.isUsingBold));
}
/// <summary>
/// Function used to evaluate the length of a text string.
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public TextInfo GetTextInfo(string text)
{
TextInfo temp_textInfo = new TextInfo();
// 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(null);
}
// Early exit if string is empty.
if (text == null || text.Length == 0)
{
return(null);
}
// Convert String to Char[]
StringToCharArray(text, ref m_text_buffer);
int size = GetArraySizes(m_text_buffer);
temp_textInfo.characterInfo = new TMPro_CharacterInfo[size];
m_fontIndex = 0;
m_fontAssetArray[m_fontIndex] = m_fontAsset;
// Scale the font to approximately match the point size
m_fontScale = (m_fontSize / m_fontAssetArray[m_fontIndex].fontInfo.PointSize * (m_isOrthographic ? 1 : 0.1f));
float baseScale = m_fontScale; // BaseScale keeps the character aligned vertically since <size=+000> results in font of different scale.
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 = FontStyles.Normal; // Set defaul style as normal.
// GetPadding to adjust the size of the mesh due to border thickness, softness, glow, etc...
if (checkPaddingRequired)
{
checkPaddingRequired = false;
m_padding = ShaderUtilities.GetPadding(m_renderer.sharedMaterials, m_enableExtraPadding, m_isUsingBold);
m_alignmentPadding = ShaderUtilities.GetFontExtent(m_sharedMaterial);
}
float style_padding = 0; // Extra padding required to accomodate Bold style.
float xadvance_multiplier = 1; // Used to increase spacing between character when style is bold.
m_baselineOffset = 0; // Used by subscript characters.
float lineOffset = 0; // Amount of space between lines (font line spacing + m_linespacing).
m_xAdvance = 0; // Used to track the position of each character.
int lineNumber = 0;
int wordCount = 0;
int character_Count = 0; // Total characters in the char[]
int visibleCharacter_Count = 0; // # of visible characters.
// Limit Line Length to whatever size fits all characters on a single line.
m_lineLength = m_lineLength > max_LineWrapLength ? max_LineWrapLength : m_lineLength;
// Initialize struct to track states of word wrapping
m_SaveWordWrapState = new WordWrapState();
int wrappingIndex = 0;
if (temp_textInfo.lineInfo == null)
{
temp_textInfo.lineInfo = new LineInfo[8];
}
for (int i = 0; i < temp_textInfo.lineInfo.Length; i++)
{
temp_textInfo.lineInfo[i] = new LineInfo();
//m_textInfo.lineInfo[i].lineExtents = new Extents(k_InfinityVector, -k_InfinityVector);
}
// Tracking of the highest Ascender
float maxAscender = 0;
float maxDescender = 0;
int lastLineNumber = 0;
int endTagIndex = 0;
// Parse through Character buffer to read html tags and begin creating mesh.
for (int i = 0; m_text_buffer[i] != 0; i++)
{
m_tabSpacing = -999;
m_spacing = -999;
charCode = m_text_buffer[i];
if (m_isRichText && charCode == 60) // '<'
{
// Check if Tag is valid. If valid, skip to the end of the validated tag.
if (ValidateHtmlTag(m_text_buffer, i + 1, out endTagIndex))
{
i = endTagIndex;
if (m_tabSpacing != -999)
{
// Move character to a fix position. Position expresses in characters (approximation).
m_xAdvance = m_tabSpacing * m_cached_Underline_GlyphInfo.width * m_fontScale;
}
if (m_spacing != -999)
{
m_xAdvance += m_spacing * m_fontScale * m_cached_Underline_GlyphInfo.width;
}
continue;
}
}
//isMissingCharacter = false;
// Look up Character Data from Dictionary and cache it.
m_fontAssetArray[m_fontIndex].characterDictionary.TryGetValue(charCode, out m_cached_GlyphInfo);
if (m_cached_GlyphInfo == null)
{
// Character wasn't found in the Dictionary.
m_fontAssetArray[m_fontIndex].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.");
// 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 ...
//continue;
}
}
// Store some of the text object's information
temp_textInfo.characterInfo[character_Count].character = (char)charCode;
//temp_textInfo.characterInfo[character_Count].color = m_htmlColor;
//temp_textInfo.characterInfo[character_Count].style = m_style;
temp_textInfo.characterInfo[character_Count].index = (short)i;
// Handle Kerning if Enabled.
if (m_enableKerning && character_Count >= 1)
{
KerningPairKey keyValue = new KerningPairKey(prev_charCode, charCode);
KerningPair pair;
m_fontAsset.kerningDictionary.TryGetValue(keyValue.key, out pair);
if (pair != null)
{
m_xAdvance += pair.XadvanceOffset * m_fontScale;
}
}
// Set Padding based on selected font style
if ((m_style & FontStyles.Bold) == FontStyles.Bold) // Checks for any combination of Bold Style.
{
style_padding = m_fontAsset.BoldStyle * 2;
xadvance_multiplier = 1.07f; // Increase xAdvance for bold characters.
}
else
{
style_padding = m_fontAsset.NormalStyle * 2;
xadvance_multiplier = 1.0f;
}
// Setup Vertices for each character.
Vector3 top_left = new Vector3(0 + m_xAdvance + ((m_cached_GlyphInfo.xOffset - m_padding - style_padding) * m_fontScale), (m_cached_GlyphInfo.yOffset + m_baselineOffset + m_padding) * m_fontScale - lineOffset * baseScale, 0);
Vector3 bottom_left = new Vector3(top_left.x, top_left.y - ((m_cached_GlyphInfo.height + m_padding * 2) * m_fontScale), 0);
Vector3 top_right = new Vector3(bottom_left.x + ((m_cached_GlyphInfo.width + m_padding * 2 + style_padding * 2) * m_fontScale), 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
if ((m_style & 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_fontAsset.ItalicStyle * 0.01f;
Vector3 topShear = new Vector3(shear_value * ((m_cached_GlyphInfo.yOffset + m_padding + style_padding) * m_fontScale), 0, 0);
Vector3 bottomShear = new Vector3(shear_value * (((m_cached_GlyphInfo.yOffset - m_cached_GlyphInfo.height - m_padding - style_padding)) * m_fontScale), 0, 0);
top_left = top_left + topShear;
bottom_left = bottom_left + bottomShear;
top_right = top_right + topShear;
bottom_right = bottom_right + bottomShear;
}
// Track Word Count per line and for the object
if (character_Count > 0 && (char.IsWhiteSpace((char)charCode) || char.IsPunctuation((char)charCode)))
{
if (char.IsLetterOrDigit(temp_textInfo.characterInfo[character_Count - 1].character))
{
wordCount += 1;
temp_textInfo.lineInfo[lineNumber].wordCount += 1;
}
}
// Setup Mesh for visible characters. ie. not a SPACE / LINEFEED / CARRIAGE RETURN.
if (charCode != 32 && charCode != 9 && charCode != 10 && charCode != 13)
{
// Determine the bounds of the Mesh.
//meshExtents.min = new Vector2(Mathf.Min(meshExtents.min.x, bottom_left.x), Mathf.Min(meshExtents.min.y, bottom_left.y));
//meshExtents.max = new Vector2(Mathf.Max(meshExtents.max.x, top_right.x), Mathf.Max(meshExtents.max.y, top_left.y));
// Determine the extend of each line
LineInfo lineInfo = temp_textInfo.lineInfo[lineNumber];
Extents lineExtents = lineInfo.lineExtents;
temp_textInfo.lineInfo[lineNumber].lineExtents.min = new Vector2(Mathf.Min(lineExtents.min.x, bottom_left.x), Mathf.Min(lineExtents.min.y, bottom_left.y));
temp_textInfo.lineInfo[lineNumber].lineExtents.max = new Vector2(Mathf.Max(lineExtents.max.x, top_right.x), Mathf.Max(lineExtents.max.y, top_left.y));
if (m_enableWordWrapping && top_right.x > m_lineLength)
{
// Check if further wrapping is possible or if we need to increase the line length
if (wrappingIndex == m_SaveWordWrapState.previous_WordBreak)
{
if (isAffectingWordWrapping)
{
m_lineLength = Mathf.Round(top_right.x * 100 + 0.5f) / 100f;//m_lineLength = top_right.x;
GenerateTextMesh();
isAffectingWordWrapping = false;
}
Debug.Log("Line " + lineNumber + " Cannot wrap lines anymore.");
return(null);
}
// Restore to previously stored state
character_Count = m_SaveWordWrapState.total_CharacterCount + 1;
visibleCharacter_Count = m_SaveWordWrapState.visible_CharacterCount;
m_textInfo.lineInfo[lineNumber] = m_SaveWordWrapState.lineInfo;
m_htmlColor = m_SaveWordWrapState.vertexColor;
m_style = m_SaveWordWrapState.fontStyle;
m_baselineOffset = m_SaveWordWrapState.baselineOffset;
m_fontScale = m_SaveWordWrapState.fontScale;
i = m_SaveWordWrapState.previous_WordBreak;
wrappingIndex = i; // Used to dectect when line length can no longer be reduced.
lineNumber += 1;
// Check to make sure Array is large enough to hold a new line.
if (lineNumber >= temp_textInfo.lineInfo.Length)
{
Array.Resize(ref temp_textInfo.lineInfo, Mathf.NextPowerOfTwo(lineNumber));
}
lineOffset += (m_fontAssetArray[m_fontIndex].fontInfo.LineHeight + m_lineSpacing);
m_xAdvance = 0;
continue;
}
//visibleCharacter_Count += 1;
}
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)
{
//m_lineExtents[lineNumber].spaceCount += 1;
temp_textInfo.lineInfo[lineNumber].spaceCount += 1;
temp_textInfo.spaceCount += 1;
}
// 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.
m_SaveWordWrapState.previous_WordBreak = i;
m_SaveWordWrapState.total_CharacterCount = character_Count;
m_SaveWordWrapState.visible_CharacterCount = visibleCharacter_Count;
m_SaveWordWrapState.maxLineLength = m_xAdvance;
m_SaveWordWrapState.fontScale = m_fontScale;
m_SaveWordWrapState.baselineOffset = m_baselineOffset;
m_SaveWordWrapState.fontStyle = m_style;
m_SaveWordWrapState.vertexColor = m_htmlColor;
m_SaveWordWrapState.lineInfo = temp_textInfo.lineInfo[lineNumber];
}
// Store Rectangle positions for each Character.
temp_textInfo.characterInfo[character_Count].bottomLeft = bottom_left;
temp_textInfo.characterInfo[character_Count].topRight = top_right;
temp_textInfo.characterInfo[character_Count].lineNumber = (short)lineNumber;
//temp_textInfo.characterInfo[character_Count].baseLine = top_right.y - (m_cached_GlyphInfo.yOffset + m_padding) * m_fontScale;
//temp_textInfo.characterInfo[character_Count].topLine = temp_textInfo.characterInfo[character_Count].baseLine + (m_fontAssetArray[m_fontIndex].fontInfo.Ascender + m_alignmentPadding.y) * m_fontScale; // Ascender
//temp_textInfo.characterInfo[character_Count].bottomLine = temp_textInfo.characterInfo[character_Count].baseLine + (m_fontAssetArray[m_fontIndex].fontInfo.Descender - m_alignmentPadding.w) * m_fontScale; // Descender
maxAscender = temp_textInfo.characterInfo[character_Count].topLine > maxAscender ? temp_textInfo.characterInfo[character_Count].topLine : maxAscender;
maxDescender = temp_textInfo.characterInfo[character_Count].bottomLine < maxDescender ? temp_textInfo.characterInfo[character_Count].bottomLine : maxDescender;
//temp_textInfo.characterInfo[character_Count].aspectRatio = m_cached_GlyphInfo.width / m_cached_GlyphInfo.height;
//temp_textInfo.characterInfo[character_Count].scale = m_fontScale;
temp_textInfo.lineInfo[lineNumber].characterCount += 1;
//Debug.Log("Character #" + i + " is [" + (char)charCode + "] ASCII (" + charCode + ")");
// Store LineInfo
if (lineNumber != lastLineNumber)
{
temp_textInfo.lineInfo[lineNumber].firstCharacterIndex = character_Count;
temp_textInfo.lineInfo[lineNumber - 1].lastCharacterIndex = character_Count - 1;
temp_textInfo.lineInfo[lineNumber - 1].characterCount = temp_textInfo.lineInfo[lineNumber - 1].lastCharacterIndex - temp_textInfo.lineInfo[lineNumber - 1].firstCharacterIndex + 1;
temp_textInfo.lineInfo[lineNumber - 1].lineLength = temp_textInfo.characterInfo[character_Count - 1].topRight.x - m_padding * m_fontScale;
}
lastLineNumber = lineNumber;
// Handle Tabulation Stops. Tab stops at every 25% of Font Size.
if (charCode == 9)
{
m_xAdvance = (int)(m_xAdvance / (m_fontSize * 0.25f) + 1) * (m_fontSize * 0.25f);
}
else
{
m_xAdvance += (m_cached_GlyphInfo.xAdvance * xadvance_multiplier * m_fontScale) + m_characterSpacing;
}
// Handle Line Feed as well as Word Wrapping
if (charCode == 10 || charCode == 13)
{
lineNumber += 1;
// Check to make sure Array is large enough to hold a new line.
if (lineNumber >= temp_textInfo.lineInfo.Length)
{
Array.Resize(ref temp_textInfo.lineInfo, Mathf.NextPowerOfTwo(lineNumber));
}
lineOffset += (m_fontAssetArray[m_fontIndex].fontInfo.LineHeight + m_lineSpacing);
m_xAdvance = 0;
}
character_Count += 1;
prev_charCode = charCode;
}
temp_textInfo.lineInfo[lineNumber].lastCharacterIndex = character_Count - 1;
temp_textInfo.lineInfo[lineNumber].characterCount = temp_textInfo.lineInfo[lineNumber].lastCharacterIndex - temp_textInfo.lineInfo[lineNumber].firstCharacterIndex + 1;
temp_textInfo.lineInfo[lineNumber].lineLength = temp_textInfo.characterInfo[character_Count - 1].topRight.x - m_padding * m_fontScale;
//m_textMetrics = new TMPro_TextMetrics();
temp_textInfo.characterCount = character_Count;
temp_textInfo.lineCount = lineNumber + 1;
temp_textInfo.wordCount = wordCount;
//for (int i = 0; i < lineNumber + 1; i++)
//{
// Debug.Log("Line: " + (i + 1) + " # Char: " + temp_textInfo.lineInfo[i].characterCount
// + " Word Count: " + temp_textInfo.lineInfo[i].wordCount
// + " Space: " + temp_textInfo.lineInfo[i].spaceCount
// + " First:" + temp_textInfo.lineInfo[i].firstCharacterIndex + " Last [" + temp_textInfo.characterInfo[temp_textInfo.lineInfo[i].lastCharacterIndex].character
// + "] at Index: " + temp_textInfo.lineInfo[i].lastCharacterIndex + " Length: " + temp_textInfo.lineInfo[i].lineLength
// + " Line Extents: " + temp_textInfo.lineInfo[i].lineExtents);
// //Debug.Log("line: " + (i + 1) + " m_lineExtents Count: " + m_lineExtents[i].characterCount + " lineInfo: " + m_textInfo.lineInfo[i].characterCount);
// //Debug.DrawLine(new Vector3(m_textInfo.lineInfo[i].lineLength, 2, 0), new Vector3(m_textInfo.lineInfo[i].lineLength, -2, 0), Color.red, 30f);
//}
return(temp_textInfo);
}
