From c55fba8ab2a1c9d3df65eda4a5a1e957f4aa1f78 Mon Sep 17 00:00:00 2001 From: Andrew Lee Date: Sun, 19 Apr 2020 17:19:32 -0400 Subject: Inital commit --- .../Scripts/Runtime/TMP_SubMesh.cs | 580 +++++++++++++++++++++ 1 file changed, 580 insertions(+) create mode 100644 Library/PackageCache/com.unity.textmeshpro@2.0.1/Scripts/Runtime/TMP_SubMesh.cs (limited to 'Library/PackageCache/com.unity.textmeshpro@2.0.1/Scripts/Runtime/TMP_SubMesh.cs') diff --git a/Library/PackageCache/com.unity.textmeshpro@2.0.1/Scripts/Runtime/TMP_SubMesh.cs b/Library/PackageCache/com.unity.textmeshpro@2.0.1/Scripts/Runtime/TMP_SubMesh.cs new file mode 100644 index 0000000..c9c7648 --- /dev/null +++ b/Library/PackageCache/com.unity.textmeshpro@2.0.1/Scripts/Runtime/TMP_SubMesh.cs @@ -0,0 +1,580 @@ +using UnityEngine; +using System; +using System.Collections; + +#pragma warning disable 0109 // Disable warning due to conflict between Unity Editor DLL and Runtime DLL related to .renderer property being available in one but not the other. + +namespace TMPro +{ + [RequireComponent(typeof(MeshRenderer))] + [RequireComponent(typeof(MeshFilter))] + [ExecuteAlways] + public class TMP_SubMesh : MonoBehaviour + { + /// + /// The TMP Font Asset assigned to this sub text object. + /// + public TMP_FontAsset fontAsset + { + get { return m_fontAsset; } + set { m_fontAsset = value; } + } + [SerializeField] + private TMP_FontAsset m_fontAsset; + + + /// + /// The TMP Sprite Asset assigned to this sub text object. + /// + public TMP_SpriteAsset spriteAsset + { + get { return m_spriteAsset; } + set { m_spriteAsset = value; } + } + [SerializeField] + private TMP_SpriteAsset m_spriteAsset; + + + /// + /// The material to be assigned to this object. Returns an instance of the material. + /// + public Material material + { + // Return a new Instance of the Material if none exists. Otherwise return the current Material Instance. + get { return GetMaterial(m_sharedMaterial); } + + // Assign new font material + set + { + if (m_sharedMaterial.GetInstanceID() == value.GetInstanceID()) + return; + + m_sharedMaterial = m_material = value; + + m_padding = GetPaddingForMaterial(); + + SetVerticesDirty(); + SetMaterialDirty(); + } + } + [SerializeField] + private Material m_material; + + + /// + /// The material to be assigned to this text object. + /// + public Material sharedMaterial + { + get { return m_sharedMaterial; } + set { SetSharedMaterial(value); } + } + [SerializeField] + private Material m_sharedMaterial; + + + /// + /// The fallback material created from the properties of the fallback source material. + /// + public Material fallbackMaterial + { + get { return m_fallbackMaterial; } + set + { + if (m_fallbackMaterial == value) return; + + if (m_fallbackMaterial != null && m_fallbackMaterial != value) + TMP_MaterialManager.ReleaseFallbackMaterial(m_fallbackMaterial); + + m_fallbackMaterial = value; + TMP_MaterialManager.AddFallbackMaterialReference(m_fallbackMaterial); + + SetSharedMaterial(m_fallbackMaterial); + } + } + private Material m_fallbackMaterial; + + + /// + /// The source material used by the fallback font + /// + public Material fallbackSourceMaterial + { + get { return m_fallbackSourceMaterial; } + set { m_fallbackSourceMaterial = value; } + } + private Material m_fallbackSourceMaterial; + + + /// + /// Is the text object using the default font asset material. + /// + public bool isDefaultMaterial + { + get { return m_isDefaultMaterial; } + set { m_isDefaultMaterial = value; } + } + [SerializeField] + private bool m_isDefaultMaterial; + + + /// + /// Padding value resulting for the property settings on the material. + /// + public float padding + { + get { return m_padding; } + set { m_padding = value; } + } + [SerializeField] + private float m_padding; + + + /// + /// The Mesh Renderer of this text sub object. + /// + public new Renderer renderer + { + get { if (m_renderer == null) m_renderer = GetComponent(); + + return m_renderer; + } + } + [SerializeField] + private Renderer m_renderer; + + + /// + /// The MeshFilter of this text sub object. + /// + public MeshFilter meshFilter + { + get { if (m_meshFilter == null) m_meshFilter = GetComponent(); + return m_meshFilter; + } + } + [SerializeField] + private MeshFilter m_meshFilter; + + + /// + /// The Mesh of this text sub object. + /// + public Mesh mesh + { + get + { + if (m_mesh == null) + { + m_mesh = new Mesh(); + m_mesh.hideFlags = HideFlags.HideAndDontSave; + this.meshFilter.mesh = m_mesh; + } + + return m_mesh; + } + set { m_mesh = value; } + } + private Mesh m_mesh; + + /// + /// + /// + //public BoxCollider boxCollider + //{ + // get + // { + // if (m_boxCollider == null) + // { + // // + // m_boxCollider = GetComponent(); + // if (m_boxCollider == null) + // { + // m_boxCollider = gameObject.AddComponent(); + // gameObject.AddComponent(); + // } + // } + + // return m_boxCollider; + // } + //} + //[SerializeField] + //private BoxCollider m_boxCollider; + + [SerializeField] + private TextMeshPro m_TextComponent; + + [NonSerialized] + private bool m_isRegisteredForEvents; + + + void OnEnable() + { + // Register Callbacks for various events. + if (!m_isRegisteredForEvents) + { + #if UNITY_EDITOR + TMPro_EventManager.MATERIAL_PROPERTY_EVENT.Add(ON_MATERIAL_PROPERTY_CHANGED); + TMPro_EventManager.FONT_PROPERTY_EVENT.Add(ON_FONT_PROPERTY_CHANGED); + //TMPro_EventManager.TEXTMESHPRO_PROPERTY_EVENT.Add(ON_TEXTMESHPRO_PROPERTY_CHANGED); + TMPro_EventManager.DRAG_AND_DROP_MATERIAL_EVENT.Add(ON_DRAG_AND_DROP_MATERIAL); + //TMPro_EventManager.TEXT_STYLE_PROPERTY_EVENT.Add(ON_TEXT_STYLE_CHANGED); + TMPro_EventManager.SPRITE_ASSET_PROPERTY_EVENT.Add(ON_SPRITE_ASSET_PROPERTY_CHANGED); + //TMPro_EventManager.TMP_SETTINGS_PROPERTY_EVENT.Add(ON_TMP_SETTINGS_CHANGED); + #endif + + m_isRegisteredForEvents = true; + } + + // Make the geometry visible when the object is enabled. + meshFilter.sharedMesh = mesh; + + // Update _ClipRect values + if (m_sharedMaterial != null) + m_sharedMaterial.SetVector(ShaderUtilities.ID_ClipRect, new Vector4(-32767, -32767, 32767, 32767)); + } + + + void OnDisable() + { + // Hide the geometry when the object is disabled. + m_meshFilter.sharedMesh = null; + + if (m_fallbackMaterial != null) + { + TMP_MaterialManager.ReleaseFallbackMaterial(m_fallbackMaterial); + m_fallbackMaterial = null; + } + + + } + + + void OnDestroy() + { + // Destroy Mesh + if (m_mesh != null) DestroyImmediate(m_mesh); + + if (m_fallbackMaterial != null) + { + TMP_MaterialManager.ReleaseFallbackMaterial(m_fallbackMaterial); + m_fallbackMaterial = null; + } + + #if UNITY_EDITOR + // Unregister the event this object was listening to + TMPro_EventManager.MATERIAL_PROPERTY_EVENT.Remove(ON_MATERIAL_PROPERTY_CHANGED); + TMPro_EventManager.FONT_PROPERTY_EVENT.Remove(ON_FONT_PROPERTY_CHANGED); + //TMPro_EventManager.TEXTMESHPRO_PROPERTY_EVENT.Remove(ON_TEXTMESHPRO_PROPERTY_CHANGED); + TMPro_EventManager.DRAG_AND_DROP_MATERIAL_EVENT.Remove(ON_DRAG_AND_DROP_MATERIAL); + //TMPro_EventManager.TEXT_STYLE_PROPERTY_EVENT.Remove(ON_TEXT_STYLE_CHANGED); + TMPro_EventManager.SPRITE_ASSET_PROPERTY_EVENT.Remove(ON_SPRITE_ASSET_PROPERTY_CHANGED); + //TMPro_EventManager.TMP_SETTINGS_PROPERTY_EVENT.Remove(ON_TMP_SETTINGS_CHANGED); + #endif + m_isRegisteredForEvents = false; + } + + + + #if UNITY_EDITOR + // Event received when custom material editor properties are changed. + void ON_MATERIAL_PROPERTY_CHANGED(bool isChanged, Material mat) + { + //Debug.Log("*** ON_MATERIAL_PROPERTY_CHANGED ***"); + int targetMaterialID = mat.GetInstanceID(); + int sharedMaterialID = m_sharedMaterial.GetInstanceID(); + int fallbackSourceMaterialID = m_fallbackSourceMaterial == null ? 0 : m_fallbackSourceMaterial.GetInstanceID(); + + // Filter events and return if the affected material is not this object's material. + if (targetMaterialID != sharedMaterialID) + { + // Check if event applies to the source fallback material + if (m_fallbackMaterial != null && fallbackSourceMaterialID == targetMaterialID) + TMP_MaterialManager.CopyMaterialPresetProperties(mat, m_fallbackMaterial); + else + return; + } + + if (m_TextComponent == null) m_TextComponent = GetComponentInParent(); + + m_padding = GetPaddingForMaterial(); + + m_TextComponent.havePropertiesChanged = true; + m_TextComponent.SetVerticesDirty(); + } + + + // Event to Track Material Changed resulting from Drag-n-drop. + void ON_DRAG_AND_DROP_MATERIAL(GameObject obj, Material currentMaterial, Material newMaterial) + { + // Check if event applies to this current object + #if UNITY_2018_2_OR_NEWER + if (obj == gameObject || UnityEditor.PrefabUtility.GetCorrespondingObjectFromSource(gameObject) == obj) + #else + if (obj == gameObject || UnityEditor.PrefabUtility.GetPrefabParent(gameObject) == obj) + #endif + { + if (!m_isDefaultMaterial) return; + + // Make sure we have a valid reference to the renderer. + if (m_renderer == null) m_renderer = GetComponent(); + + UnityEditor.Undo.RecordObject(this, "Material Assignment"); + UnityEditor.Undo.RecordObject(m_renderer, "Material Assignment"); + + SetSharedMaterial(newMaterial); + m_TextComponent.havePropertiesChanged = true; + } + } + + + // Event received when font asset properties are changed in Font Inspector + void ON_SPRITE_ASSET_PROPERTY_CHANGED(bool isChanged, UnityEngine.Object obj) + { + //if (spriteSheet != null && (obj as TMP_SpriteAsset == m_spriteAsset || obj as Texture2D == m_spriteAsset.spriteSheet)) + //{ + if (m_TextComponent != null) + { + m_TextComponent.havePropertiesChanged = true; + //m_TextComponent.SetVerticesDirty(); + } + + //} + } + + // Event received when font asset properties are changed in Font Inspector + void ON_FONT_PROPERTY_CHANGED(bool isChanged, TMP_FontAsset font) + { + if (m_fontAsset != null && font.GetInstanceID() == m_fontAsset.GetInstanceID()) + { + // Copy Normal and Bold Weight + if (m_fallbackMaterial != null) + { + m_fallbackMaterial.SetFloat(ShaderUtilities.ID_WeightNormal, m_fontAsset.normalStyle); + m_fallbackMaterial.SetFloat(ShaderUtilities.ID_WeightBold, m_fontAsset.boldStyle); + } + } + } + + /// + /// Event received when the TMP Settings are changed. + /// + void ON_TMP_SETTINGS_CHANGED() + { + // //Debug.Log("TMP Setting have changed."); + // //SetVerticesDirty(); + // SetMaterialDirty(); + } + #endif + + + + public static TMP_SubMesh AddSubTextObject(TextMeshPro textComponent, MaterialReference materialReference) + { + GameObject go = new GameObject("TMP SubMesh [" + materialReference.material.name + "]", typeof(TMP_SubMesh)); + + TMP_SubMesh subMesh = go.GetComponent(); + + go.transform.SetParent(textComponent.transform, false); + go.transform.localPosition = Vector3.zero; + go.transform.localRotation = Quaternion.identity; + go.transform.localScale = Vector3.one; + go.layer = textComponent.gameObject.layer; + + subMesh.m_meshFilter = go.GetComponent(); + + subMesh.m_TextComponent = textComponent; + subMesh.m_fontAsset = materialReference.fontAsset; + subMesh.m_spriteAsset = materialReference.spriteAsset; + subMesh.m_isDefaultMaterial = materialReference.isDefaultMaterial; + subMesh.SetSharedMaterial(materialReference.material); + + subMesh.renderer.sortingLayerID = textComponent.renderer.sortingLayerID; + subMesh.renderer.sortingOrder = textComponent.renderer.sortingOrder; + + return subMesh; + } + + + public void DestroySelf() + { + Destroy(this.gameObject, 1f); + } + + // Function called internally when a new material is assigned via the fontMaterial property. + Material GetMaterial(Material mat) + { + // Check in case Object is disabled. If so, we don't have a valid reference to the Renderer. + // This can occur when the Duplicate Material Context menu is used on an inactive object. + if (m_renderer == null) + m_renderer = GetComponent(); + + // Create Instance Material only if the new material is not the same instance previously used. + if (m_material == null || m_material.GetInstanceID() != mat.GetInstanceID()) + m_material = CreateMaterialInstance(mat); + + m_sharedMaterial = m_material; + + // Compute and Set new padding values for this new material. + m_padding = GetPaddingForMaterial(); + + SetVerticesDirty(); + SetMaterialDirty(); + + return m_sharedMaterial; + } + + + /// + /// Method used to create an instance of the material + /// + /// + /// + Material CreateMaterialInstance(Material source) + { + Material mat = new Material(source); + mat.shaderKeywords = source.shaderKeywords; + mat.name += " (Instance)"; + + return mat; + } + + + /// + /// Method returning the shared material assigned to the text object. + /// + /// + Material GetSharedMaterial() + { + if (m_renderer == null) + m_renderer = GetComponent(); + + return m_renderer.sharedMaterial; + } + + + /// + /// Method to set the shared material. + /// + /// + void SetSharedMaterial(Material mat) + { + //Debug.Log("*** SetSharedMaterial() *** FRAME (" + Time.frameCount + ")"); + + // Assign new material. + m_sharedMaterial = mat; + + // Compute and Set new padding values for this new material. + m_padding = GetPaddingForMaterial(); + + SetMaterialDirty(); + + #if UNITY_EDITOR + if (m_sharedMaterial != null) + gameObject.name = "TMP SubMesh [" + m_sharedMaterial.name + "]"; + #endif + } + + + /// + /// Function called when the padding value for the material needs to be re-calculated. + /// + /// + public float GetPaddingForMaterial() + { + float padding = ShaderUtilities.GetPadding(m_sharedMaterial, m_TextComponent.extraPadding, m_TextComponent.isUsingBold); + + return padding; + } + + + /// + /// Function to update the padding values of the object. + /// + /// + /// + public void UpdateMeshPadding(bool isExtraPadding, bool isUsingBold) + { + m_padding = ShaderUtilities.GetPadding(m_sharedMaterial, isExtraPadding, isUsingBold); + } + + + /// + /// + /// + public void SetVerticesDirty() + { + if (!this.enabled) + return; + + // This is called on the parent TextMeshPro component. + if (m_TextComponent != null) + { + m_TextComponent.havePropertiesChanged = true; + m_TextComponent.SetVerticesDirty(); + } + } + + + /// + /// + /// + public void SetMaterialDirty() + { + //if (!this.enabled) + // return; + + UpdateMaterial(); + + //m_materialDirty = true; + //TMP_UpdateRegistry.RegisterCanvasElementForGraphicRebuild((ICanvasElement)this); + } + + + /// + /// + /// + protected void UpdateMaterial() + { + //Debug.Log("*** STO - UpdateMaterial() *** FRAME (" + Time.frameCount + ")"); + + //if (!this.enabled) + // return; + + if (m_renderer == null) m_renderer = this.renderer; + + m_renderer.sharedMaterial = m_sharedMaterial; + + #if UNITY_EDITOR + if (m_sharedMaterial != null && gameObject.name != "TMP SubMesh [" + m_sharedMaterial.name + "]") + gameObject.name = "TMP SubMesh [" + m_sharedMaterial.name + "]"; + #endif + } + + /// + /// + /// + //public void UpdateColliders(int vertexCount) + //{ + // if (this.boxCollider == null) return; + + // Vector2 bl = TMP_Math.MAX_16BIT; + // Vector2 tr = TMP_Math.MIN_16BIT; + // // Compute the bounds of the sub text object mesh (excluding the transform position). + // for (int i = 0; i < vertexCount; i++) + // { + // bl.x = Mathf.Min(bl.x, m_mesh.vertices[i].x); + // bl.y = Mathf.Min(bl.y, m_mesh.vertices[i].y); + + // tr.x = Mathf.Max(tr.x, m_mesh.vertices[i].x); + // tr.y = Mathf.Max(tr.y, m_mesh.vertices[i].y); + // } + + // Vector3 center = (bl + tr) / 2; + // Vector3 size = tr - bl; + // size.z = .1f; + // this.boxCollider.center = center; + // this.boxCollider.size = size; + //} + } +} -- cgit v1.2.3