From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- Client/Assets/Scripts/XUtliPoolLib/XFx.cs | 1083 +++++++++++++++++++++++++++++ 1 file changed, 1083 insertions(+) create mode 100644 Client/Assets/Scripts/XUtliPoolLib/XFx.cs (limited to 'Client/Assets/Scripts/XUtliPoolLib/XFx.cs') diff --git a/Client/Assets/Scripts/XUtliPoolLib/XFx.cs b/Client/Assets/Scripts/XUtliPoolLib/XFx.cs new file mode 100644 index 00000000..b1b51b94 --- /dev/null +++ b/Client/Assets/Scripts/XUtliPoolLib/XFx.cs @@ -0,0 +1,1083 @@ +using System; +using System.Collections.Generic; +using UnityEngine; + +namespace XUtliPoolLib +{ + public class XFx : IRenderObject + { + public bool IsLoaded + { + get + { + return this.m_LoadStatus == 1; + } + } + + public Vector3 Position + { + get + { + return (this.m_TransformCache != null) ? this.m_TransformCache.position : this._pos; + } + set + { + this._pos = value; + bool flag = this.m_TransformCache != null; + if (flag) + { + this.m_TransformCache.position = value; + } + } + } + + public Quaternion Rotation + { + get + { + return (this.m_TransformCache != null) ? this.m_TransformCache.rotation : this._rot; + } + set + { + this._rot = value; + bool flag = this.m_TransformCache != null; + if (flag) + { + this.m_TransformCache.rotation = value; + } + } + } + + public Vector3 Forward + { + get + { + bool flag = this.m_TransformCache != null; + Vector3 result; + if (flag) + { + result = this.m_TransformCache.forward; + } + else + { + result = this._rot * Vector3.forward; + } + return result; + } + set + { + this._rot = Quaternion.LookRotation(value); + bool flag = this.m_TransformCache != null; + if (flag) + { + this.m_TransformCache.forward = value; + } + } + } + + public int InstanceID + { + set + { + } + } + + public static int globalFxID = 0; + + public int _instanceID = -1; + + public string FxName = ""; + + private GameObject m_GameObject = null; + + private Transform m_TransformCache = null; + + private Animation _animation = null; + + private AnimationState _animState = null; + + private Animator _animator = null; + + private List _particles = new List(); + + private List _projectors = new List(); + + private List _meshs = null; + + private IWeaponTail _weaponTail = null; + + private TrailRenderer _trail = null; + + private float _startSize = 1f; + + private float _startProjectorSize = 1f; + + public float DelayDestroy = -1f; + + public uint Token = 0u; + + private Transform _parent = null; + + private XGameObject _parentXgo = null; + + private float _speed_ratio = 0f; + + private Vector3 _pos; + + private Quaternion _rot; + + private Vector3 _scale; + + private Vector3 _offset; + + private bool _follow; + + private bool _sticky; + + private string _transName = ""; + + private float _translate = 0f; + + private int _layer = -1; + + private int _renderQueue = -1; + + private bool _enable = true; + + private int m_LoadFinishCbFlag = 0; + + private short m_LoadStatus = 0; + + private LoadAsyncTask loadTask = null; + + private LoadCallBack loadCb = null; + + public LoadCallBack loadFinish = null; + + public OnFxDestroyed callback = null; + + private static CommandCallback _parentLoadCb = new CommandCallback(XFx._ParentLoad); + + private static FxLoadCallback[] loadCallbacks = null; + + public static LoadCallBack _ProcessMesh = new LoadCallBack(XFx.ProcessMesh); + + private enum ECallbackCmd + { + ESyncActive = 1, + ESyncPlay, + ESyncLayer = 4, + ESyncRenderQueue = 8, + ESyncRefreshRenderQueue = 16, + ESyncParent = 32 + } + + public XFx() + { + this.loadCb = new LoadCallBack(this.LoadFinish); + bool flag = XFx.loadCallbacks == null; + if (flag) + { + XFx.loadCallbacks = new FxLoadCallback[] + { + new FxLoadCallback(XFx.SyncActive), + new FxLoadCallback(XFx.SyncPlay), + new FxLoadCallback(XFx.SyncLayer), + new FxLoadCallback(XFx.SyncRenderQueue), + new FxLoadCallback(XFx.SyncRefreshUIRenderQueue), + new FxLoadCallback(XFx.SyncParent) + }; + } + } + + public static int GetGlobalFxID() + { + XFx.globalFxID++; + bool flag = XFx.globalFxID > 1000000; + if (flag) + { + XFx.globalFxID = 0; + } + return XFx.globalFxID; + } + + public static XFx CreateXFx(string location, LoadCallBack loadFinish, bool async = true) + { + XFx xfx = CommonObjectPool.Get(); + xfx._instanceID = XFx.GetGlobalFxID(); + xfx.FxName = location; + xfx.loadFinish = loadFinish; + bool flag = string.IsNullOrEmpty(location) || location.EndsWith("empty"); + if (flag) + { + xfx.LoadFinish(null, null); + } + else + { + bool flag2 = XSingleton.singleton.DelayLoad && async; + if (flag2) + { + xfx.LoadAsync(location); + } + else + { + xfx.Load(location); + } + } + return xfx; + } + + public static void DestroyXFx(XFx fx, bool stop = true) + { + bool flag = fx._instanceID >= 0; + if (flag) + { + if (stop) + { + fx.Stop(); + } + fx.Reset(); + CommonObjectPool.Release(fx); + } + } + + public void Reset() + { + bool flag = this.callback != null; + if (flag) + { + this.callback(this); + } + this._instanceID = -1; + this.FxName = ""; + this.m_TransformCache = null; + this.DelayDestroy = -1f; + bool flag2 = this.Token > 0u; + if (flag2) + { + XSingleton.singleton.KillTimer(this.Token); + } + this.Token = 0u; + this._animation = null; + this._animator = null; + this._particles.Clear(); + this._projectors.Clear(); + bool flag3 = this._meshs != null; + if (flag3) + { + this._meshs.Clear(); + ListPool.Release(this._meshs); + this._meshs = null; + } + this._weaponTail = null; + this._trail = null; + this._parent = null; + this._parentXgo = null; + this._startSize = 1f; + this._startProjectorSize = 1f; + this._pos = XResourceLoaderMgr.Far_Far_Away; + this._rot = Quaternion.identity; + this._scale = Vector3.one; + this._offset = Vector3.zero; + this._speed_ratio = 0f; + this._follow = false; + this._sticky = false; + this._transName = ""; + this._translate = 0f; + this._layer = -1; + this._renderQueue = -1; + this._enable = true; + this.m_LoadFinishCbFlag = 0; + this.m_LoadStatus = 0; + bool flag4 = this.loadTask != null; + if (flag4) + { + this.loadTask.CancelLoad(this.loadCb); + this.loadTask = null; + } + this.callback = null; + XResourceLoaderMgr.SafeDestroy(ref this.m_GameObject, true); + } + + private void LoadAsync(string location) + { + this.loadTask = XSingleton.singleton.CreateFromPrefabAsync(location, this.loadCb, null, true); + bool isLoaded = this.IsLoaded; + if (isLoaded) + { + this.loadTask = null; + } + } + + private void Load(string location) + { + GameObject obj = XSingleton.singleton.CreateFromAsset(location, ".prefab", true, false); + this.LoadFinish(obj, null); + } + + private bool PreProcessFx(GameObject go, int qualityLayer) + { + int num = 1 << go.layer; + bool flag = (num & qualityLayer) == 0; + bool result; + if (flag) + { + bool activeSelf = go.activeSelf; + if (activeSelf) + { + go.SetActive(false); + } + result = false; + } + else + { + result = true; + } + return result; + } + + private void LoadFinish(UnityEngine.Object obj, object cbOjb) + { + this.m_GameObject = (obj as GameObject); + this.m_LoadStatus = 1; + bool flag = this.m_GameObject != null; + if (flag) + { + this.m_TransformCache = this.m_GameObject.transform; + this._animation = this.m_TransformCache.GetComponentInChildren(); + this._animator = this.m_TransformCache.GetComponentInChildren(); + bool flag2 = this._animator != null; + if (flag2) + { + this._animator.enabled = true; + } + bool flag3 = this._animation != null; + if (flag3) + { + this._animation.enabled = true; + } + this._particles.Clear(); + this._projectors.Clear(); + List list = ListPool.Get(); + this.m_TransformCache.GetComponentsInChildren(true, list); + for (int i = 0; i < list.Count; i++) + { + Component component = list[i]; + bool flag4 = component is ParticleSystem; + if (flag4) + { + ParticleSystem particleSystem = component as ParticleSystem; + bool flag5 = XFxMgr.MaxParticelCount > 0; + if (flag5) + { + ParticleSystem.MainModule main = particleSystem.main; + bool flag6 = main.maxParticles > XFxMgr.MaxParticelCount; + if (flag6) + { + main.maxParticles = XFxMgr.MaxParticelCount; + } + } + bool flag7 = this.PreProcessFx(particleSystem.gameObject, XSingleton.singleton.CameraLayerMask); + if (flag7) + { + this._particles.Add(particleSystem); + } + } + else + { + bool flag8 = component is Projector; + if (flag8) + { + Projector projector = component as Projector; + bool flag9 = this.PreProcessFx(projector.gameObject, XSingleton.singleton.CameraLayerMask); + if (flag9) + { + this._projectors.Add(projector); + } + } + else + { + bool flag10 = component is IWeaponTail; + if (flag10) + { + this._weaponTail = (component as IWeaponTail); + } + else + { + bool flag11 = component is TrailRenderer; + if (flag11) + { + this._trail = (component as TrailRenderer); + } + } + } + } + } + ListPool.Release(list); + bool flag12 = this.loadFinish != null; + if (flag12) + { + this.loadFinish(this.m_GameObject, this); + } + for (int j = 0; j < XFx.loadCallbacks.Length; j++) + { + bool flag13 = this.IsCbFlag(j); + if (flag13) + { + FxLoadCallback fxLoadCallback = XFx.loadCallbacks[j]; + fxLoadCallback(this); + } + } + this.m_LoadFinishCbFlag = 0; + } + } + + private void SetCbFlag(XFx.ECallbackCmd cmd, bool add) + { + int num = XFastEnumIntEqualityComparer.ToInt(cmd); + if (add) + { + this.m_LoadFinishCbFlag |= num; + } + else + { + this.m_LoadFinishCbFlag &= ~num; + } + } + + private bool IsCbFlag(int index) + { + int num = 1 << index; + return (this.m_LoadFinishCbFlag & num) != 0; + } + + private static void _ParentLoad(XGameObject gameObject, object o, int commandID) + { + XFx xfx = o as XFx; + bool flag = xfx._instanceID == commandID; + if (flag) + { + xfx.RealPlay(); + } + } + + private static void SyncPlay(XFx fx) + { + bool flag = fx._parentXgo != null; + if (flag) + { + fx._parentXgo.CallCommand(XFx._parentLoadCb, fx, fx._instanceID, false); + } + else + { + fx.RealPlay(); + } + } + + private static void SyncLayer(XFx fx) + { + bool flag = fx._layer >= 0; + if (flag) + { + for (int i = 0; i < fx._particles.Count; i++) + { + ParticleSystem particleSystem = fx._particles[i]; + bool flag2 = particleSystem != null; + if (flag2) + { + particleSystem.gameObject.layer = fx._layer; + } + } + for (int j = 0; j < fx._projectors.Count; j++) + { + Projector projector = fx._projectors[j]; + projector.gameObject.layer = fx._layer; + } + bool flag3 = fx._meshs != null; + if (flag3) + { + for (int k = 0; k < fx._meshs.Count; k++) + { + MeshRenderer meshRenderer = fx._meshs[k]; + bool flag4 = meshRenderer != null; + if (flag4) + { + meshRenderer.gameObject.layer = fx._layer; + } + } + } + } + } + + private static void SyncRenderQueue(XFx fx) + { + bool flag = fx._renderQueue > 0; + if (flag) + { + for (int i = 0; i < fx._particles.Count; i++) + { + ParticleSystem particleSystem = fx._particles[i]; + Renderer component = particleSystem.GetComponent(); + bool flag2 = component != null && component.sharedMaterial != null; + if (flag2) + { + component.material.renderQueue = fx._renderQueue; + } + } + bool flag3 = fx._meshs != null; + if (flag3) + { + for (int j = 0; j < fx._meshs.Count; j++) + { + MeshRenderer meshRenderer = fx._meshs[j]; + bool flag4 = meshRenderer != null && meshRenderer.sharedMaterial != null; + if (flag4) + { + meshRenderer.material.renderQueue = fx._renderQueue; + } + } + } + } + } + + public static void SyncRefreshUIRenderQueue(XFx fx) + { + bool flag = fx.m_GameObject != null; + if (flag) + { + for (int i = 0; i < fx._particles.Count; i++) + { + IControlParticle controlParticle = fx._particles[i].gameObject.GetComponent("ControlParticle") as IControlParticle; + bool flag2 = controlParticle != null; + if (flag2) + { + controlParticle.RefreshRenderQueue(true); + } + } + } + } + + private static void SyncActive(XFx fx) + { + bool flag = fx.m_GameObject != null; + if (flag) + { + fx.m_GameObject.SetActive(fx._enable); + } + } + + private static void SyncParent(XFx fx) + { + bool flag = fx.m_TransformCache != null; + if (flag) + { + fx.m_TransformCache.parent = fx._parent; + fx.m_TransformCache.localPosition = fx._pos; + fx.m_TransformCache.localRotation = fx._rot; + fx.m_TransformCache.localScale = fx._scale; + } + } + + private void SetTransform() + { + bool flag = this.m_TransformCache != null; + if (flag) + { + bool flag2 = this._parent == null; + if (flag2) + { + this.m_TransformCache.position = this._pos; + this.m_TransformCache.rotation = this._rot; + this.m_TransformCache.localScale = this._scale; + } + else + { + bool follow = this._follow; + if (follow) + { + this.m_TransformCache.parent = this._parent; + this.m_TransformCache.localPosition = Vector3.zero; + this.m_TransformCache.localRotation = Quaternion.identity; + this.m_TransformCache.localScale = this._scale; + this.m_TransformCache.localPosition += this._parent.rotation * this._offset; + } + else + { + this.m_TransformCache.position = this._parent.position + this._parent.rotation * this._offset; + this.m_TransformCache.rotation = this._parent.rotation; + this.m_TransformCache.localScale = this._scale; + } + bool flag3 = Mathf.Abs(this._translate) > 0.001f; + if (flag3) + { + this.m_TransformCache.Translate(Vector3.up * this._translate); + this._translate = 0f; + } + } + } + } + + private void RealPlay() + { + bool flag = this._parent == null && this._parentXgo != null; + if (flag) + { + this._parent = this._parentXgo.Find(""); + bool flag2 = this._parent != null && !string.IsNullOrEmpty(this._transName); + if (flag2) + { + Transform transform = this._parent.Find(this._transName); + bool flag3 = transform == null; + if (flag3) + { + int num = this._transName.LastIndexOf("/"); + bool flag4 = num >= 0; + if (flag4) + { + string text = this._transName.Substring(num + 1); + transform = this._parent.Find(text); + bool flag5 = transform != null; + if (flag5) + { + this._parent = transform; + } + } + } + else + { + this._parent = transform; + } + } + } + this.SetTransform(); + bool enable = this._enable; + if (enable) + { + bool flag6 = this.m_GameObject != null && !this.m_GameObject.activeSelf; + if (flag6) + { + this.m_GameObject.SetActive(true); + } + bool flag7 = this._animation != null; + if (flag7) + { + this._animation.enabled = true; + this._animation.Play(); + this._animState = this._animation[this._animation.name]; + bool flag8 = this._animState != null; + if (flag8) + { + bool flag9 = this._speed_ratio > 0f; + if (flag9) + { + this._animState.speed = 1f / this._speed_ratio; + } + else + { + this._animState.speed = 0f; + } + } + } + bool flag10 = this._animator != null; + if (flag10) + { + this._animator.enabled = true; + bool flag11 = this._speed_ratio > 0f; + if (flag11) + { + this._animator.speed = 1f / this._speed_ratio; + } + else + { + this._animator.speed = 0f; + } + bool flag12 = this._animator.runtimeAnimatorController != null; + if (flag12) + { + this._animator.Play(this._animator.runtimeAnimatorController.name, 0, 0f); + } + } + bool flag13 = this._particles != null; + if (flag13) + { + this._startSize = this._scale.x; + for (int i = 0; i < this._particles.Count; i++) + { + ParticleSystem particleSystem = this._particles[i]; + ParticleSystem.MainModule main = particleSystem.main; + bool flag14 = this._speed_ratio > 0f; + if (flag14) + { + main.simulationSpeed = 1f / this._speed_ratio; + } + else + { + main.simulationSpeed = 0f; + } + bool flag15 = this._startSize > 0f; + if (flag15) + { + ParticleSystem.MinMaxCurve startSize = main.startSize; + ParticleSystem.MinMaxCurve startSizeZ = main.startSizeZ; + startSize.constantMin = this._startSize * startSizeZ.constantMin; + startSize.constantMax = this._startSize * startSizeZ.constantMax; + } + particleSystem.time = 0f; + particleSystem.Play(false); + } + } + bool flag16 = this._projectors != null; + if (flag16) + { + this._startProjectorSize = 1f; + float aspectRatio = 1f; + bool flag17 = this._scale.z > 0f; + if (flag17) + { + aspectRatio = this._scale.x / this._scale.z; + this._startProjectorSize = this._scale.z; + } + for (int j = 0; j < this._projectors.Count; j++) + { + Projector projector = this._projectors[j]; + projector.enabled = true; + projector.aspectRatio = aspectRatio; + projector.orthographicSize *= this._startProjectorSize; + } + } + bool flag18 = this._weaponTail != null; + if (flag18) + { + this._weaponTail.Activate(); + } + bool flag19 = this._trail != null; + if (flag19) + { + this._trail.enabled = true; + } + this.StickToGround(); + } + } + + private void ReqPlay() + { + bool isLoaded = this.IsLoaded; + if (isLoaded) + { + XFx.SyncPlay(this); + } + else + { + this.SetCbFlag(XFx.ECallbackCmd.ESyncPlay, true); + } + } + + public void Play(Vector3 position, Quaternion rotation, Vector3 scale, float speed_ratio = 1f) + { + this._parent = null; + this._parentXgo = null; + this._pos = position; + this._rot = rotation; + this._scale = scale; + this._offset = Vector3.zero; + this._speed_ratio = speed_ratio; + this._follow = false; + this._sticky = false; + this._transName = ""; + this._translate = 0f; + this.ReqPlay(); + } + + public void Play(Transform parent, Vector3 offset, Vector3 scale, float speed_ratio = 1f, bool follow = false, bool sticky = false) + { + this._parent = parent; + this._parentXgo = null; + this._pos = Vector3.zero; + this._rot = Quaternion.identity; + this._scale = scale; + this._offset = offset; + this._speed_ratio = speed_ratio; + this._follow = follow; + this._sticky = sticky; + this._transName = ""; + this._translate = 0f; + this.ReqPlay(); + } + + public void Play(XGameObject parent, Vector3 offset, Vector3 scale, float speed_ratio = 1f, bool follow = false, bool sticky = false, string transName = "", float translate = 0f) + { + this._parent = null; + this._parentXgo = parent; + this._pos = Vector3.zero; + this._rot = Quaternion.identity; + this._scale = scale; + this._offset = offset; + this._speed_ratio = speed_ratio; + this._follow = follow; + this._sticky = sticky; + this._transName = transName; + this._translate = translate; + this.ReqPlay(); + } + + public void Play() + { + this.ReqPlay(); + } + + public void SetParent(Transform parent) + { + this._parent = parent; + this._parentXgo = null; + this._pos = Vector3.zero; + this._rot = Quaternion.identity; + this._scale = Vector3.one; + this._offset = Vector3.zero; + this._speed_ratio = 1f; + this._follow = false; + this._sticky = false; + this._transName = ""; + this._translate = 0f; + } + + public void SetParent(Transform parent, Vector3 position, Quaternion rotation, Vector3 scale) + { + this._parent = parent; + this._pos = position; + this._rot = rotation; + this._scale = scale; + bool isLoaded = this.IsLoaded; + if (isLoaded) + { + XFx.SyncParent(this); + } + else + { + this.SetCbFlag(XFx.ECallbackCmd.ESyncParent, true); + } + } + + public void Stop() + { + bool flag = this.m_GameObject != null && this.m_GameObject.transform != null; + if (flag) + { + this.m_GameObject.transform.localScale = Vector3.one; + } + bool flag2 = this._animation != null; + if (flag2) + { + this._animation.Stop(); + this._animation.enabled = false; + } + bool flag3 = this._animator != null; + if (flag3) + { + this._animator.speed = 1f; + this._animator.enabled = false; + } + bool flag4 = this._particles != null; + if (flag4) + { + for (int i = 0; i < this._particles.Count; i++) + { + ParticleSystem particleSystem = this._particles[i]; + bool flag5 = particleSystem != null; + if (flag5) + { + particleSystem.Stop(false); + particleSystem.Clear(false); + } + } + } + bool flag6 = this._projectors != null; + if (flag6) + { + for (int j = 0; j < this._projectors.Count; j++) + { + Projector projector = this._projectors[j]; + bool flag7 = projector != null; + if (flag7) + { + projector.enabled = false; + bool flag8 = this._startProjectorSize > 0f; + if (flag8) + { + projector.orthographicSize /= this._startProjectorSize; + } + } + } + } + bool flag9 = this._weaponTail != null; + if (flag9) + { + this._weaponTail.Deactivate(); + } + bool flag10 = this._trail != null; + if (flag10) + { + this._trail.enabled = false; + } + this._startSize = 1f; + this._startProjectorSize = 1f; + } + + public void StickToGround() + { + bool flag = this.m_GameObject == null || this.m_GameObject.transform.parent == null || !this._sticky; + if (!flag) + { + Vector3 zero = Vector3.zero; + float num = 0f; + Vector3 position = this.m_GameObject.transform.parent.position; + float y = this.m_GameObject.transform.parent.localScale.y; + bool flag2 = XCurrentGrid.grid.TryGetHeight(position, out num); + if (flag2) + { + zero.y = (num - position.y) / y + 0.025f; + } + this.m_GameObject.transform.localPosition = zero; + } + } + + public void SetUIWidget(GameObject go) + { + bool flag = this.m_GameObject != null; + if (flag) + { + for (int i = 0; i < this._particles.Count; i++) + { + IControlParticle controlParticle = this._particles[i].gameObject.GetComponent("ControlParticle") as IControlParticle; + bool flag2 = controlParticle != null; + if (flag2) + { + controlParticle.SetWidget(go); + } + } + } + } + + public void SetActive(bool enable) + { + bool flag = this._enable != enable; + if (flag) + { + this._enable = enable; + bool isLoaded = this.IsLoaded; + if (isLoaded) + { + XFx.SyncActive(this); + } + else + { + this.SetCbFlag(XFx.ECallbackCmd.ESyncActive, true); + } + } + } + + public bool IsSameObj(int id) + { + return this._instanceID == id; + } + + public void SetShader(int type) + { + } + + public void ResetShader() + { + } + + public void SetColor(byte r, byte g, byte b, byte a) + { + } + + public void SetColor(Color32 c) + { + } + + public void Update() + { + } + + public void SetRenderLayer(int layer) + { + bool flag = this._layer != layer; + if (flag) + { + this._layer = layer; + bool isLoaded = this.IsLoaded; + if (isLoaded) + { + XFx.SyncLayer(this); + } + else + { + this.SetCbFlag(XFx.ECallbackCmd.ESyncLayer, true); + } + } + } + + public void Clean() + { + } + + public void SetRenderQueue(int renderQueue) + { + bool flag = this._renderQueue != renderQueue; + if (flag) + { + this._renderQueue = renderQueue; + bool isLoaded = this.IsLoaded; + if (isLoaded) + { + XFx.SyncRenderQueue(this); + } + else + { + this.SetCbFlag(XFx.ECallbackCmd.ESyncRenderQueue, true); + } + } + } + + public void RefreshUIRenderQueue() + { + bool isLoaded = this.IsLoaded; + if (isLoaded) + { + XFx.SyncRefreshUIRenderQueue(this); + } + else + { + this.SetCbFlag(XFx.ECallbackCmd.ESyncRefreshRenderQueue, true); + } + } + + public static void ProcessMesh(UnityEngine.Object obj, object cbOjb) + { + GameObject gameObject = obj as GameObject; + bool flag = gameObject != null; + if (flag) + { + XFx xfx = cbOjb as XFx; + List list = ListPool.Get(); + gameObject.GetComponentsInChildren(true, list); + for (int i = 0; i < list.Count; i++) + { + Component component = list[i]; + bool flag2 = component is MeshRenderer; + if (flag2) + { + bool flag3 = xfx._meshs == null; + if (flag3) + { + xfx._meshs = ListPool.Get(); + } + xfx._meshs.Add(component as MeshRenderer); + } + } + ListPool.Release(list); + } + } + } +} -- cgit v1.1-26-g67d0