public override void Awake()
{
base.Awake();
var t = mDMono.transform;
StarIcon = t.GetComponentEx <UISprite>();
FX = t.FindEx("FX").gameObject;
SSO = FX.GetComponent <SetSortingOrder>();
FxPlayTime = 0.45f;
m_light = "Ty_Icon_Xingxing";
}
public void Stop()
{
StopTimer();
if (mFX != null)
{
mFX.EnableEmission(false);
mFX.Stop(true);
mFX.Clear(true);
mFX.StopAll(true);
Animator[] animators = mFX.GetComponentsInChildren <Animator>(true);
if (animators != null)
{
for (int i = 0; i < animators.Length; i++)
{
Animator anim = animators[i];
anim.gameObject.CustomSetActive(false);
}
}
Animation[] animations = mFX.GetComponentsInChildren <Animation>(true);
if (animators != null)
{
for (int i = 0; i < animations.Length; i++)
{
Animation anim = animations[i];
anim.gameObject.CustomSetActive(false);
}
}
SetSortingOrder sso = mFX.GetComponent <SetSortingOrder>();
if (sso != null)
{
sso.SetLayer(mOriginSortingOrder);
Destroy(sso);
}
ClearAllMats();
Destroy(mFX.gameObject);
mFX = null;
}
if (destroyOnStop)
{
Destroy(gameObject);
}
}
private GameObject CreateObj(GameObject obj, bool isFx)
{
if (obj == null)
{
return(null);
}
GameObject tempObj = GameObject.Instantiate(obj);
tempObj.transform.SetParent(ContainerObj.transform);
tempObj.transform.localPosition = Vector3.zero;
tempObj.transform.localScale = Vector3.one;
if (isFx)
{
SetSortingOrder sso = tempObj.GetComponent <SetSortingOrder>();
if (sso == null)
{
sso = tempObj.AddComponent <SetSortingOrder>();
}
sso.SortingOrder = Panel.sortingOrder + 1;
}
return(tempObj);
}
public void Play(bool clear = true)
{
if (mFX != null && clear)
{
Stop();
}
if (fx == null)
{
EB.Debug.LogWarning("ParticleSystemUIComponent's fx is null,Please check it name——{0}", this.gameObject.name);
return;
}
if (mFX == null)
{
ClearAllMats();
mFX = Instantiate(fx);
_particleSystemRenderers = mFX.gameObject.GetComponentsInChildren <ParticleSystemRenderer>(true);
_particleSystems = mFX.gameObject.GetComponentsInChildren <ParticleSystem>(true);
}
if (mFX != null)
{
ParticleSystem[] ps = mFX.GetComponentsInChildren <ParticleSystem>();
if (needFXScaleMode && ps != null)
{
for (int i = 0; i < ps.Length; ++i)
{
var main = ps[i].main;
main.scalingMode = ScaleMode;
}
}
if (!isPlaceOutside)
{
mFX.transform.SetParent(transform);
mFX.transform.localScale = fx.transform.localScale;
}
if (scaleByAspect)
{
Vector2 screenSize = NGUITools.screenSize;
float screenScale = 1f;
if ((screenSize.x / screenSize.y) < (16f / 9f))
{
screenScale = screenSize.y / screenSize.x * (16.0f / 9.0f); // base aspect is iphone 16 : 9
}
else if ((screenSize.x / screenSize.y) > (16f / 9f))
{
screenScale = screenSize.x / screenSize.y * (9.0f / 16.0f); // base aspect is iphone 16 : 9
}
if (needFXScaleMode)
{
mFX.transform.localScale = screenScale * fx.transform.localScale;
}
else
{
for (int i = 0; i < ps.Length; ++i)
{
if (ps[i] != mFX)
{
ps[i].transform.localScale *= screenScale;
}
}
}
}
if (isPlaceOutside)
{
mFX.transform.position = transform.position;
}
else
{
mFX.transform.localPosition = position;
}
mFX.transform.localEulerAngles = rotation;
SetScale();
NGUITools.SetLayer(mFX.gameObject, gameObject.layer);
SetSortingOrder sso = mFX.gameObject.GetComponent <SetSortingOrder>();
if (sso == null)
{
sso = mFX.gameObject.AddComponent <SetSortingOrder>();
}
mOriginSortingOrder = sso.OriginSortingOrder;
sso.SortingOrder = panel.sortingOrder + sortingOrderOffset;
//mFX.EnableEmission(true);
//mFX.Simulate(0.0001f, true, true);
if (WaitFrame == 0)
{
mFX.gameObject.CustomSetActive(true);
PlayFx(); // mFX.Play(true);
}
else
{
mFX.Stop(true);
//if (mTimer == 0)
//{
// mTimer = TimerManager.instance.AddFramer(WaitFrame, 1, FxPlayTimer);
//}
mWaitFrame = WaitFrame;
}
if (playTime > 0)
{
Invoke("OnPlayEnd", playTime);
}
}
else
{
EB.Debug.LogError("ParticleSystemReferenceComponent.Play: fx not found, {0}", fx.name);
}
}
/// <summary>
/// 分配的UI深度
/// </summary>
private int AssignDepths(IStackableWrapper wrapper)
{
int stackDepth = _nextStackDepth;
int originStartSortingOrder = wrapper.lastSortingOrder = wrapper.firstSortingOrder = GetHighestSortingOrder();
if (wrapper.stackable is Component)
{
List <UIPanel> panels = new List <UIPanel>();
List <Renderer> renderers = new List <Renderer>();
panels.AddRange(((Component)wrapper.stackable).GetComponentsInChildren <UIPanel>(true));
renderers.AddRange(((Component)wrapper.stackable).GetComponentsInChildren <Renderer>(true));
panels.Sort((UIPanel panel1, UIPanel panel2) => panel1.sortingOrder != panel2.sortingOrder ? panel1.sortingOrder - panel2.sortingOrder : panel1.depth - panel2.depth);
renderers.Sort((Renderer r1, Renderer r2) => r1.sortingOrder - r2.sortingOrder);
if (wrapper.inputBlockerInstance != null)
{
if (panels.Count == 0)
{
EB.Debug.LogWarning("AssignDepths: need panel above blocker on {0}", wrapper.stackable);
UIPanel uiPanel = ((Component)wrapper.stackable).gameObject.AddComponent <UIPanel>();
panels.Add(uiPanel);
}
UIPanel blockerPanel = wrapper.inputBlockerInstance.GetComponent <UIPanel>();
blockerPanel.depth = panels[0].depth - 1;
blockerPanel.sortingOrder = panels[0].sortingOrder;
panels.Insert(0, blockerPanel);
}
if (panels.Count > 0)
{
int currentOffset = 0;
int previousDepth = panels[0].depth;
panels[0].renderQueue = UIPanel.RenderQueue.StartAt;
panels[0].depth = stackDepth;
wrapper.firstStackDepth = panels[0].depth;
int previousSortingOrder = originStartSortingOrder = panels[0].sortingOrder;
panels[0].sortingOrder = wrapper.firstSortingOrder;
int sortingOrder = panels[0].sortingOrder;
for (int i = 1; i < panels.Count; i++)
{
int currentSortingOrderOffset = panels[i].sortingOrder - previousSortingOrder;
previousSortingOrder = panels[i].sortingOrder;
panels[i].sortingOrder = sortingOrder + currentSortingOrderOffset;
sortingOrder = panels[i].sortingOrder;
wrapper.lastSortingOrder = Mathf.Max(sortingOrder, wrapper.lastSortingOrder);
if (currentSortingOrderOffset > 0)
{
previousDepth = panels[i].depth;
panels[i].depth = stackDepth + currentSortingOrderOffset + 100;
stackDepth = panels[i].depth;
}
else
{
currentOffset = panels[i].depth - previousDepth;
previousDepth = panels[i].depth;
panels[i].depth = stackDepth + currentOffset;
stackDepth = panels[i].depth;
}
}
panels[0].SetDirty();
}
else
{
wrapper.firstStackDepth = stackDepth;
}
if (renderers.Count > 0)
{
int previousSortingOrder = originStartSortingOrder;
int sortingOrder = wrapper.firstSortingOrder;
List <Material> materials = new List <Material>();
for (int i = 0; i < renderers.Count; i++)
{
if (renderers[i].materials != null)
{
materials.AddRange(renderers[i].materials);
}
SetSortingOrder sso = renderers[i].GetComponent <SetSortingOrder>();
int currentSortingOrder = sso != null ? sso.SortingOrder : 0;
int currentSortingOrderOffset = currentSortingOrder - previousSortingOrder;
previousSortingOrder = currentSortingOrder;
sortingOrder = sortingOrder + currentSortingOrderOffset;
if (sso != null)
{
sso.SortingOrder = sortingOrder;
}
wrapper.lastSortingOrder = Mathf.Max(sortingOrder, wrapper.lastSortingOrder);
}
if (materials.Count > 0)
{
materials.Sort((Material m1, Material m2) => m1.renderQueue - m2.renderQueue);
}
}
}
else
{
wrapper.firstStackDepth = stackDepth;
}
stackDepth += 10;
return(stackDepth);
}
