public bool CanRendering(int atlasId)
{
#if UNITY_EDITOR && !EMOJI_RUNTIME
if (_unityallAtlases != null)
{
for (int i = 0; i < _unityallAtlases.Count; ++i)
{
SpriteAsset asset = _unityallAtlases[i];
if (asset.ID == atlasId)
{
return(true);
}
}
}
return(false);
#else
for (int i = 0; i < _sharedAtlases.Count; ++i)
{
SpriteAsset asset = _sharedAtlases[i];
if (asset.ID == atlasId)
{
return(true);
}
}
return(false);
#endif
}
SpriteGraphic FindGraphic(InlineText text, int atlasID, out SpriteAsset matchAsset)
{
matchAsset = null;
for (int i = 0; i < allatlas.Count; ++i)
{
SpriteAsset asset = allatlas[i];
if (asset != null && asset.ID == atlasID)
{
matchAsset = asset;
break;
}
}
if (matchAsset && matchAsset.texSource != null)
{
List <SpriteGraphic> list = null;
SpriteGraphic target = FindGraphic(text, matchAsset, out list);
if (!target)
{
target = CreateSpriteRender(text.transform);
list.Add(target);
}
return(target);
}
return(null);
}
SpriteGraphic FindGraphic(InlineText text, SpriteAsset matchAsset, out List <SpriteGraphic> list)
{
EmojiTools.BeginSample("Emoji_UnitFindGraphic");
if (textGraphics == null)
{
textGraphics = new Dictionary <InlineText, List <SpriteGraphic> >();
}
if (!textGraphics.TryGetValue(text, out list))
{
list = ListPool <SpriteGraphic> .Get();
textGraphics[text] = list;
}
SpriteGraphic target = null;
for (int i = 0; i < list.Count; ++i)
{
SpriteGraphic graphic = list[i];
if (graphic && UnityEngine.Object.ReferenceEquals(graphic.mainTexture, matchAsset.texSource))
{
target = graphic;
break;
}
}
EmojiTools.EndSample();
return(target);
}
public bool isRendingAtlas(SpriteAsset asset)
{
if (allatlas != null)
{
return(allatlas.Contains(asset));
}
return(false);
}
void RefreshSubUIMesh(InlineText text, SpriteGraphic target, SpriteAsset matchAsset, Vector3[] Pos, Vector2[] UV)
{
// set mesh
tempMesh.SetAtlas(matchAsset);
tempMesh.SetUVLen(UV.Length);
tempMesh.SetVertLen(Pos.Length);
for (int i = 0; i < Pos.Length; ++i)
{
//text object pos
Vector3 value = Pos[i];
Vector3 worldpos = text.transform.TransformPoint(value);
Vector3 localpos = target.transform.InverseTransformPoint(worldpos);
tempMesh.SetVert(i, localpos);
}
for (int i = 0; i < UV.Length; ++i)
{
Vector2 value = UV[i];
tempMesh.SetUV(i, value);
}
//rendermesh
UnitMeshInfo currentMesh = null;
if (!this.renderData.TryGetValue(target, out currentMesh))
{
currentMesh = new UnitMeshInfo();
renderData[target] = currentMesh;
}
if (!currentMesh.Equals(tempMesh))
{
if (target.isDirty)
{
currentMesh.AddCopy(tempMesh);
tempMesh.Clear();
}
else
{
currentMesh.Copy(tempMesh);
}
}
if (currentMesh.VertCnt() > 3 && currentMesh.UVCnt() > 3)
{
target.Draw(this);
target.SetDirtyMask();
target.SetVerticesDirty();
}
else
{
target.Draw(null);
target.SetDirtyMask();
target.SetVerticesDirty();
}
}
void PreLoad()
{
for (int i = 0; i < PreparedAtlas.Count; ++i)
{
string atlasname = PreparedAtlas[i];
string fixname = System.IO.Path.GetFileNameWithoutExtension(atlasname);
SpriteAsset _spriteAsset = FindAtlas(fixname);
PushRenderAtlas(_spriteAsset);
}
}
void OnEnable()
{
spriteAsset = (SpriteAsset)target;
playSpeed = 6;
Reset();
EditorApplication.update += UpdateFrame;
}
public void Copy(UnitMeshInfo mesh)
{
atlas = mesh.atlas;
if (_Vertices.Count < mesh._Vertices.Count)
{
for (int i = 0; i < _Vertices.Count; ++i)
{
_Vertices[i] = mesh._Vertices[i];
}
for (int i = _Vertices.Count; i < mesh._Vertices.Count; ++i)
{
_Vertices.Add(mesh._Vertices[i]);
}
}
else
{
for (int i = 0; i < mesh._Vertices.Count; ++i)
{
_Vertices[i] = mesh._Vertices[i];
}
for (int i = _Vertices.Count - 1; i >= mesh._Vertices.Count; --i)
{
_Vertices.RemoveAt(i);
}
}
if (_UV.Count < mesh._UV.Count)
{
for (int i = 0; i < _UV.Count; ++i)
{
_UV[i] = mesh._UV[i];
}
for (int i = _UV.Count; i < mesh._UV.Count; ++i)
{
_UV.Add(mesh._UV[i]);
}
}
else
{
for (int i = 0; i < mesh._UV.Count; ++i)
{
_UV[i] = mesh._UV[i];
}
for (int i = _UV.Count - 1; i >= mesh._UV.Count; --i)
{
_UV.RemoveAt(i);
}
}
}
void MarkDirtyStaticEmoji()
{
if (alltexts != null && alltexts.Count > 0)
{
if (listeners == null)
{
listeners = new Dictionary <InlineText, ListenerData>();
}
for (int i = 0; i < alltexts.Count; ++i)
{
InlineText text = alltexts[i];
List <IFillData> emojidata = text.PopEmojiData();
if (text != null && emojidata != null && emojidata.Count > 0 && allatlas != null && allatlas.Count > 0)
{
bool isdirty = false;
ListenerData data = null;
if (listeners.TryGetValue(text, out data))
{
isdirty = data.Dirty(text);
if (isdirty)
{
data.Set(text);
}
}
else
{
data = new ListenerData();
data.Set(text);
listeners.Add(text, data);
}
int staticcnt = 0;
for (int j = 0; j < emojidata.Count; ++j)
{
IFillData taginfo = emojidata[j];
SpriteAsset asset = null;
SpriteInfoGroup groupinfo = manager.FindSpriteGroup(taginfo.Tag, out asset);
if (groupinfo != null && groupinfo.spritegroups.Count == 1)
{
staticcnt++;
}
}
if (staticcnt > 0 && isdirty)
{
this.TryRendering(text);
}
}
}
}
}
public void PrepareAtlas(SpriteAsset asset)
{
if (allatlas == null)
{
allatlas = ListPool <SpriteAsset> .Get();
}
if (!allatlas.Contains(asset))
{
allatlas.Add(asset);
}
}
public SpriteAsset FindAtlas(string atlasname)
{
EmojiTools.BeginSample("FindAtlas");
#if UNITY_EDITOR && !EMOJI_RUNTIME
SpriteAsset result = null;
if (_unityallAtlases != null)
{
for (int i = 0; i < _unityallAtlases.Count; ++i)
{
SpriteAsset asset = _unityallAtlases[i];
if (asset.AssetName.Equals(atlasname))
{
result = asset;
break;
}
}
}
if (_lostAssets == null)
{
_lostAssets = new List <string>();
}
if (!PreparedAtlas.Contains(atlasname))
{
if (!_lostAssets.Contains(atlasname))
{
_lostAssets.Add(atlasname);
}
}
EmojiTools.EndSample();
return(result);
#else
for (int i = 0; i < _sharedAtlases.Count; ++i)
{
SpriteAsset asset = _sharedAtlases[i];
if (asset.AssetName.Equals(atlasname))
{
EmojiTools.EndSample();
return(asset);
}
}
SpriteAsset newasset = InstantiateSpriteAsset(atlasname);
if (newasset != null)
{
_sharedAtlases.Add(newasset);
}
EmojiTools.EndSample();
return(newasset);
#endif
}
void RefreshSubUIMesh(InlineText text, CanvasGraphicGroup group, SpriteAsset matchAsset, Vector3[] Pos, Vector2[] UV, List <string> joblist)
{
// set mesh
tempMesh.SetAtlas(matchAsset);
tempMesh.SetUVLen(UV.Length);
tempMesh.SetVertLen(Pos.Length);
SpriteGraphic graphic = group.graphic;
//think about culling and screen coordinate.......
for (int i = 0; i < Pos.Length; ++i)
{
//text object pos
Vector3 value = Pos[i];
Vector3 worldpos = text.transform.TransformPoint(value);
Vector3 localpos = group.graphic.transform.InverseTransformPoint(worldpos);
tempMesh.SetVert(i, localpos);
}
for (int i = 0; i < UV.Length; ++i)
{
Vector2 value = UV[i];
tempMesh.SetUV(i, value);
}
//rendermesh
UnitMeshInfo currentMesh = group.mesh;
if (!currentMesh.Equals(tempMesh))
{
if (joblist != null && joblist.Count > 0)
{
currentMesh.AddCopy(tempMesh);
tempMesh.Clear();
}
else
{
currentMesh.Copy(tempMesh);
}
}
if (currentMesh.VertCnt() > 3 && currentMesh.UVCnt() > 3)
{
graphic.Draw(this);
}
else
{
graphic.Draw(null);
}
group.isDirty = true;
}
public SpriteInfoGroup FindSpriteGroup(string TagName, out SpriteAsset resultatlas)
{
EmojiTools.BeginSample("Emoji_FindSpriteGroup");
#if UNITY_EDITOR && !EMOJI_RUNTIME
resultatlas = null;
SpriteInfoGroup result = null;
if (_unityallAtlases != null)
{
for (int i = 0; i < _unityallAtlases.Count; ++i)
{
SpriteAsset asset = _unityallAtlases[i];
for (int j = 0; j < asset.listSpriteGroup.Count; ++j)
{
SpriteInfoGroup group = asset.listSpriteGroup[j];
if (group.tag.Equals(TagName))
{
result = group;
resultatlas = asset;
break;
}
}
}
}
if (_lostAssets == null)
{
_lostAssets = new List <string>();
}
if (resultatlas != null && !PreparedAtlas.Contains(resultatlas.AssetName))
{
if (!_lostAssets.Contains(resultatlas.AssetName))
{
_lostAssets.Add(resultatlas.AssetName);
}
}
EmojiTools.EndSample();
return(result);
#else
resultatlas = null;
SpriteInfoGroup result = null;
KeyValuePair <SpriteAsset, SpriteInfoGroup> data;
if (_spritemap.TryGetValue(TagName, out data))
{
result = data.Value;
resultatlas = data.Key;
}
EmojiTools.EndSample();
return(result);
#endif
}
public void PushRenderAtlas(SpriteAsset _spriteAsset)
{
EmojiTools.BeginSample("Emoji_PushRenderAtlas");
if (!isRendering(_spriteAsset) && _spriteAsset != null)
{
_render.PrepareAtlas(_spriteAsset);
if (!_sharedAtlases.Contains(_spriteAsset))
{
_sharedAtlases.Add(_spriteAsset);
}
}
EmojiTools.EndSample();
}
Graphic ParsePosAndUV(InlineText text, int ID, Vector3[] Pos, Vector2[] UV, List <string> joblist)
{
EmojiTools.BeginSample("Emoji_GroupParsePosAndUV");
SpriteAsset matchAsset = null;
for (int i = 0; i < allatlas.Count; ++i)
{
SpriteAsset asset = allatlas[i];
if (asset != null && asset.ID == ID)
{
matchAsset = asset;
break;
}
}
if (matchAsset && matchAsset.texSource != null)
{
CanvasGraphicGroup group = FindGraphicGroup(text.canvas, matchAsset.ID);
if (group == null)
{
group = new CanvasGraphicGroup();
group.AtlasID = matchAsset.ID;
group.canvas = text.canvas;
group.mesh = UnitMeshInfoPool.Get();
group.isDirty = false;
group.graphic = CreateSpriteRender();
if (GraphicTasks == null)
{
GraphicTasks = new List <CanvasGraphicGroup>();
}
GraphicTasks.Add(group);
}
RefreshSubUIMesh(text, group, matchAsset, Pos, UV, joblist);
EmojiTools.EndSample();
return(group.graphic);
}
else
{
Debug.LogErrorFormat("missing {0} atlas", ID);
}
EmojiTools.EndSample();
return(null);
}
public void AddCopy(UnitMeshInfo mesh)
{
if (atlas != null && atlas != mesh.atlas)
{
throw new ArgumentException();
}
atlas = mesh.atlas;
for (int i = 0; i < mesh._Vertices.Count; ++i)
{
_Vertices.Add(mesh._Vertices[i]);
}
for (int i = 0; i < mesh._UV.Count; ++i)
{
_UV.Add(mesh._UV[i]);
}
}
public int Init(ref TextCotext context)
{
#if UNITY_EDITOR
string[] result = AssetDatabase.FindAssets(string.Format("t:{0}", typeof(SpriteAsset).FullName));
if (result.Length > 0)
{
for (int i = 0; i < result.Length; ++i)
{
string path = AssetDatabase.GUIDToAssetPath(result[i]);
SpriteAsset asset = AssetDatabase.LoadAssetAtPath <SpriteAsset>(path);
if (asset)
{
context.Refercens.Add(asset);
}
}
}
#endif
InlineManager[] managers = GameObject.FindObjectsOfType <InlineManager>();
foreach (var manager in managers)
{
foreach (var asset in manager.SharedAssets)
{
if (context.Refercens.Contains(asset) == false)
{
context.Refercens.Add(asset);
}
}
}
Debug.LogFormat("find :{0} atlas resource", result.Length);
foreach (var asset in context.Refercens)
{
foreach (var gp in asset.listSpriteGroup)
{
context.GroupMapper[gp.tag] = gp;
}
}
return(0);
}
void RebuildTagList()
{
EmojiTools.BeginSample("Emoji_rebuildTags");
_alltags.Clear();
_spritemap.Clear();
#if UNITY_EDITOR && !EMOJI_RUNTIME
if (_unityallAtlases != null)
{
for (int i = 0; i < _unityallAtlases.Count; ++i)
{
SpriteAsset asset = _unityallAtlases[i];
for (int j = 0; j < asset.listSpriteGroup.Count; ++j)
{
SpriteInfoGroup infogroup = asset.listSpriteGroup[j];
SpriteInfoGroup group;
if (_alltags.TryGetValue(infogroup.tag, out group))
{
Debug.LogErrorFormat("already exist :{0} ", infogroup.tag);
}
_alltags[infogroup.tag] = infogroup;
}
}
}
#else
for (int i = 0; i < _sharedAtlases.Count; ++i)
{
SpriteAsset asset = _sharedAtlases[i];
for (int j = 0; j < asset.listSpriteGroup.Count; ++j)
{
SpriteInfoGroup infogroup = asset.listSpriteGroup[j];
SpriteInfoGroup group;
if (_alltags.TryGetValue(infogroup.tag, out group))
{
Debug.LogErrorFormat("already exist :{0} ", infogroup.tag);
}
_alltags[infogroup.tag] = infogroup;
_spritemap[infogroup.tag] = new KeyValuePair <SpriteAsset, SpriteInfoGroup>(asset, infogroup);
}
}
#endif
EmojiTools.EndSample();
}
SpriteGraphic ParsePosAndUV(InlineText text, int ID, Vector3[] Pos, Vector2[] UV)
{
EmojiTools.BeginSample("Emoji_UnitParsePosAndUV");
SpriteAsset matchAsset = null;
for (int i = 0; i < allatlas.Count; ++i)
{
SpriteAsset asset = allatlas[i];
if (asset != null && asset.ID == ID)
{
matchAsset = asset;
break;
}
}
if (matchAsset && matchAsset.texSource != null)
{
List <SpriteGraphic> list = null;
SpriteGraphic target = FindGraphic(text, matchAsset, out list);
if (!target)
{
target = CreateSpriteRender(text.transform);
list.Add(target);
}
RefreshSubUIMesh(text, target, matchAsset, Pos, UV);
EmojiTools.EndSample();
return(target);
}
else
{
Debug.LogErrorFormat("missing {0} atlas", ID);
}
EmojiTools.EndSample();
return(null);
}
void Initialize()
{
HasInit = true;
#if UNITY_EDITOR
string[] result = AssetDatabase.FindAssets(string.Format("t:{0}", typeof(SpriteAsset).FullName));
if (result.Length > 0 && _unityallAtlases == null)
{
_unityallAtlases = new List <SpriteAsset>(result.Length);
for (int i = 0; i < result.Length; ++i)
{
string path = AssetDatabase.GUIDToAssetPath(result[i]);
SpriteAsset asset = AssetDatabase.LoadAssetAtPath <SpriteAsset>(path);
if (asset)
{
_unityallAtlases.Add(asset);
}
}
}
Debug.LogFormat("find :{0} atlas resource", result.Length);
Debug.LogWarning("if your asset not in the resources please override InstantiateSpriteAsset");
#endif
EmojiTools.BeginSample("Emoji_Init");
InitRender();
EmojiTools.EndSample();
EmojiTools.BeginSample("Emoji_preLoad");
PreLoad();
EmojiTools.EndSample();
RebuildTagList();
ForceRebuild();
}
public void Clear()
{
atlas = null;
_Vertices.Clear();
_UV.Clear();
}
public void SetAtlas(SpriteAsset data)
{
atlas = data;
}
public override void OnInspectorGUI()
{
InlineManager manager = target as InlineManager;
EditorGUILayout.PropertyField(m_Script);
EditorGUILayout.Space();
serializedObject.Update();
manager.OpenDebug = EditorGUILayout.Toggle("Debug", manager.OpenDebug);
manager.RenderType = (EmojiRenderType)EditorGUILayout.EnumPopup("Rendetype", manager.RenderType);
manager.AnimationSpeed = EditorGUILayout.Slider("AnimationSpeed", manager.AnimationSpeed, 0, 100);
foldout = EditorGUILayout.Foldout(foldout, "prepared:" + manager.PreparedAtlas.Count);
if (foldout)
{
EditorGUI.indentLevel++;
for (int i = 0; i < manager.PreparedAtlas.Count; ++i)
{
string resName = manager.PreparedAtlas[i];
SpriteAsset asset = null;
if (!string.IsNullOrEmpty(resName))
{
if (!assetDic.ContainsKey(resName))
{
string fixname = System.IO.Path.GetFileNameWithoutExtension(resName);
string[] allassets = AssetDatabase.FindAssets(string.Format("t:{0}", typeof(SpriteAsset).FullName));
for (int j = 0; j < allassets.Length; ++j)
{
string path = AssetDatabase.GUIDToAssetPath(allassets[j]);
string subname = System.IO.Path.GetFileNameWithoutExtension(path);
if (subname.Equals(fixname))
{
asset = assetDic[resName] = AssetDatabase.LoadAssetAtPath <SpriteAsset>(path);
break;
}
}
}
else
{
asset = assetDic[resName];
}
}
SpriteAsset newasset = (SpriteAsset)EditorGUILayout.ObjectField(i.ToString(), asset, typeof(SpriteAsset), false);
if (newasset != asset)
{
if (newasset == null)
{
manager.PreparedAtlas[i] = "";
}
else
{
manager.PreparedAtlas[i] = System.IO.Path.GetFileNameWithoutExtension(AssetDatabase.GetAssetPath(newasset));
assetDic[manager.PreparedAtlas[i]] = newasset;
}
EditorUtility.SetDirty(manager);
}
}
EditorGUI.indentLevel--;
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("add", GUILayout.Width(100)))
{
manager.PreparedAtlas.Add("");
}
if (GUILayout.Button("remove", GUILayout.Width(100)))
{
if (manager.PreparedAtlas.Count > 0)
{
manager.PreparedAtlas.RemoveAt(manager.PreparedAtlas.Count - 1);
}
}
EditorGUILayout.EndHorizontal();
}
serializedObject.ApplyModifiedProperties();
}
void PlayAnimation()
{
EmojiTools.BeginSample("Emoji_GroupAnimation");
if (alltexts != null)
{
if (_time == null)
{
_time = Time.timeSinceLevelLoad;
}
else
{
float deltatime = Time.timeSinceLevelLoad - _time.Value;
int framecnt = Mathf.RoundToInt(deltatime * Speed);
if (framecnt > 0)
{
List <string> joblist = ListPool <string> .Get();
for (int i = 0; i < alltexts.Count; ++i)
{
InlineText text = alltexts[i];
List <IFillData> emojidata = text.PopEmojiData();
if (emojidata != null && emojidata.Count > 0 && allatlas != null && allatlas.Count > 0)
{
for (int j = 0; j < emojidata.Count; ++j)
{
IFillData taginfo = emojidata[j];
if (taginfo == null || taginfo.ignore)
{
continue;
}
SpriteAsset asset = null;
SpriteInfoGroup groupinfo = manager.FindSpriteGroup(taginfo.Tag, out asset);
if (groupinfo != null && groupinfo.spritegroups.Count > 1)
{
int index = framecnt % groupinfo.spritegroups.Count;
SpriteInfo sprInfo = groupinfo.spritegroups[index];
taginfo.uv = sprInfo.uv;
//render next
CanvasGraphicGroup group = FindGraphicGroup(text.canvas, asset.ID);
if (group != null)
{
if (tempMesh == null)
{
tempMesh = UnitMeshInfoPool.Get();
}
RefreshSubUIMesh(text, group, asset, taginfo.pos, taginfo.uv, joblist);
if (group.isDirty)
{
group.graphic.SetVerticesDirty();
}
joblist.Add(taginfo.Tag);
}
}
}
}
}
ListPool <string> .Release(joblist);
}
}
}
EmojiTools.EndSample();
}
public bool isRendering(SpriteAsset _spriteAsset)
{
return(_spriteAsset != null && _render != null && _render.isRendingAtlas(_spriteAsset));
}
void InitRender()
{
if (_render == null || _render.renderType != RenderType)
{
if (RenderType == EmojiRenderType.RenderGroup)
{
EmojiRenderGroup newRender = new EmojiRenderGroup(this);
newRender.Speed = AnimationSpeed;
if (_render != null)
{
List <InlineText> list = _render.GetAllRenders();
if (list != null)
{
for (int i = 0; i < list.Count; ++i)
{
InlineText text = list[i];
if (text != null)
{
newRender.TryRendering(text);
}
}
}
List <SpriteAsset> atlaslist = _render.GetAllRenderAtlas();
if (atlaslist != null)
{
for (int i = 0; i < atlaslist.Count; ++i)
{
SpriteAsset atlas = atlaslist[i];
if (atlas != null)
{
newRender.PrepareAtlas(atlas);
}
}
}
_render.Dispose();
}
_render = newRender;
}
else if (RenderType == EmojiRenderType.RenderUnit)
{
UnitRender newRender = new UnitRender(this);
newRender.Speed = AnimationSpeed;
if (_render != null)
{
List <InlineText> list = _render.GetAllRenders();
if (list != null)
{
for (int i = 0; i < list.Count; ++i)
{
InlineText text = list[i];
if (text != null)
{
newRender.TryRendering(text);
}
}
}
List <SpriteAsset> atlaslist = _render.GetAllRenderAtlas();
if (atlaslist != null)
{
for (int i = 0; i < atlaslist.Count; ++i)
{
SpriteAsset atlas = atlaslist[i];
if (atlas != null)
{
newRender.PrepareAtlas(atlas);
}
}
}
_render.Dispose();
}
_render = newRender;
}
else
{
Debug.LogError("not support yet");
this.enabled = false;
}
}
}
void PlayAnimation()
{
EmojiTools.BeginSample("Emoji_UnitAnimation");
if (alltexts != null)
{
if (_time == null)
{
_time = Time.timeSinceLevelLoad;
}
else
{
float deltatime = Time.timeSinceLevelLoad - _time.Value;
//at least one frame
int framecnt = Mathf.RoundToInt(deltatime * Speed);
if (framecnt > 0)
{
for (int i = 0; i < alltexts.Count; ++i)
{
InlineText text = alltexts[i];
List <IFillData> emojidata = text.PopEmojiData();
if (emojidata != null && emojidata.Count > 0 && allatlas != null && allatlas.Count > 0)
{
for (int j = 0; j < emojidata.Count; ++j)
{
IFillData taginfo = emojidata[j];
if (taginfo == null || taginfo.ignore)
{
continue;
}
SpriteAsset asset = null;
SpriteInfoGroup groupinfo = manager.FindSpriteGroup(taginfo.Tag, out asset);
if (groupinfo != null && groupinfo.spritegroups.Count > 1)
{
int index = framecnt % groupinfo.spritegroups.Count;
SpriteInfo sprInfo = groupinfo.spritegroups[index];
taginfo.uv = sprInfo.uv;
List <SpriteGraphic> list = null;
SpriteGraphic target = FindGraphic(text, asset, out list);
if (target)
{
if (tempMesh == null)
{
tempMesh = UnitMeshInfoPool.Get();
}
if (renderData == null)
{
renderData = new Dictionary <Graphic, UnitMeshInfo>(emojidata.Count);
}
RefreshSubUIMesh(text, target, asset, taginfo.pos, taginfo.uv);
}
}
}
}
}
}
}
}
EmojiTools.EndSample();
}
