private void PlaySound(FXSpine dataSpine)
{
if (dataSpine != null && dataSpine.audioId > 0)
{
SoundManager.PlayUI(dataSpine.audioId, dataSpine.audioLoop == 1);
}
}
public sealed override string GetPath(int guid)
{
FXSpine fXSpine = DataReader <FXSpine> .Get(guid);
if (fXSpine == null)
{
Debug.LogError("[FXSpine] no find, id = " + guid);
return(null);
}
return(FileSystem.GetPathOfSpine(fXSpine.name));
}
public int PlaySpine(int templateId, Transform host, string uibase, int depthValue = 2001, Action finishCallback = null, string layer = "UI", float xOffset = 0f, float yOffset = 0f, float xScale = 1f, float yScale = 1f, bool stencilMask = false, FXMaskLayer.MaskState maskState = FXMaskLayer.MaskState.None)
{
if (this.IsLockWhenDeleteAllSpine)
{
return(0);
}
if (!string.IsNullOrEmpty(ClientGMManager.spineout_ids))
{
string[] array = ClientGMManager.spineout_ids.Split(new char[]
{
','
});
for (int i = 0; i < array.Length; i++)
{
if (int.Parse(array[i]) == templateId)
{
return(0);
}
}
}
if (!SystemConfig.IsUIFXOn)
{
return(0);
}
if (templateId <= 0)
{
return(0);
}
if (host == null)
{
return(0);
}
FXSpine fXSpine = DataReader <FXSpine> .Get(templateId);
if (fXSpine == null)
{
return(0);
}
if (string.IsNullOrEmpty(fXSpine.name))
{
return(0);
}
int uid = ++this.m_fxOfcounter;
this.m_fxSpines.set_Item(uid, null);
this.PreloadAsset(templateId, delegate
{
if (this.m_fxSpines.ContainsKey(uid))
{
this.JustPlaySpine(uid, templateId, host, uibase, depthValue, finishCallback, layer, xOffset, yOffset, xScale, yScale, stencilMask, maskState);
}
});
return(uid);
}
private void ResetAll()
{
this.RemoveListener();
this.JustSetEnableRenderer(true);
if (this._skeletonAnimation != null)
{
this._skeletonAnimation.Clear();
}
this._uid = 0;
this._dataSpine = null;
this._uibase = string.Empty;
this._depth = 0;
this._finishCallback = null;
this._isEnableRender = true;
}
private void JustPlaySpine(int uid, int templateId, Transform host, string uibase, int depthValue, Action finishCallback, string layer, float xOffset, float yOffset, float xScale, float yScale, bool stencilMask, FXMaskLayer.MaskState maskState = FXMaskLayer.MaskState.None)
{
FXSpine fXSpine = DataReader <FXSpine> .Get(templateId);
if (fXSpine == null || string.IsNullOrEmpty(fXSpine.name))
{
return;
}
if (host == null)
{
return;
}
ActorFXSpine actorFXSpine = FXSpinePool.Instance.Get(templateId);
if (actorFXSpine == null)
{
return;
}
actorFXSpine.get_transform().set_name(templateId.ToString());
if (maskState != FXMaskLayer.MaskState.None)
{
FXMaskLayer fXMaskLayer = actorFXSpine.get_gameObject().AddUniqueComponent <FXMaskLayer>();
fXMaskLayer.state = maskState;
}
this.m_fxSpines.set_Item(uid, actorFXSpine);
actorFXSpine.get_transform().set_parent(host);
actorFXSpine.get_transform().set_localPosition(new Vector3(xOffset, yOffset, 0f));
actorFXSpine.get_transform().set_localRotation(Quaternion.get_identity());
actorFXSpine.get_transform().set_localScale(new Vector3(xScale, yScale, 1f));
LayerSystem.SetGameObjectLayer(actorFXSpine.get_gameObject(), layer, 1);
DepthOfFX depthOfFX = actorFXSpine.get_gameObject().AddMissingComponent <DepthOfFX>();
depthOfFX.SortingOrder = depthValue;
actorFXSpine._uid = uid;
actorFXSpine._dataSpine = fXSpine;
actorFXSpine._uibase = uibase;
actorFXSpine._depth = depthValue;
actorFXSpine._stencilMask = stencilMask;
actorFXSpine._finishCallback = finishCallback;
actorFXSpine.AwakeSelf();
actorFXSpine.get_gameObject().SetActive(true);
actorFXSpine.PlaySpine();
this.DoSetShader(actorFXSpine, stencilMask, fXSpine);
this.PlaySound(fXSpine);
}
public void PreloadAsset(int templateId, Action action)
{
FXSpine fXSpine = DataReader <FXSpine> .Get(templateId);
if (fXSpine == null)
{
if (action != null)
{
action.Invoke();
}
return;
}
AssetManager.AssetOfSpineManager.LoadAssetWithPool(FileSystem.GetPathOfSpine(fXSpine.name), delegate(bool isSuccess)
{
if (action != null)
{
action.Invoke();
}
});
}
public static void Init()
{
if (ResourceRegulation.IsInit)
{
return;
}
ResourceRegulation.IsInit = true;
List <ReleaseResWhiteLists> dataList = DataReader <ReleaseResWhiteLists> .DataList;
for (int i = 0; i < dataList.get_Count(); i++)
{
int id = dataList.get_Item(i).id;
if (id >= 0 && id <= 1000)
{
string name = dataList.get_Item(i).name;
if (!string.IsNullOrEmpty(name))
{
ResourceRegulation.whitelist2uiatlas.Add(name.ToLower());
}
}
else if (id >= 1001 && id <= 2000)
{
string name2 = dataList.get_Item(i).name;
if (!string.IsNullOrEmpty(name2))
{
int key = int.Parse(GameDataUtils.SplitString4Dot0(name2));
FXSpine fXSpine = DataReader <FXSpine> .Get(key);
if (fXSpine != null)
{
ResourceRegulation.whitelist2spine.Add("UGUI/PrefabSpine2d/" + fXSpine.name);
}
}
}
else if (id >= 2001 && id <= 3000)
{
string name3 = dataList.get_Item(i).name;
if (!string.IsNullOrEmpty(name3))
{
int key2 = int.Parse(GameDataUtils.SplitString4Dot0(name3));
Fx fx = DataReader <Fx> .Get(key2);
if (fx != null && string.IsNullOrEmpty(fx.path))
{
ResourceRegulation.whitelist2common.Add(fx.path);
}
}
}
else if (id >= 3001 && id <= 4000)
{
string name4 = dataList.get_Item(i).name;
if (!string.IsNullOrEmpty(name4))
{
ResourceRegulation.whitelist2common.Add(FileSystem.GetPath(name4, string.Empty));
}
}
else if (id >= 4001 && id < 5000)
{
string name5 = dataList.get_Item(i).name;
if (!string.IsNullOrEmpty(name5))
{
int key3 = int.Parse(GameDataUtils.SplitString4Dot0(name5));
UINameTable uINameTable = DataReader <UINameTable> .Get(key3);
if (uINameTable != null)
{
string path = FileSystem.GetPath(uINameTable.name, string.Empty);
ResourceRegulation.whitelist2common.Add(path);
ResourceRegulation.temp_uilist.Add(path);
}
}
}
}
ResourceRegulation.Preload();
}
private void DoSetShader(ActorFXSpine actorSpine, bool stencilMask, FXSpine dataSpine)
{
if (actorSpine == null)
{
return;
}
using (Dictionary <int, ActorFXSpine> .ValueCollection.Enumerator enumerator = this.m_fxSpines.get_Values().GetEnumerator())
{
while (enumerator.MoveNext())
{
ActorFXSpine current = enumerator.get_Current();
if (!(current == null))
{
if (current._dataSpine != null && actorSpine._dataSpine != null)
{
if (current._uid != actorSpine._uid)
{
if (!(current.myRenderer == null) && !(actorSpine.myRenderer == null))
{
if (current.myRenderer.get_sharedMaterial() == null)
{
Debug.Log("tspine.myRenderer.sharedMaterial is null");
}
else if (!(current.myRenderer.get_sharedMaterial().get_mainTexture() == null))
{
if (current._dataSpine.id == actorSpine._dataSpine.id && current._stencilMask == actorSpine._stencilMask)
{
actorSpine.myRenderer.set_sharedMaterial(current.myRenderer.get_sharedMaterial());
return;
}
if (current._dataSpine.name == actorSpine._dataSpine.name && current._dataSpine.blendWay == actorSpine._dataSpine.blendWay && current._dataSpine.BrightnessRatio == actorSpine._dataSpine.BrightnessRatio && current._stencilMask == actorSpine._stencilMask && (current._dataSpine.blendWay != 0 || current._dataSpine.rgbEffect == actorSpine._dataSpine.rgbEffect))
{
actorSpine.myRenderer.set_sharedMaterial(current.myRenderer.get_sharedMaterial());
return;
}
}
}
}
}
}
}
}
Material material = actorSpine.GetComponent <MeshRenderer>().get_material();
Shader shader;
if (stencilMask)
{
if (dataSpine.blendWay == 0)
{
shader = ShaderManager.Find("Hsh(Mobile)/UI/UIStencilAlphaBlended");
}
else
{
shader = ShaderManager.Find("Hsh(Mobile)/UI/UIStencilAdd");
}
}
else
{
int blendWay = dataSpine.blendWay;
if (blendWay != 1)
{
if (blendWay != 2)
{
if (dataSpine.rgbEffect == 0)
{
shader = ShaderManager.Find("Hsh(Mobile)/UI/UISpineAlphaBlended");
}
else
{
shader = ShaderManager.Find("Hsh(Mobile)/FX/ParticleAlphaBlended");
}
}
else
{
shader = ShaderManager.Find("Particles/Additive");
}
}
else
{
shader = ShaderManager.Find("Hsh(Mobile)/UI/UISpineAdd");
}
}
material.set_shader(shader);
material.SetFloat(ShaderPIDManager._BrightnessRatio, dataSpine.BrightnessRatio);
}
