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/TextMeshProUGUI.cs | 656 +++++++++++++++++++++ 1 file changed, 656 insertions(+) create mode 100644 Library/PackageCache/com.unity.textmeshpro@2.0.1/Scripts/Runtime/TextMeshProUGUI.cs (limited to 'Library/PackageCache/com.unity.textmeshpro@2.0.1/Scripts/Runtime/TextMeshProUGUI.cs') diff --git a/Library/PackageCache/com.unity.textmeshpro@2.0.1/Scripts/Runtime/TextMeshProUGUI.cs b/Library/PackageCache/com.unity.textmeshpro@2.0.1/Scripts/Runtime/TextMeshProUGUI.cs new file mode 100644 index 0000000..be57eb1 --- /dev/null +++ b/Library/PackageCache/com.unity.textmeshpro@2.0.1/Scripts/Runtime/TextMeshProUGUI.cs @@ -0,0 +1,656 @@ +using UnityEngine; +using System; +using System.Collections; +using System.Collections.Generic; + +using UnityEngine.UI; +using UnityEngine.EventSystems; +using UnityEngine.UI.CoroutineTween; + + +#pragma warning disable 0414 // Disabled a few warnings related to serialized variables not used in this script but used in the editor. + +namespace TMPro +{ + + [DisallowMultipleComponent] + [RequireComponent(typeof(RectTransform))] + [RequireComponent(typeof(CanvasRenderer))] + [AddComponentMenu("UI/TextMeshPro - Text (UI)", 11)] + [ExecuteAlways] + public partial class TextMeshProUGUI : TMP_Text, ILayoutElement + { + /// + /// Get the material that will be used for rendering. + /// + public override Material materialForRendering + { + get { return TMP_MaterialManager.GetMaterialForRendering(this, m_sharedMaterial); } + } + + /// + /// Determines if the size of the text container will be adjusted to fit the text object when it is first created. + /// + public override bool autoSizeTextContainer + { + get { return m_autoSizeTextContainer; } + + set { if (m_autoSizeTextContainer == value) return; m_autoSizeTextContainer = value; if (m_autoSizeTextContainer) { CanvasUpdateRegistry.RegisterCanvasElementForLayoutRebuild(this); SetLayoutDirty(); } } + } + + + + /// + /// Reference to the Mesh used by the text object. + /// + public override Mesh mesh + { + get { return m_mesh; } + } + + + /// + /// Reference to the CanvasRenderer used by the text object. + /// + public new CanvasRenderer canvasRenderer + { + get + { + if (m_canvasRenderer == null) m_canvasRenderer = GetComponent(); + + return m_canvasRenderer; + } + } + + + /// + /// Anchor dampening prevents the anchor position from being adjusted unless the positional change exceeds about 40% of the width of the underline character. This essentially stabilizes the anchor position. + /// + //public bool anchorDampening + //{ + // get { return m_anchorDampening; } + // set { if (m_anchorDampening != value) { havePropertiesChanged = true; m_anchorDampening = value; /* ScheduleUpdate(); */ } } + //} + + + private bool m_isRebuildingLayout = false; + //private bool m_isLayoutDirty = false; + + + /// + /// Function called by Unity when the horizontal layout needs to be recalculated. + /// + public void CalculateLayoutInputHorizontal() + { + //Debug.Log("*** CalculateLayoutHorizontal() ***"); // at Frame: " + Time.frameCount); // called on Object ID " + GetInstanceID()); + + //// Check if object is active + if (!this.gameObject.activeInHierarchy) + return; + + if (m_isCalculateSizeRequired || m_rectTransform.hasChanged) + { + m_preferredWidth = GetPreferredWidth(); + + ComputeMarginSize(); + + m_isLayoutDirty = true; + } + } + + + /// + /// Function called by Unity when the vertical layout needs to be recalculated. + /// + public void CalculateLayoutInputVertical() + { + //Debug.Log("*** CalculateLayoutInputVertical() ***"); // at Frame: " + Time.frameCount); // called on Object ID " + GetInstanceID()); + + //// Check if object is active + if (!this.gameObject.activeInHierarchy) // || IsRectTransformDriven == false) + return; + + if (m_isCalculateSizeRequired || m_rectTransform.hasChanged) + { + m_preferredHeight = GetPreferredHeight(); + + ComputeMarginSize(); + + m_isLayoutDirty = true; + } + + m_isCalculateSizeRequired = false; + } + + + public override void SetVerticesDirty() + { + if (m_verticesAlreadyDirty || this == null || !this.IsActive() || CanvasUpdateRegistry.IsRebuildingGraphics()) + return; + + m_verticesAlreadyDirty = true; + CanvasUpdateRegistry.RegisterCanvasElementForGraphicRebuild((ICanvasElement)this); + + if (m_OnDirtyVertsCallback != null) + m_OnDirtyVertsCallback(); + } + + + /// + /// + /// + public override void SetLayoutDirty() + { + m_isPreferredWidthDirty = true; + m_isPreferredHeightDirty = true; + + if ( m_layoutAlreadyDirty || this == null || !this.IsActive()) + return; + + m_layoutAlreadyDirty = true; + LayoutRebuilder.MarkLayoutForRebuild(this.rectTransform); + + m_isLayoutDirty = true; + + if (m_OnDirtyLayoutCallback != null) + m_OnDirtyLayoutCallback(); + } + + + /// + /// + /// + public override void SetMaterialDirty() + { + //Debug.Log("SetMaterialDirty()"); + + if (this == null || !this.IsActive() || CanvasUpdateRegistry.IsRebuildingGraphics()) + return; + + m_isMaterialDirty = true; + CanvasUpdateRegistry.RegisterCanvasElementForGraphicRebuild((ICanvasElement)this); + + if (m_OnDirtyMaterialCallback != null) + m_OnDirtyMaterialCallback(); + } + + + /// + /// + /// + public override void SetAllDirty() + { + m_isInputParsingRequired = true; + + SetLayoutDirty(); + SetVerticesDirty(); + SetMaterialDirty(); + } + + + + /// + /// + /// + /// + public override void Rebuild(CanvasUpdate update) + { + if (this == null) return; + + if (update == CanvasUpdate.Prelayout) + { + if (m_autoSizeTextContainer) + { + m_rectTransform.sizeDelta = GetPreferredValues(Mathf.Infinity, Mathf.Infinity); + } + } + else if (update == CanvasUpdate.PreRender) + { + OnPreRenderCanvas(); + + m_verticesAlreadyDirty = false; + m_layoutAlreadyDirty = false; + + if (!m_isMaterialDirty) return; + + UpdateMaterial(); + m_isMaterialDirty = false; + } + } + + + /// + /// Method to keep the pivot of the sub text objects in sync with the parent pivot. + /// + private void UpdateSubObjectPivot() + { + if (m_textInfo == null) return; + + for (int i = 1; i < m_subTextObjects.Length && m_subTextObjects[i] != null; i++) + { + m_subTextObjects[i].SetPivotDirty(); + } + //m_isPivotDirty = false; + } + + + /// + /// + /// + /// + /// + public override Material GetModifiedMaterial(Material baseMaterial) + { + Material mat = baseMaterial; + + if (m_ShouldRecalculateStencil) + { + m_stencilID = TMP_MaterialManager.GetStencilID(gameObject); + m_ShouldRecalculateStencil = false; + } + + // Release masking material + //if (m_MaskMaterial != null) + // MaterialManager.ReleaseStencilMaterial(m_MaskMaterial); + + if (m_stencilID > 0) + { + mat = TMP_MaterialManager.GetStencilMaterial(baseMaterial, m_stencilID); + if (m_MaskMaterial != null) + TMP_MaterialManager.ReleaseStencilMaterial(m_MaskMaterial); + + m_MaskMaterial = mat; + } + + return mat; + } + + + /// + /// + /// + protected override void UpdateMaterial() + { + //Debug.Log("*** UpdateMaterial() ***"); + + //if (!this.IsActive()) + // return; + + if (m_sharedMaterial == null) return; + + if (m_canvasRenderer == null) m_canvasRenderer = this.canvasRenderer; + + m_canvasRenderer.materialCount = 1; + m_canvasRenderer.SetMaterial(materialForRendering, 0); + } + + + //public override void OnRebuildRequested() + //{ + // //Debug.Log("OnRebuildRequested"); + + // base.OnRebuildRequested(); + //} + + + + //public override bool Raycast(Vector2 sp, Camera eventCamera) + //{ + // //Debug.Log("Raycast Event. ScreenPoint: " + sp); + // return base.Raycast(sp, eventCamera); + //} + + + // MASKING RELATED PROPERTIES + /// + /// Sets the masking offset from the bounds of the object + /// + public Vector4 maskOffset + { + get { return m_maskOffset; } + set { m_maskOffset = value; UpdateMask(); m_havePropertiesChanged = true; } + } + + + //public override Material defaultMaterial + //{ + // get { Debug.Log("Default Material called."); return m_sharedMaterial; } + //} + + + + //protected override void OnCanvasHierarchyChanged() + //{ + // //Debug.Log("OnCanvasHierarchyChanged..."); + //} + + + // IClippable implementation + /// + /// Method called when the state of a parent changes. + /// + public override void RecalculateClipping() + { + //Debug.Log("***** RecalculateClipping() *****"); + + base.RecalculateClipping(); + } + + // IMaskable Implementation + /// + /// Method called when Stencil Mask needs to be updated on this element and parents. + /// + public override void RecalculateMasking() + { + //Debug.Log("***** RecalculateMasking() *****"); + + this.m_ShouldRecalculateStencil = true; + SetMaterialDirty(); + } + + /// + /// Override of the Cull function to provide for the ability to override the culling of the text object. + /// + /// + /// + public override void Cull(Rect clipRect, bool validRect) + { + if (m_ignoreRectMaskCulling) return; + + base.Cull(clipRect, validRect); + } + + + //protected override void UpdateGeometry() + //{ + // //Debug.Log("UpdateGeometry"); + // //base.UpdateGeometry(); + //} + + + //protected override void UpdateMaterial() + //{ + // //Debug.Log("UpdateMaterial called."); + //// base.UpdateMaterial(); + //} + + + /* + /// + /// Sets the mask type + /// + public MaskingTypes mask + { + get { return m_mask; } + set { m_mask = value; havePropertiesChanged = true; isMaskUpdateRequired = true; } + } + + /// + /// Set the masking offset mode (as percentage or pixels) + /// + public MaskingOffsetMode maskOffsetMode + { + get { return m_maskOffsetMode; } + set { m_maskOffsetMode = value; havePropertiesChanged = true; isMaskUpdateRequired = true; } + } + */ + + + + /* + /// + /// Sets the softness of the mask + /// + public Vector2 maskSoftness + { + get { return m_maskSoftness; } + set { m_maskSoftness = value; havePropertiesChanged = true; isMaskUpdateRequired = true; } + } + + /// + /// Allows to move / offset the mesh vertices by a set amount + /// + public Vector2 vertexOffset + { + get { return m_vertexOffset; } + set { m_vertexOffset = value; havePropertiesChanged = true; isMaskUpdateRequired = true; } + } + */ + + + /// + /// Function to be used to force recomputing of character padding when Shader / Material properties have been changed via script. + /// + 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); + } + + + /// + /// Tweens the CanvasRenderer color associated with this Graphic. + /// + /// Target color. + /// Tween duration. + /// Should ignore Time.scale? + /// Should also Tween the alpha channel? + protected override void InternalCrossFadeColor(Color targetColor, float duration, bool ignoreTimeScale, bool useAlpha) + { + int materialCount = m_textInfo.materialCount; + + for (int i = 1; i < materialCount; i++) + { + m_subTextObjects[i].CrossFadeColor(targetColor, duration, ignoreTimeScale, useAlpha); + } + } + + + /// + /// Tweens the alpha of the CanvasRenderer color associated with this Graphic. + /// + /// Target alpha. + /// Duration of the tween in seconds. + /// Should ignore Time.scale? + protected override void InternalCrossFadeAlpha(float alpha, float duration, bool ignoreTimeScale) + { + int materialCount = m_textInfo.materialCount; + + for (int i = 1; i < materialCount; i++) + { + m_subTextObjects[i].CrossFadeAlpha(alpha, duration, ignoreTimeScale); + } + } + + + /// + /// Function to force regeneration of the mesh before its normal process time. This is useful when changes to the text object properties need to be applied immediately. + /// + public override void ForceMeshUpdate() + { + //if (m_isEnabled == false) this.OnEnable(); + + m_havePropertiesChanged = true; + OnPreRenderCanvas(); + } + + + /// + /// Function to force regeneration of the mesh before its normal process time. This is useful when changes to the text object properties need to be applied immediately. + /// + /// If set to true, the text object will be regenerated regardless of is active state. + public override void ForceMeshUpdate(bool ignoreInactive) + { + m_havePropertiesChanged = true; + m_ignoreActiveState = true; + OnPreRenderCanvas(); + } + + + /// + /// Function used to evaluate the length of a text string. + /// + /// + /// + public override TMP_TextInfo GetTextInfo(string text) + { + StringToCharArray(text, ref m_TextParsingBuffer); + SetArraySizes(m_TextParsingBuffer); + + m_renderMode = TextRenderFlags.DontRender; + + ComputeMarginSize(); + + // Need to make sure we have a valid reference to a Canvas. + if (m_canvas == null) m_canvas = this.canvas; + + GenerateTextMesh(); + + m_renderMode = TextRenderFlags.Render; + + return this.textInfo; + } + + /// + /// Function to clear the geometry of the Primary and Sub Text objects. + /// + public override void ClearMesh() + { + m_canvasRenderer.SetMesh(null); + + for (int i = 1; i < m_subTextObjects.Length && m_subTextObjects[i] != null; i++) + m_subTextObjects[i].canvasRenderer.SetMesh(null); + + //if (m_linkedTextComponent != null) + // m_linkedTextComponent.ClearMesh(); + } + + + /// + /// Function to force the regeneration of the text object. + /// + /// Flags to control which portions of the geometry gets uploaded. + //public override void ForceMeshUpdate(TMP_VertexDataUpdateFlags flags) { } + + + /// + /// Function to update the geometry of the main and sub text objects. + /// + /// + /// + public override void UpdateGeometry(Mesh mesh, int index) + { + mesh.RecalculateBounds(); + + if (index == 0) + { + m_canvasRenderer.SetMesh(mesh); + } + else + { + m_subTextObjects[index].canvasRenderer.SetMesh(mesh); + } + } + + + /// + /// Function to upload the updated vertex data and renderer. + /// + public override void UpdateVertexData(TMP_VertexDataUpdateFlags flags) + { + int materialCount = m_textInfo.materialCount; + + for (int i = 0; i < materialCount; i++) + { + Mesh mesh; + + if (i == 0) + mesh = m_mesh; + else + { + // Clear unused vertices + // TODO: Causes issues when sorting geometry as last vertex data attribute get wiped out. + //m_textInfo.meshInfo[i].ClearUnusedVertices(); + + mesh = m_subTextObjects[i].mesh; + } + + if ((flags & TMP_VertexDataUpdateFlags.Vertices) == TMP_VertexDataUpdateFlags.Vertices) + mesh.vertices = m_textInfo.meshInfo[i].vertices; + + if ((flags & TMP_VertexDataUpdateFlags.Uv0) == TMP_VertexDataUpdateFlags.Uv0) + mesh.uv = m_textInfo.meshInfo[i].uvs0; + + if ((flags & TMP_VertexDataUpdateFlags.Uv2) == TMP_VertexDataUpdateFlags.Uv2) + mesh.uv2 = m_textInfo.meshInfo[i].uvs2; + + //if ((flags & TMP_VertexDataUpdateFlags.Uv4) == TMP_VertexDataUpdateFlags.Uv4) + // mesh.uv4 = m_textInfo.meshInfo[i].uvs4; + + if ((flags & TMP_VertexDataUpdateFlags.Colors32) == TMP_VertexDataUpdateFlags.Colors32) + mesh.colors32 = m_textInfo.meshInfo[i].colors32; + + mesh.RecalculateBounds(); + + if (i == 0) + m_canvasRenderer.SetMesh(mesh); + else + m_subTextObjects[i].canvasRenderer.SetMesh(mesh); + } + } + + + /// + /// Function to upload the updated vertex data and renderer. + /// + public override void UpdateVertexData() + { + int materialCount = m_textInfo.materialCount; + + for (int i = 0; i < materialCount; i++) + { + Mesh mesh; + + if (i == 0) + mesh = m_mesh; + else + { + // Clear unused vertices + m_textInfo.meshInfo[i].ClearUnusedVertices(); + + mesh = m_subTextObjects[i].mesh; + } + + //mesh.MarkDynamic(); + mesh.vertices = m_textInfo.meshInfo[i].vertices; + mesh.uv = m_textInfo.meshInfo[i].uvs0; + mesh.uv2 = m_textInfo.meshInfo[i].uvs2; + //mesh.uv4 = m_textInfo.meshInfo[i].uvs4; + mesh.colors32 = m_textInfo.meshInfo[i].colors32; + + mesh.RecalculateBounds(); + + if (i == 0) + m_canvasRenderer.SetMesh(mesh); + else + m_subTextObjects[i].canvasRenderer.SetMesh(mesh); + } + } + + + public void UpdateFontAsset() + { + LoadFontAsset(); + } + + } +} \ No newline at end of file -- cgit v1.2.3