0d9d8acae0
Compile-driven bulk-copy loop (tools/engine-port/m1_copy_loop.py) pulled the precise reference closure of the battle-core roots, stopping at the classify god-object/View-VFX-UI boundary. 782 files; no re-explosion (M0 had estimated ~order 1000). Residual frontier = 52 shim-classified + 80 external (Unity/BCL) types to author next.
1942 lines
39 KiB
C#
1942 lines
39 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using Wizard;
|
|
|
|
[ExecuteInEditMode]
|
|
[AddComponentMenu("NGUI/UI/NGUI Label")]
|
|
public class UILabel : UIWidget
|
|
{
|
|
public enum Effect
|
|
{
|
|
None,
|
|
Shadow,
|
|
Outline,
|
|
Outline8
|
|
}
|
|
|
|
public enum Overflow
|
|
{
|
|
ShrinkContent,
|
|
ClampContent,
|
|
ResizeFreely,
|
|
ResizeHeight
|
|
}
|
|
|
|
public enum Crispness
|
|
{
|
|
Never,
|
|
OnDesktop,
|
|
Always
|
|
}
|
|
|
|
public Crispness keepCrispWhenShrunk = Crispness.OnDesktop;
|
|
|
|
private static bool OnFontChangedFlg = false;
|
|
|
|
private static UnityEngine.Font OnFontChangedFont;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private UnityEngine.Font mTrueTypeFont;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private UIFont mFont;
|
|
|
|
[Multiline(6)]
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private string mText = "";
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private int mFontSize = 16;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private FontStyle mFontStyle;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private NGUIText.Alignment mAlignment;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private bool mEncoding = true;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private int mMaxLineCount;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private Effect mEffectStyle;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private Color mEffectColor = Color.black;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private NGUIText.SymbolStyle mSymbols = NGUIText.SymbolStyle.Normal;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private Vector2 mEffectDistance = Vector2.one;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private Overflow mOverflow;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private Material mMaterial;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private bool mApplyGradient;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private Color mGradientTop = Color.white;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private Color mGradientBottom = new Color(0.7f, 0.7f, 0.7f);
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private int mSpacingX;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private int mSpacingY;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private bool mUseFloatSpacing;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private float mFloatSpacingX;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private float mFloatSpacingY;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private bool mOverflowEllipsis;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private bool m_bWizardRuby;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private float m_WizardRubyScale = 0.6f;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private float m_WizardRubyMargin = 0.6f;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private bool m_bWizardDot;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private float m_WizardDotScale = 0.8f;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private float m_WizardDotMargin = 0.5f;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private bool _alignmentEachLanguage;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private bool mShrinkToFit;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private int mMaxLineWidth;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private int mMaxLineHeight;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private float mLineWidth;
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private bool mMultiline = true;
|
|
|
|
[NonSerialized]
|
|
private UnityEngine.Font mActiveTTF;
|
|
|
|
[NonSerialized]
|
|
private float mDensity = 1f;
|
|
|
|
[NonSerialized]
|
|
private bool mShouldBeProcessed = true;
|
|
|
|
[NonSerialized]
|
|
private string mProcessedText;
|
|
|
|
[NonSerialized]
|
|
private bool mPremultiply;
|
|
|
|
[NonSerialized]
|
|
private Vector2 mCalculatedSize = Vector2.zero;
|
|
|
|
[NonSerialized]
|
|
private float mScale = 1f;
|
|
|
|
[NonSerialized]
|
|
private int mFinalFontSize;
|
|
|
|
[NonSerialized]
|
|
private int mLastWidth;
|
|
|
|
[NonSerialized]
|
|
private int mLastHeight;
|
|
|
|
private string _originalText;
|
|
|
|
public Action OnWindowResize;
|
|
|
|
private static BetterList<UILabel> mList = new BetterList<UILabel>();
|
|
|
|
private static Dictionary<UnityEngine.Font, int> mFontUsage = new Dictionary<UnityEngine.Font, int>();
|
|
|
|
private static bool mTexRebuildAdded = false;
|
|
|
|
private static BetterList<Vector3> mTempVerts = new BetterList<Vector3>();
|
|
|
|
private static BetterList<int> mTempIndices = new BetterList<int>();
|
|
|
|
public bool IsRuby => m_bWizardRuby;
|
|
|
|
public float RubyScale => m_WizardRubyScale;
|
|
|
|
public float RubyMargin => m_WizardRubyMargin;
|
|
|
|
public bool IsDot => m_bWizardDot;
|
|
|
|
public float DotScale => m_WizardDotScale;
|
|
|
|
public float DotMargin => m_WizardDotMargin;
|
|
|
|
public int finalFontSize
|
|
{
|
|
get
|
|
{
|
|
if ((bool)trueTypeFont)
|
|
{
|
|
return Mathf.RoundToInt(mScale * (float)mFinalFontSize);
|
|
}
|
|
return Mathf.RoundToInt((float)mFinalFontSize * mScale);
|
|
}
|
|
}
|
|
|
|
private bool shouldBeProcessed
|
|
{
|
|
get
|
|
{
|
|
return mShouldBeProcessed;
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
{
|
|
mChanged = true;
|
|
mShouldBeProcessed = true;
|
|
}
|
|
else
|
|
{
|
|
mShouldBeProcessed = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override bool isAnchoredHorizontally
|
|
{
|
|
get
|
|
{
|
|
if (!base.isAnchoredHorizontally)
|
|
{
|
|
return mOverflow == Overflow.ResizeFreely;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public override bool isAnchoredVertically
|
|
{
|
|
get
|
|
{
|
|
if (!base.isAnchoredVertically && mOverflow != Overflow.ResizeFreely)
|
|
{
|
|
return mOverflow == Overflow.ResizeHeight;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public override Material material
|
|
{
|
|
get
|
|
{
|
|
if (mMaterial != null)
|
|
{
|
|
return mMaterial;
|
|
}
|
|
if (mFont != null)
|
|
{
|
|
return mFont.material;
|
|
}
|
|
if (mTrueTypeFont != null)
|
|
{
|
|
return mTrueTypeFont.material;
|
|
}
|
|
return null;
|
|
}
|
|
set
|
|
{
|
|
if (mMaterial != value)
|
|
{
|
|
RemoveFromPanel();
|
|
mMaterial = value;
|
|
MarkAsChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Obsolete("Use UILabel.bitmapFont instead")]
|
|
public UIFont font
|
|
{
|
|
get
|
|
{
|
|
return bitmapFont;
|
|
}
|
|
set
|
|
{
|
|
bitmapFont = value;
|
|
}
|
|
}
|
|
|
|
public UIFont bitmapFont
|
|
{
|
|
get
|
|
{
|
|
return mFont;
|
|
}
|
|
set
|
|
{
|
|
if (mFont != value)
|
|
{
|
|
RemoveFromPanel();
|
|
mFont = value;
|
|
mTrueTypeFont = null;
|
|
MarkAsChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Font trueTypeFont
|
|
{
|
|
get
|
|
{
|
|
if (mTrueTypeFont != null)
|
|
{
|
|
return mTrueTypeFont;
|
|
}
|
|
if (!(mFont != null))
|
|
{
|
|
return null;
|
|
}
|
|
return mFont.dynamicFont;
|
|
}
|
|
set
|
|
{
|
|
if (mTrueTypeFont != value)
|
|
{
|
|
SetActiveFont(null);
|
|
RemoveFromPanel();
|
|
mTrueTypeFont = value;
|
|
shouldBeProcessed = true;
|
|
mFont = null;
|
|
SetActiveFont(value);
|
|
ProcessAndRequest();
|
|
if (mActiveTTF != null)
|
|
{
|
|
base.MarkAsChanged();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Object ambigiousFont
|
|
{
|
|
get
|
|
{
|
|
return (UnityEngine.Object)(((object)mFont) ?? ((object)mTrueTypeFont));
|
|
}
|
|
set
|
|
{
|
|
UIFont uIFont = value as UIFont;
|
|
if (uIFont != null)
|
|
{
|
|
bitmapFont = uIFont;
|
|
}
|
|
else
|
|
{
|
|
trueTypeFont = value as UnityEngine.Font;
|
|
}
|
|
}
|
|
}
|
|
|
|
public string text
|
|
{
|
|
get
|
|
{
|
|
return mText;
|
|
}
|
|
set
|
|
{
|
|
if (mText == value)
|
|
{
|
|
return;
|
|
}
|
|
if (string.IsNullOrEmpty(value))
|
|
{
|
|
if (!string.IsNullOrEmpty(mText))
|
|
{
|
|
mText = "";
|
|
MarkAsChanged();
|
|
ProcessAndRequest();
|
|
}
|
|
}
|
|
else if (mText != value)
|
|
{
|
|
mText = value;
|
|
MarkAsChanged();
|
|
ProcessAndRequest();
|
|
}
|
|
if (autoResizeBoxCollider)
|
|
{
|
|
ResizeCollider();
|
|
}
|
|
}
|
|
}
|
|
|
|
public int defaultFontSize
|
|
{
|
|
get
|
|
{
|
|
if (!(trueTypeFont != null))
|
|
{
|
|
if (!(mFont != null))
|
|
{
|
|
return 16;
|
|
}
|
|
return mFont.defaultSize;
|
|
}
|
|
return mFontSize;
|
|
}
|
|
}
|
|
|
|
public int fontSize
|
|
{
|
|
get
|
|
{
|
|
return mFontSize;
|
|
}
|
|
set
|
|
{
|
|
value = Mathf.Clamp(value, 0, 256);
|
|
if (mFontSize != value)
|
|
{
|
|
mFontSize = value;
|
|
shouldBeProcessed = true;
|
|
ProcessAndRequest();
|
|
}
|
|
}
|
|
}
|
|
|
|
public FontStyle fontStyle
|
|
{
|
|
get
|
|
{
|
|
return mFontStyle;
|
|
}
|
|
set
|
|
{
|
|
if (mFontStyle != value)
|
|
{
|
|
mFontStyle = value;
|
|
shouldBeProcessed = true;
|
|
ProcessAndRequest();
|
|
}
|
|
}
|
|
}
|
|
|
|
public NGUIText.Alignment alignment
|
|
{
|
|
get
|
|
{
|
|
if (_alignmentEachLanguage)
|
|
{
|
|
try
|
|
{
|
|
return (NGUIText.Alignment)Enum.Parse(typeof(NGUIText.Alignment), Data.SystemText.Get("Dialog_Text_Alignment"));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
_ = Application.isPlaying;
|
|
}
|
|
}
|
|
return mAlignment;
|
|
}
|
|
set
|
|
{
|
|
if (mAlignment != value)
|
|
{
|
|
mAlignment = value;
|
|
shouldBeProcessed = true;
|
|
ProcessAndRequest();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool applyGradient
|
|
{
|
|
get
|
|
{
|
|
return mApplyGradient;
|
|
}
|
|
set
|
|
{
|
|
if (mApplyGradient != value)
|
|
{
|
|
mApplyGradient = value;
|
|
MarkAsChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public Color gradientTop
|
|
{
|
|
get
|
|
{
|
|
return mGradientTop;
|
|
}
|
|
set
|
|
{
|
|
if (mGradientTop != value)
|
|
{
|
|
mGradientTop = value;
|
|
if (mApplyGradient)
|
|
{
|
|
MarkAsChanged();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public Color gradientBottom
|
|
{
|
|
get
|
|
{
|
|
return mGradientBottom;
|
|
}
|
|
set
|
|
{
|
|
if (mGradientBottom != value)
|
|
{
|
|
mGradientBottom = value;
|
|
if (mApplyGradient)
|
|
{
|
|
MarkAsChanged();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public int spacingX
|
|
{
|
|
get
|
|
{
|
|
return mSpacingX;
|
|
}
|
|
set
|
|
{
|
|
if (mSpacingX != value)
|
|
{
|
|
mSpacingX = value;
|
|
MarkAsChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public int spacingY
|
|
{
|
|
get
|
|
{
|
|
return mSpacingY;
|
|
}
|
|
set
|
|
{
|
|
if (mSpacingY != value)
|
|
{
|
|
mSpacingY = value;
|
|
MarkAsChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool useFloatSpacing
|
|
{
|
|
get
|
|
{
|
|
return mUseFloatSpacing;
|
|
}
|
|
set
|
|
{
|
|
if (mUseFloatSpacing != value)
|
|
{
|
|
mUseFloatSpacing = value;
|
|
shouldBeProcessed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public float floatSpacingX
|
|
{
|
|
get
|
|
{
|
|
return mFloatSpacingX;
|
|
}
|
|
set
|
|
{
|
|
if (!Mathf.Approximately(mFloatSpacingX, value))
|
|
{
|
|
mFloatSpacingX = value;
|
|
MarkAsChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public float floatSpacingY
|
|
{
|
|
get
|
|
{
|
|
return mFloatSpacingY;
|
|
}
|
|
set
|
|
{
|
|
if (!Mathf.Approximately(mFloatSpacingY, value))
|
|
{
|
|
mFloatSpacingY = value;
|
|
MarkAsChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public float effectiveSpacingY
|
|
{
|
|
get
|
|
{
|
|
if (!mUseFloatSpacing)
|
|
{
|
|
return mSpacingY;
|
|
}
|
|
return mFloatSpacingY;
|
|
}
|
|
}
|
|
|
|
public float effectiveSpacingX
|
|
{
|
|
get
|
|
{
|
|
if (!mUseFloatSpacing)
|
|
{
|
|
return mSpacingX;
|
|
}
|
|
return mFloatSpacingX;
|
|
}
|
|
}
|
|
|
|
public bool overflowEllipsis
|
|
{
|
|
get
|
|
{
|
|
return mOverflowEllipsis;
|
|
}
|
|
set
|
|
{
|
|
if (mOverflowEllipsis != value)
|
|
{
|
|
mOverflowEllipsis = value;
|
|
MarkAsChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool keepCrisp => trueTypeFont != null;
|
|
|
|
public bool supportEncoding
|
|
{
|
|
get
|
|
{
|
|
return mEncoding;
|
|
}
|
|
set
|
|
{
|
|
if (mEncoding != value)
|
|
{
|
|
mEncoding = value;
|
|
shouldBeProcessed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public NGUIText.SymbolStyle symbolStyle
|
|
{
|
|
get
|
|
{
|
|
return mSymbols;
|
|
}
|
|
set
|
|
{
|
|
if (mSymbols != value)
|
|
{
|
|
mSymbols = value;
|
|
shouldBeProcessed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public Overflow overflowMethod
|
|
{
|
|
get
|
|
{
|
|
return mOverflow;
|
|
}
|
|
set
|
|
{
|
|
if (mOverflow != value)
|
|
{
|
|
mOverflow = value;
|
|
shouldBeProcessed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
[Obsolete("Use 'width' instead")]
|
|
public int lineWidth
|
|
{
|
|
get
|
|
{
|
|
return base.width;
|
|
}
|
|
set
|
|
{
|
|
base.width = value;
|
|
}
|
|
}
|
|
|
|
[Obsolete("Use 'height' instead")]
|
|
public int lineHeight
|
|
{
|
|
get
|
|
{
|
|
return base.height;
|
|
}
|
|
set
|
|
{
|
|
base.height = value;
|
|
}
|
|
}
|
|
|
|
public bool multiLine
|
|
{
|
|
get
|
|
{
|
|
return mMaxLineCount != 1;
|
|
}
|
|
set
|
|
{
|
|
if (mMaxLineCount != 1 != value)
|
|
{
|
|
mMaxLineCount = ((!value) ? 1 : 0);
|
|
shouldBeProcessed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override Vector3[] localCorners
|
|
{
|
|
get
|
|
{
|
|
if (shouldBeProcessed)
|
|
{
|
|
ProcessText();
|
|
}
|
|
return base.localCorners;
|
|
}
|
|
}
|
|
|
|
public override Vector3[] worldCorners
|
|
{
|
|
get
|
|
{
|
|
if (shouldBeProcessed)
|
|
{
|
|
ProcessText();
|
|
}
|
|
return base.worldCorners;
|
|
}
|
|
}
|
|
|
|
public override Vector4 drawingDimensions
|
|
{
|
|
get
|
|
{
|
|
if (shouldBeProcessed)
|
|
{
|
|
ProcessText();
|
|
}
|
|
return base.drawingDimensions;
|
|
}
|
|
}
|
|
|
|
public int maxLineCount
|
|
{
|
|
get
|
|
{
|
|
return mMaxLineCount;
|
|
}
|
|
set
|
|
{
|
|
if (mMaxLineCount != value)
|
|
{
|
|
mMaxLineCount = Mathf.Max(value, 0);
|
|
shouldBeProcessed = true;
|
|
if (overflowMethod == Overflow.ShrinkContent)
|
|
{
|
|
MakePixelPerfect();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public Effect effectStyle
|
|
{
|
|
get
|
|
{
|
|
return mEffectStyle;
|
|
}
|
|
set
|
|
{
|
|
if (mEffectStyle != value)
|
|
{
|
|
mEffectStyle = value;
|
|
shouldBeProcessed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public Color effectColor
|
|
{
|
|
get
|
|
{
|
|
return mEffectColor;
|
|
}
|
|
set
|
|
{
|
|
if (mEffectColor != value)
|
|
{
|
|
mEffectColor = value;
|
|
if (mEffectStyle != Effect.None)
|
|
{
|
|
shouldBeProcessed = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public Vector2 effectDistance
|
|
{
|
|
get
|
|
{
|
|
return mEffectDistance;
|
|
}
|
|
set
|
|
{
|
|
if (mEffectDistance != value)
|
|
{
|
|
mEffectDistance = value;
|
|
shouldBeProcessed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
[Obsolete("Use 'overflowMethod == UILabel.Overflow.ShrinkContent' instead")]
|
|
public bool shrinkToFit
|
|
{
|
|
get
|
|
{
|
|
return mOverflow == Overflow.ShrinkContent;
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
{
|
|
overflowMethod = Overflow.ShrinkContent;
|
|
}
|
|
}
|
|
}
|
|
|
|
public string processedText
|
|
{
|
|
get
|
|
{
|
|
if (mLastWidth != mWidth || mLastHeight != mHeight)
|
|
{
|
|
mLastWidth = mWidth;
|
|
mLastHeight = mHeight;
|
|
mShouldBeProcessed = true;
|
|
}
|
|
if (shouldBeProcessed)
|
|
{
|
|
ProcessText();
|
|
}
|
|
return mProcessedText;
|
|
}
|
|
}
|
|
|
|
public Vector2 printedSize
|
|
{
|
|
get
|
|
{
|
|
if (shouldBeProcessed)
|
|
{
|
|
ProcessText();
|
|
}
|
|
return mCalculatedSize;
|
|
}
|
|
}
|
|
|
|
public override Vector2 localSize
|
|
{
|
|
get
|
|
{
|
|
if (shouldBeProcessed)
|
|
{
|
|
ProcessText();
|
|
}
|
|
return base.localSize;
|
|
}
|
|
}
|
|
|
|
private bool isValid
|
|
{
|
|
get
|
|
{
|
|
if (!(mFont != null))
|
|
{
|
|
return mTrueTypeFont != null;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public void SetWrapText(string s)
|
|
{
|
|
_originalText = s;
|
|
text = Global.GetConvertWrapText(this, s);
|
|
}
|
|
|
|
public void WrapOnResize()
|
|
{
|
|
if (_originalText != null)
|
|
{
|
|
text = Global.GetConvertWrapText(this, _originalText);
|
|
}
|
|
if (OnWindowResize != null)
|
|
{
|
|
OnWindowResize();
|
|
}
|
|
}
|
|
|
|
protected override void OnInit()
|
|
{
|
|
base.OnInit();
|
|
mList.Add(this);
|
|
InitializeFont();
|
|
SetActiveFont(trueTypeFont);
|
|
}
|
|
|
|
public void InitializeFont()
|
|
{
|
|
if (Global.GAME_FONT == null)
|
|
{
|
|
Global.GAME_FONT = Resources.Load<UnityEngine.Font>("Fonts/Jpn/A-OTF-KaiminTuStd-Bold");
|
|
}
|
|
if (trueTypeFont != Global.GAME_FONT && bitmapFont == null)
|
|
{
|
|
trueTypeFont = Global.GAME_FONT;
|
|
}
|
|
}
|
|
|
|
protected override void OnDisable()
|
|
{
|
|
SetActiveFont(null);
|
|
mList.Remove(this);
|
|
base.OnDisable();
|
|
}
|
|
|
|
protected void SetActiveFont(UnityEngine.Font fnt)
|
|
{
|
|
if (!(mActiveTTF != fnt))
|
|
{
|
|
return;
|
|
}
|
|
UnityEngine.Font font = mActiveTTF;
|
|
if (font != null && mFontUsage.TryGetValue(font, out var value))
|
|
{
|
|
value = Mathf.Max(0, --value);
|
|
if (value == 0)
|
|
{
|
|
mFontUsage.Remove(font);
|
|
}
|
|
else
|
|
{
|
|
mFontUsage[font] = value;
|
|
}
|
|
}
|
|
mActiveTTF = fnt;
|
|
font = fnt;
|
|
if (font != null)
|
|
{
|
|
int num = 0;
|
|
num = (mFontUsage[font] = num + 1);
|
|
}
|
|
}
|
|
|
|
private static void OnFontChanged(UnityEngine.Font font)
|
|
{
|
|
OnFontChangedFlg = true;
|
|
OnFontChangedFont = font;
|
|
for (int i = 0; i < mList.size; i++)
|
|
{
|
|
UILabel uILabel = mList[i];
|
|
if (uILabel != null)
|
|
{
|
|
UnityEngine.Font font2 = uILabel.trueTypeFont;
|
|
if (font2 == font)
|
|
{
|
|
font2.RequestCharactersInTexture(uILabel.mText, uILabel.mFinalFontSize, uILabel.mFontStyle);
|
|
uILabel.RemoveFromPanel();
|
|
uILabel.CreatePanel();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override Vector3[] GetSides(Transform relativeTo)
|
|
{
|
|
if (shouldBeProcessed)
|
|
{
|
|
ProcessText();
|
|
}
|
|
return base.GetSides(relativeTo);
|
|
}
|
|
|
|
protected override void UpgradeFrom265()
|
|
{
|
|
ProcessText(legacyMode: true, full: true);
|
|
if (mShrinkToFit)
|
|
{
|
|
overflowMethod = Overflow.ShrinkContent;
|
|
mMaxLineCount = 0;
|
|
}
|
|
if (mMaxLineWidth != 0)
|
|
{
|
|
base.width = mMaxLineWidth;
|
|
overflowMethod = ((mMaxLineCount > 0) ? Overflow.ResizeHeight : Overflow.ShrinkContent);
|
|
}
|
|
else
|
|
{
|
|
overflowMethod = Overflow.ResizeFreely;
|
|
}
|
|
if (mMaxLineHeight != 0)
|
|
{
|
|
base.height = mMaxLineHeight;
|
|
}
|
|
if (mFont != null)
|
|
{
|
|
int defaultSize = mFont.defaultSize;
|
|
if (base.height < defaultSize)
|
|
{
|
|
base.height = defaultSize;
|
|
}
|
|
fontSize = defaultSize;
|
|
}
|
|
mMaxLineWidth = 0;
|
|
mMaxLineHeight = 0;
|
|
mShrinkToFit = false;
|
|
NGUITools.UpdateWidgetCollider(base.gameObject, considerInactive: true);
|
|
}
|
|
|
|
protected override void OnAnchor()
|
|
{
|
|
if (mOverflow == Overflow.ResizeFreely)
|
|
{
|
|
if (base.isFullyAnchored)
|
|
{
|
|
mOverflow = Overflow.ShrinkContent;
|
|
}
|
|
}
|
|
else if (mOverflow == Overflow.ResizeHeight && topAnchor.target != null && bottomAnchor.target != null)
|
|
{
|
|
mOverflow = Overflow.ShrinkContent;
|
|
}
|
|
base.OnAnchor();
|
|
}
|
|
|
|
private void ProcessAndRequest()
|
|
{
|
|
if (ambigiousFont != null)
|
|
{
|
|
ProcessText();
|
|
}
|
|
}
|
|
|
|
protected override void OnEnable()
|
|
{
|
|
base.OnEnable();
|
|
if (!mTexRebuildAdded)
|
|
{
|
|
mTexRebuildAdded = true;
|
|
UnityEngine.Font.textureRebuilt += OnFontChanged;
|
|
}
|
|
}
|
|
|
|
public void RefreshCustom()
|
|
{
|
|
SetActiveFont(null);
|
|
mList.Remove(this);
|
|
RemoveFromPanel();
|
|
if (base.isActiveAndEnabled)
|
|
{
|
|
base.OnEnable();
|
|
}
|
|
}
|
|
|
|
protected override void OnStart()
|
|
{
|
|
base.OnStart();
|
|
if (mLineWidth > 0f)
|
|
{
|
|
mMaxLineWidth = Mathf.RoundToInt(mLineWidth);
|
|
mLineWidth = 0f;
|
|
}
|
|
if (!mMultiline)
|
|
{
|
|
mMaxLineCount = 1;
|
|
mMultiline = true;
|
|
}
|
|
mPremultiply = material != null && material.shader != null && material.shader.name.Contains("Premultiplied");
|
|
ProcessAndRequest();
|
|
}
|
|
|
|
public override void MarkAsChanged()
|
|
{
|
|
shouldBeProcessed = true;
|
|
base.MarkAsChanged();
|
|
}
|
|
|
|
public void ProcessText()
|
|
{
|
|
ProcessText(legacyMode: false, full: true);
|
|
}
|
|
|
|
private void ProcessText(bool legacyMode, bool full)
|
|
{
|
|
if (!isValid)
|
|
{
|
|
return;
|
|
}
|
|
mChanged = true;
|
|
shouldBeProcessed = false;
|
|
float num = mDrawRegion.z - mDrawRegion.x;
|
|
float num2 = mDrawRegion.w - mDrawRegion.y;
|
|
NGUIText.rectWidth = ((!legacyMode) ? base.width : ((mMaxLineWidth != 0) ? mMaxLineWidth : 1000000));
|
|
NGUIText.rectHeight = ((!legacyMode) ? base.height : ((mMaxLineHeight != 0) ? mMaxLineHeight : 1000000));
|
|
NGUIText.regionWidth = ((num != 1f) ? Mathf.RoundToInt((float)NGUIText.rectWidth * num) : NGUIText.rectWidth);
|
|
NGUIText.regionHeight = ((num2 != 1f) ? Mathf.RoundToInt((float)NGUIText.rectHeight * num2) : NGUIText.rectHeight);
|
|
mFinalFontSize = Mathf.Abs(legacyMode ? Mathf.RoundToInt(base.cachedTransform.localScale.x) : defaultFontSize);
|
|
mScale = 1f;
|
|
if (NGUIText.regionWidth < 1 || NGUIText.regionHeight < 0)
|
|
{
|
|
mProcessedText = "";
|
|
return;
|
|
}
|
|
bool flag = trueTypeFont != null;
|
|
if (flag && keepCrisp)
|
|
{
|
|
UIRoot uIRoot = base.root;
|
|
if (uIRoot != null)
|
|
{
|
|
mDensity = ((uIRoot != null) ? uIRoot.pixelSizeAdjustment : 1f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mDensity = 1f;
|
|
}
|
|
if (full)
|
|
{
|
|
UpdateNGUIText();
|
|
}
|
|
if (mOverflow == Overflow.ResizeFreely)
|
|
{
|
|
NGUIText.rectWidth = 1000000;
|
|
NGUIText.regionWidth = 1000000;
|
|
}
|
|
if (mOverflow == Overflow.ResizeFreely || mOverflow == Overflow.ResizeHeight)
|
|
{
|
|
NGUIText.rectHeight = 1000000;
|
|
NGUIText.regionHeight = 1000000;
|
|
}
|
|
if (mFinalFontSize > 0)
|
|
{
|
|
bool flag2 = keepCrisp;
|
|
int num3 = mFinalFontSize;
|
|
while (num3 > 0)
|
|
{
|
|
if (flag2)
|
|
{
|
|
mFinalFontSize = num3;
|
|
NGUIText.fontSize = mFinalFontSize;
|
|
}
|
|
else
|
|
{
|
|
mScale = (float)num3 / (float)mFinalFontSize;
|
|
NGUIText.fontScale = (flag ? mScale : ((float)mFontSize / (float)mFont.defaultSize * mScale));
|
|
}
|
|
NGUIText.Update(request: false, base.rawPivot);
|
|
bool flag3 = NGUIText.WrapText(mText, out mProcessedText, keepCharCount: true, wrapLineColors: false, mOverflowEllipsis && mOverflow == Overflow.ClampContent);
|
|
if (mOverflow == Overflow.ShrinkContent && !flag3)
|
|
{
|
|
if (--num3 <= 1)
|
|
{
|
|
break;
|
|
}
|
|
num3--;
|
|
continue;
|
|
}
|
|
if (mOverflow == Overflow.ResizeFreely)
|
|
{
|
|
mCalculatedSize = NGUIText.CalculatePrintedSize(mProcessedText);
|
|
mWidth = Mathf.Max(minWidth, Mathf.RoundToInt(mCalculatedSize.x));
|
|
if (num != 1f)
|
|
{
|
|
mWidth = Mathf.RoundToInt((float)mWidth / num);
|
|
}
|
|
mHeight = Mathf.Max(minHeight, Mathf.RoundToInt(mCalculatedSize.y));
|
|
if (num2 != 1f)
|
|
{
|
|
mHeight = Mathf.RoundToInt((float)mHeight / num2);
|
|
}
|
|
if ((mWidth & 1) == 1)
|
|
{
|
|
mWidth++;
|
|
}
|
|
if ((mHeight & 1) == 1)
|
|
{
|
|
mHeight++;
|
|
}
|
|
}
|
|
else if (mOverflow == Overflow.ResizeHeight)
|
|
{
|
|
mCalculatedSize = NGUIText.CalculatePrintedSize(mProcessedText);
|
|
mHeight = Mathf.Max(minHeight, Mathf.RoundToInt(mCalculatedSize.y));
|
|
if (num2 != 1f)
|
|
{
|
|
mHeight = Mathf.RoundToInt((float)mHeight / num2);
|
|
}
|
|
if ((mHeight & 1) == 1)
|
|
{
|
|
mHeight++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mCalculatedSize = NGUIText.CalculatePrintedSize(mProcessedText);
|
|
}
|
|
if (legacyMode)
|
|
{
|
|
base.width = Mathf.RoundToInt(mCalculatedSize.x);
|
|
base.height = Mathf.RoundToInt(mCalculatedSize.y);
|
|
base.cachedTransform.localScale = Vector3.one;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
base.cachedTransform.localScale = Vector3.one;
|
|
mProcessedText = "";
|
|
mScale = 1f;
|
|
}
|
|
if (full)
|
|
{
|
|
NGUIText.bitmapFont = null;
|
|
NGUIText.dynamicFont = null;
|
|
}
|
|
if (OnFontChangedFlg)
|
|
{
|
|
FontReflash(OnFontChangedFont);
|
|
}
|
|
}
|
|
|
|
private IEnumerator FontRefreshCoroutine()
|
|
{
|
|
yield return null;
|
|
Invalidate(includeChildren: false);
|
|
}
|
|
|
|
private static void FontReflash(UnityEngine.Font font)
|
|
{
|
|
OnFontChangedFlg = false;
|
|
List<UIPanel> list = null;
|
|
for (int i = 0; i < mList.size; i++)
|
|
{
|
|
UILabel uILabel = mList[i];
|
|
if (uILabel != null && uILabel.trueTypeFont == font)
|
|
{
|
|
if (list == null)
|
|
{
|
|
list = new List<UIPanel>();
|
|
}
|
|
if (!list.Contains(uILabel.panel))
|
|
{
|
|
list.Add(uILabel.panel);
|
|
}
|
|
}
|
|
}
|
|
if (list != null)
|
|
{
|
|
int j = 0;
|
|
for (int count = list.Count; j < count; j++)
|
|
{
|
|
UIPanel uIPanel = list[j];
|
|
if (uIPanel != null)
|
|
{
|
|
uIPanel.Refresh();
|
|
}
|
|
}
|
|
list.Clear();
|
|
}
|
|
OnFontChangedFlg = false;
|
|
}
|
|
|
|
public override void MakePixelPerfect()
|
|
{
|
|
if (ambigiousFont != null)
|
|
{
|
|
Vector3 localPosition = base.cachedTransform.localPosition;
|
|
localPosition.x = Mathf.RoundToInt(localPosition.x);
|
|
localPosition.y = Mathf.RoundToInt(localPosition.y);
|
|
localPosition.z = Mathf.RoundToInt(localPosition.z);
|
|
base.cachedTransform.localPosition = localPosition;
|
|
base.cachedTransform.localScale = Vector3.one;
|
|
if (mOverflow == Overflow.ResizeFreely)
|
|
{
|
|
AssumeNaturalSize();
|
|
return;
|
|
}
|
|
int a = base.width;
|
|
int a2 = base.height;
|
|
Overflow overflow = mOverflow;
|
|
if (overflow != Overflow.ResizeHeight)
|
|
{
|
|
mWidth = 100000;
|
|
}
|
|
mHeight = 100000;
|
|
mOverflow = Overflow.ShrinkContent;
|
|
ProcessText(legacyMode: false, full: true);
|
|
mOverflow = overflow;
|
|
int a3 = Mathf.RoundToInt(mCalculatedSize.x);
|
|
int a4 = Mathf.RoundToInt(mCalculatedSize.y);
|
|
a3 = Mathf.Max(a3, base.minWidth);
|
|
a4 = Mathf.Max(a4, base.minHeight);
|
|
if ((a3 & 1) == 1)
|
|
{
|
|
a3++;
|
|
}
|
|
if ((a4 & 1) == 1)
|
|
{
|
|
a4++;
|
|
}
|
|
mWidth = Mathf.Max(a, a3);
|
|
mHeight = Mathf.Max(a2, a4);
|
|
MarkAsChanged();
|
|
}
|
|
else
|
|
{
|
|
base.MakePixelPerfect();
|
|
}
|
|
}
|
|
|
|
public void AssumeNaturalSize()
|
|
{
|
|
if (ambigiousFont != null)
|
|
{
|
|
mWidth = 100000;
|
|
mHeight = 100000;
|
|
ProcessText(legacyMode: false, full: true);
|
|
mWidth = Mathf.RoundToInt(mCalculatedSize.x);
|
|
mHeight = Mathf.RoundToInt(mCalculatedSize.y);
|
|
if ((mWidth & 1) == 1)
|
|
{
|
|
mWidth++;
|
|
}
|
|
if ((mHeight & 1) == 1)
|
|
{
|
|
mHeight++;
|
|
}
|
|
MarkAsChanged();
|
|
}
|
|
}
|
|
|
|
[Obsolete("Use UILabel.GetCharacterAtPosition instead")]
|
|
public int GetCharacterIndex(Vector3 worldPos)
|
|
{
|
|
return GetCharacterIndexAtPosition(worldPos, precise: false);
|
|
}
|
|
|
|
[Obsolete("Use UILabel.GetCharacterAtPosition instead")]
|
|
public int GetCharacterIndex(Vector2 localPos)
|
|
{
|
|
return GetCharacterIndexAtPosition(localPos, precise: false);
|
|
}
|
|
|
|
public int GetCharacterIndexAtPositionRangeSpecification(Vector3 worldPos, List<int[]> rangeList)
|
|
{
|
|
if (isValid)
|
|
{
|
|
Vector2 pos = base.cachedTransform.InverseTransformPoint(worldPos);
|
|
string value = processedText;
|
|
if (string.IsNullOrEmpty(value))
|
|
{
|
|
return 0;
|
|
}
|
|
UpdateNGUIText();
|
|
NGUIText.PrintApproximateCharacterPositions(value, mTempVerts, mTempIndices);
|
|
if (mTempVerts.size > 0)
|
|
{
|
|
ApplyOffset(mTempVerts, 0);
|
|
int nearCharacterIndex = NGUIText.GetNearCharacterIndex(mTempVerts, mTempIndices, pos, rangeList);
|
|
mTempVerts.Clear();
|
|
mTempIndices.Clear();
|
|
NGUIText.bitmapFont = null;
|
|
NGUIText.dynamicFont = null;
|
|
return nearCharacterIndex;
|
|
}
|
|
NGUIText.bitmapFont = null;
|
|
NGUIText.dynamicFont = null;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public int GetCharacterIndexAtPosition(Vector3 worldPos, bool precise)
|
|
{
|
|
Vector2 localPos = base.cachedTransform.InverseTransformPoint(worldPos);
|
|
return GetCharacterIndexAtPosition(localPos, precise);
|
|
}
|
|
|
|
public int GetCharacterIndexAtPosition(Vector2 localPos, bool precise)
|
|
{
|
|
if (isValid)
|
|
{
|
|
string value = processedText;
|
|
if (string.IsNullOrEmpty(value))
|
|
{
|
|
return 0;
|
|
}
|
|
UpdateNGUIText();
|
|
if (precise)
|
|
{
|
|
NGUIText.PrintExactCharacterPositions(value, mTempVerts, mTempIndices);
|
|
}
|
|
else
|
|
{
|
|
NGUIText.PrintApproximateCharacterPositions(value, mTempVerts, mTempIndices);
|
|
}
|
|
if (mTempVerts.size > 0)
|
|
{
|
|
ApplyOffset(mTempVerts, 0);
|
|
int result = (precise ? NGUIText.GetExactCharacterIndex(mTempVerts, mTempIndices, localPos) : NGUIText.GetApproximateCharacterIndex(mTempVerts, mTempIndices, localPos));
|
|
mTempVerts.Clear();
|
|
mTempIndices.Clear();
|
|
NGUIText.bitmapFont = null;
|
|
NGUIText.dynamicFont = null;
|
|
return result;
|
|
}
|
|
NGUIText.bitmapFont = null;
|
|
NGUIText.dynamicFont = null;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public string GetWordAtPosition(Vector3 worldPos)
|
|
{
|
|
int characterIndexAtPosition = GetCharacterIndexAtPosition(worldPos, precise: true);
|
|
return GetWordAtCharacterIndex(characterIndexAtPosition);
|
|
}
|
|
|
|
public string GetWordAtPosition(Vector2 localPos)
|
|
{
|
|
int characterIndexAtPosition = GetCharacterIndexAtPosition(localPos, precise: true);
|
|
return GetWordAtCharacterIndex(characterIndexAtPosition);
|
|
}
|
|
|
|
public string GetWordAtCharacterIndex(int characterIndex)
|
|
{
|
|
if (characterIndex != -1 && characterIndex < mText.Length)
|
|
{
|
|
int num = mText.LastIndexOfAny(new char[2] { ' ', '\n' }, characterIndex) + 1;
|
|
int num2 = mText.IndexOfAny(new char[4] { ' ', '\n', ',', '.' }, characterIndex);
|
|
if (num2 == -1)
|
|
{
|
|
num2 = mText.Length;
|
|
}
|
|
if (num != num2)
|
|
{
|
|
int num3 = num2 - num;
|
|
if (num3 > 0)
|
|
{
|
|
return NGUIText.StripSymbols(mText.Substring(num, num3));
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public string GetUrlAtPosition(Vector3 worldPos)
|
|
{
|
|
return GetUrlAtCharacterIndex(GetCharacterIndexAtPosition(worldPos, precise: true));
|
|
}
|
|
|
|
public string GetUrlAtPosition(Vector2 localPos)
|
|
{
|
|
return GetUrlAtCharacterIndex(GetCharacterIndexAtPosition(localPos, precise: true));
|
|
}
|
|
|
|
public string GetUrlAtCharacterIndex(int characterIndex)
|
|
{
|
|
if (characterIndex != -1 && characterIndex < mText.Length - 6)
|
|
{
|
|
int num = ((mText[characterIndex] != '[' || mText[characterIndex + 1] != 'u' || mText[characterIndex + 2] != 'r' || mText[characterIndex + 3] != 'l' || mText[characterIndex + 4] != '=') ? mText.LastIndexOf("[url=", characterIndex) : characterIndex);
|
|
if (num == -1)
|
|
{
|
|
return null;
|
|
}
|
|
num += 5;
|
|
int num2 = mText.IndexOf("]", num);
|
|
if (num2 == -1)
|
|
{
|
|
return null;
|
|
}
|
|
int num3 = mText.IndexOf("[/url]", num2);
|
|
if (num3 == -1 || characterIndex <= num3)
|
|
{
|
|
return mText.Substring(num, num2 - num);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public int GetCharacterIndex(int currentIndex, KeyCode key)
|
|
{
|
|
if (isValid)
|
|
{
|
|
string text = processedText;
|
|
if (string.IsNullOrEmpty(text))
|
|
{
|
|
return 0;
|
|
}
|
|
int num = defaultFontSize;
|
|
UpdateNGUIText();
|
|
NGUIText.PrintApproximateCharacterPositions(text, mTempVerts, mTempIndices);
|
|
if (mTempVerts.size > 0)
|
|
{
|
|
ApplyOffset(mTempVerts, 0);
|
|
for (int i = 0; i < mTempIndices.size; i++)
|
|
{
|
|
if (mTempIndices[i] == currentIndex)
|
|
{
|
|
Vector2 pos = mTempVerts[i];
|
|
switch (key)
|
|
{
|
|
case KeyCode.UpArrow:
|
|
pos.y += (float)num + effectiveSpacingY;
|
|
break;
|
|
case KeyCode.DownArrow:
|
|
pos.y -= (float)num + effectiveSpacingY;
|
|
break;
|
|
case KeyCode.Home:
|
|
pos.x -= 1000f;
|
|
break;
|
|
case KeyCode.End:
|
|
pos.x += 1000f;
|
|
break;
|
|
}
|
|
int approximateCharacterIndex = NGUIText.GetApproximateCharacterIndex(mTempVerts, mTempIndices, pos);
|
|
if (approximateCharacterIndex == currentIndex)
|
|
{
|
|
break;
|
|
}
|
|
mTempVerts.Clear();
|
|
mTempIndices.Clear();
|
|
return approximateCharacterIndex;
|
|
}
|
|
}
|
|
mTempVerts.Clear();
|
|
mTempIndices.Clear();
|
|
}
|
|
NGUIText.bitmapFont = null;
|
|
NGUIText.dynamicFont = null;
|
|
switch (key)
|
|
{
|
|
case KeyCode.UpArrow:
|
|
case KeyCode.Home:
|
|
return 0;
|
|
case KeyCode.DownArrow:
|
|
case KeyCode.End:
|
|
return text.Length;
|
|
}
|
|
}
|
|
return currentIndex;
|
|
}
|
|
|
|
public void PrintOverlay(int start, int end, UIGeometry caret, UIGeometry highlight, Color caretColor, Color highlightColor)
|
|
{
|
|
caret?.Clear();
|
|
highlight?.Clear();
|
|
if (!isValid)
|
|
{
|
|
return;
|
|
}
|
|
string text = processedText;
|
|
UpdateNGUIText();
|
|
int size = caret.verts.size;
|
|
Vector2 item = new Vector2(0.5f, 0.5f);
|
|
float num = finalAlpha;
|
|
if (highlight != null && start != end)
|
|
{
|
|
int size2 = highlight.verts.size;
|
|
NGUIText.PrintCaretAndSelection(text, start, end, caret.verts, highlight.verts);
|
|
if (highlight.verts.size > size2)
|
|
{
|
|
ApplyOffset(highlight.verts, size2);
|
|
Color32 item2 = new Color(highlightColor.r, highlightColor.g, highlightColor.b, highlightColor.a * num);
|
|
for (int i = size2; i < highlight.verts.size; i++)
|
|
{
|
|
highlight.uvs.Add(item);
|
|
highlight.cols.Add(item2);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NGUIText.PrintCaretAndSelection(text, start, end, caret.verts, null);
|
|
}
|
|
ApplyOffset(caret.verts, size);
|
|
Color32 item3 = new Color(caretColor.r, caretColor.g, caretColor.b, caretColor.a * num);
|
|
for (int j = size; j < caret.verts.size; j++)
|
|
{
|
|
caret.uvs.Add(item);
|
|
caret.cols.Add(item3);
|
|
}
|
|
NGUIText.bitmapFont = null;
|
|
NGUIText.dynamicFont = null;
|
|
}
|
|
|
|
public override void OnFill(BetterList<Vector3> verts, BetterList<Vector2> uvs, BetterList<Color32> cols)
|
|
{
|
|
if (!isValid)
|
|
{
|
|
return;
|
|
}
|
|
int num = verts.size;
|
|
Color color = base.color;
|
|
color.a = finalAlpha;
|
|
if (mFont != null && mFont.premultipliedAlphaShader)
|
|
{
|
|
color = NGUITools.ApplyPMA(color);
|
|
}
|
|
if (QualitySettings.activeColorSpace == ColorSpace.Linear)
|
|
{
|
|
color.r = Mathf.GammaToLinearSpace(color.r);
|
|
color.g = Mathf.GammaToLinearSpace(color.g);
|
|
color.b = Mathf.GammaToLinearSpace(color.b);
|
|
color.a = Mathf.GammaToLinearSpace(color.a);
|
|
}
|
|
string obj = processedText;
|
|
int size = verts.size;
|
|
UpdateNGUIText();
|
|
NGUIText.tint = color;
|
|
RubyText.PrintWithRuby(obj, verts, uvs, cols, this);
|
|
NGUIText.bitmapFont = null;
|
|
NGUIText.dynamicFont = null;
|
|
Vector2 vector = ApplyOffset(verts, size);
|
|
if (mFont != null && mFont.packedFontShader)
|
|
{
|
|
return;
|
|
}
|
|
if (effectStyle != Effect.None)
|
|
{
|
|
int size2 = verts.size;
|
|
vector.x = mEffectDistance.x;
|
|
vector.y = mEffectDistance.y;
|
|
ApplyShadow(verts, uvs, cols, num, size2, vector.x, 0f - vector.y);
|
|
if (effectStyle == Effect.Outline || effectStyle == Effect.Outline8)
|
|
{
|
|
num = size2;
|
|
size2 = verts.size;
|
|
ApplyShadow(verts, uvs, cols, num, size2, 0f - vector.x, vector.y);
|
|
num = size2;
|
|
size2 = verts.size;
|
|
ApplyShadow(verts, uvs, cols, num, size2, vector.x, vector.y);
|
|
num = size2;
|
|
size2 = verts.size;
|
|
ApplyShadow(verts, uvs, cols, num, size2, 0f - vector.x, 0f - vector.y);
|
|
if (effectStyle == Effect.Outline8)
|
|
{
|
|
num = size2;
|
|
size2 = verts.size;
|
|
ApplyShadow(verts, uvs, cols, num, size2, 0f - vector.x, 0f);
|
|
num = size2;
|
|
size2 = verts.size;
|
|
ApplyShadow(verts, uvs, cols, num, size2, vector.x, 0f);
|
|
num = size2;
|
|
size2 = verts.size;
|
|
ApplyShadow(verts, uvs, cols, num, size2, 0f, vector.y);
|
|
num = size2;
|
|
size2 = verts.size;
|
|
ApplyShadow(verts, uvs, cols, num, size2, 0f, 0f - vector.y);
|
|
}
|
|
}
|
|
}
|
|
if (onPostFill != null)
|
|
{
|
|
onPostFill(this, num, verts, uvs, cols);
|
|
}
|
|
}
|
|
|
|
public Vector2 ApplyOffset(BetterList<Vector3> verts, int start)
|
|
{
|
|
Vector2 vector = base.pivotOffset;
|
|
float f = Mathf.Lerp(0f, -mWidth, vector.x);
|
|
float f2 = Mathf.Lerp(mHeight, 0f, vector.y) + Mathf.Lerp(mCalculatedSize.y - (float)mHeight, 0f, vector.y);
|
|
f = Mathf.Round(f);
|
|
f2 = Mathf.Round(f2);
|
|
for (int i = start; i < verts.size; i++)
|
|
{
|
|
verts.buffer[i].x += f;
|
|
verts.buffer[i].y += f2;
|
|
}
|
|
return new Vector2(f, f2);
|
|
}
|
|
|
|
public void ApplyShadow(BetterList<Vector3> verts, BetterList<Vector2> uvs, BetterList<Color32> cols, int start, int end, float x, float y)
|
|
{
|
|
Color color = mEffectColor;
|
|
color.a *= finalAlpha;
|
|
Color32 color2 = ((bitmapFont != null && bitmapFont.premultipliedAlphaShader) ? NGUITools.ApplyPMA(color) : color);
|
|
for (int i = start; i < end; i++)
|
|
{
|
|
verts.Add(verts.buffer[i]);
|
|
uvs.Add(uvs.buffer[i]);
|
|
cols.Add(cols.buffer[i]);
|
|
Vector3 vector = verts.buffer[i];
|
|
vector.x += x;
|
|
vector.y += y;
|
|
verts.buffer[i] = vector;
|
|
Color32 color3 = cols.buffer[i];
|
|
if (color3.a == byte.MaxValue)
|
|
{
|
|
cols.buffer[i] = color2;
|
|
continue;
|
|
}
|
|
Color color4 = color;
|
|
color4.a = (float)(int)color3.a / 255f * color.a;
|
|
cols.buffer[i] = ((bitmapFont != null && bitmapFont.premultipliedAlphaShader) ? NGUITools.ApplyPMA(color4) : color4);
|
|
}
|
|
}
|
|
|
|
public int CalculateOffsetToFit(string text)
|
|
{
|
|
UpdateNGUIText();
|
|
NGUIText.encoding = false;
|
|
NGUIText.symbolStyle = NGUIText.SymbolStyle.None;
|
|
int result = NGUIText.CalculateOffsetToFit(text);
|
|
NGUIText.bitmapFont = null;
|
|
NGUIText.dynamicFont = null;
|
|
return result;
|
|
}
|
|
|
|
public void SetCurrentProgress()
|
|
{
|
|
if (UIProgressBar.current != null)
|
|
{
|
|
text = UIProgressBar.current.value.ToString("F");
|
|
}
|
|
}
|
|
|
|
public void SetCurrentPercent()
|
|
{
|
|
if (UIProgressBar.current != null)
|
|
{
|
|
text = Mathf.RoundToInt(UIProgressBar.current.value * 100f) + "%";
|
|
}
|
|
}
|
|
|
|
public void SetCurrentSelection()
|
|
{
|
|
if (UIPopupList.current != null)
|
|
{
|
|
text = (UIPopupList.current.isLocalized ? Localization.Get(UIPopupList.current.value) : UIPopupList.current.value);
|
|
}
|
|
}
|
|
|
|
public bool Wrap(string text, out string final)
|
|
{
|
|
return Wrap(text, out final, 1000000);
|
|
}
|
|
|
|
public bool Wrap(string text, out string final, int height)
|
|
{
|
|
UpdateNGUIText();
|
|
NGUIText.rectHeight = height;
|
|
NGUIText.regionHeight = height;
|
|
bool result = NGUIText.WrapText(text, out final);
|
|
NGUIText.bitmapFont = null;
|
|
NGUIText.dynamicFont = null;
|
|
return result;
|
|
}
|
|
|
|
public void UpdateNGUIText()
|
|
{
|
|
UnityEngine.Font font = trueTypeFont;
|
|
bool flag = font != null;
|
|
NGUIText.fontSize = mFinalFontSize;
|
|
NGUIText.fontStyle = mFontStyle;
|
|
NGUIText.rectWidth = mWidth;
|
|
NGUIText.rectHeight = mHeight;
|
|
NGUIText.regionWidth = Mathf.RoundToInt((float)mWidth * (mDrawRegion.z - mDrawRegion.x));
|
|
NGUIText.regionHeight = Mathf.RoundToInt((float)mHeight * (mDrawRegion.w - mDrawRegion.y));
|
|
NGUIText.gradient = mApplyGradient && (mFont == null || !mFont.packedFontShader);
|
|
NGUIText.gradientTop = mGradientTop;
|
|
NGUIText.gradientBottom = mGradientBottom;
|
|
NGUIText.encoding = mEncoding;
|
|
NGUIText.premultiply = mPremultiply;
|
|
NGUIText.symbolStyle = mSymbols;
|
|
NGUIText.maxLines = mMaxLineCount;
|
|
NGUIText.spacingX = effectiveSpacingX;
|
|
NGUIText.spacingY = effectiveSpacingY;
|
|
NGUIText.fontScale = (flag ? mScale : ((float)mFontSize / (float)mFont.defaultSize * mScale));
|
|
if (mFont != null)
|
|
{
|
|
NGUIText.bitmapFont = mFont;
|
|
while (true)
|
|
{
|
|
UIFont replacement = NGUIText.bitmapFont.replacement;
|
|
if (replacement == null)
|
|
{
|
|
break;
|
|
}
|
|
NGUIText.bitmapFont = replacement;
|
|
}
|
|
if (NGUIText.bitmapFont.isDynamic)
|
|
{
|
|
NGUIText.dynamicFont = NGUIText.bitmapFont.dynamicFont;
|
|
NGUIText.bitmapFont = null;
|
|
}
|
|
else
|
|
{
|
|
NGUIText.dynamicFont = null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NGUIText.dynamicFont = font;
|
|
NGUIText.bitmapFont = null;
|
|
}
|
|
if (flag && keepCrisp)
|
|
{
|
|
UIRoot uIRoot = base.root;
|
|
if (uIRoot != null)
|
|
{
|
|
NGUIText.pixelDensity = ((uIRoot != null) ? uIRoot.pixelSizeAdjustment : 1f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NGUIText.pixelDensity = 1f;
|
|
}
|
|
if (mDensity != NGUIText.pixelDensity)
|
|
{
|
|
ProcessText(legacyMode: false, full: false);
|
|
NGUIText.rectWidth = mWidth;
|
|
NGUIText.rectHeight = mHeight;
|
|
NGUIText.regionWidth = Mathf.RoundToInt((float)mWidth * (mDrawRegion.z - mDrawRegion.x));
|
|
NGUIText.regionHeight = Mathf.RoundToInt((float)mHeight * (mDrawRegion.w - mDrawRegion.y));
|
|
}
|
|
if (alignment == NGUIText.Alignment.Automatic)
|
|
{
|
|
switch (base.pivot)
|
|
{
|
|
case Pivot.TopLeft:
|
|
case Pivot.Left:
|
|
case Pivot.BottomLeft:
|
|
NGUIText.alignment = NGUIText.Alignment.Left;
|
|
break;
|
|
case Pivot.TopRight:
|
|
case Pivot.Right:
|
|
case Pivot.BottomRight:
|
|
NGUIText.alignment = NGUIText.Alignment.Right;
|
|
break;
|
|
default:
|
|
NGUIText.alignment = NGUIText.Alignment.Center;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NGUIText.alignment = alignment;
|
|
}
|
|
NGUIText.Update(base.rawPivot);
|
|
}
|
|
|
|
private void OnApplicationPause(bool paused)
|
|
{
|
|
if (!paused && mTrueTypeFont != null)
|
|
{
|
|
Invalidate(includeChildren: false);
|
|
}
|
|
}
|
|
}
|