public static void LoadIconTexture(MonoBehaviour mono_behaviour, RESOURCE_CATEGORY category, string name, Action load_start_callback, Action <Texture> loaded_callback)
{
ResourceObject cachedResourceObject = MonoBehaviourSingleton <ResourceManager> .I.cache.GetCachedResourceObject(category, name);
if (cachedResourceObject != null)
{
loaded_callback(cachedResourceObject.obj as Texture);
}
else
{
load_start_callback?.Invoke();
if (string.IsNullOrEmpty(name))
{
loaded_callback(null);
}
else if (ResourceDefine.types[(int)category] == ResourceManager.CATEGORY_TYPE.HASH256)
{
MonoBehaviourSingleton <ResourceManager> .I.Load(GetResourceLoad(mono_behaviour, true), category, category.ToHash256String(name), new string[1]
{
name
}, OnLoadIconTextureComplate, OnLoadIconTextureError, false, loaded_callback);
}
else
{
MonoBehaviourSingleton <ResourceManager> .I.Load(GetResourceLoad(mono_behaviour, true), category, name, OnLoadIconTextureComplate, OnLoadIconTextureError, false, loaded_callback);
}
}
}
public void CacheEffect(RESOURCE_CATEGORY category, string name)
{
if (!MonoBehaviourSingleton <InGameManager> .IsValid() || !MonoBehaviourSingleton <InGameManager> .I.IsDisableEffectGraphicLow(name))
{
LoadEffect(category, name, true);
}
}
public ResourceObject[] GetCachedResourceObjects(RESOURCE_CATEGORY category, string[] resource_names)
{
if (objectCaches == null)
{
return(null);
}
StringKeyTable <ResourceObject> stringKeyTable = objectCaches[(int)category];
if (stringKeyTable == null)
{
return(null);
}
ResourceObject[] array = new ResourceObject[resource_names.Length];
int i = 0;
for (int num = resource_names.Length; i < num; i++)
{
string res_name = resource_names[i];
array[i] = stringKeyTable.Get(res_name);
if (array[i] == null)
{
array[i] = systemCaches.Find((ResourceObject o) => o.obj.get_name() == res_name);
}
}
return(array);
}
public static ResourceObject Get(RESOURCE_CATEGORY category, string name, Object obj)
{
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Expected O, but got Unknown
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Expected O, but got Unknown
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Expected O, but got Unknown
ResourceObject resourceObject = rymTPool <ResourceObject> .Get();
resourceObject._refCount = 0;
resourceObject.category = category;
resourceObject.obj = obj;
resourceObject.name = name;
switch (resourceObject.category)
{
case RESOURCE_CATEGORY.EFFECT_TEX:
case RESOURCE_CATEGORY.PLAYER_HIGH_RESO_TEX:
case RESOURCE_CATEGORY.SOUND_VOICE:
willReleaseList.Add(resourceObject.obj);
break;
case RESOURCE_CATEGORY.PLAYER_ARM:
case RESOURCE_CATEGORY.PLAYER_BDY:
case RESOURCE_CATEGORY.PLAYER_FACE:
case RESOURCE_CATEGORY.PLAYER_HEAD:
case RESOURCE_CATEGORY.PLAYER_LEG:
case RESOURCE_CATEGORY.PLAYER_WEAPON:
{
GameObject val = resourceObject.obj as GameObject;
if (val != null)
{
Renderer componentInChildren = val.GetComponentInChildren <Renderer>();
willReleaseList.Add(componentInChildren.get_sharedMaterial().get_mainTexture());
if (componentInChildren is MeshRenderer)
{
MeshFilter component = componentInChildren.GetComponent <MeshFilter>();
if (component != null)
{
willReleaseList.Add(component.get_sharedMesh());
}
}
else if (componentInChildren is SkinnedMeshRenderer)
{
SkinnedMeshRenderer val2 = componentInChildren as SkinnedMeshRenderer;
willReleaseList.Add(val2.get_sharedMesh());
}
}
break;
}
}
if (willReleaseList.Count > 0)
{
resourceObject.willReleaseObjs = willReleaseList.ToArray();
willReleaseList.Clear();
}
return(resourceObject);
}
public LoadAndInstantiateObject(MonoBehaviour mono_behaviour, RESOURCE_CATEGORY category, string resource_name)
{
Load(mono_behaviour, category, resource_name, false);
if (MonoBehaviourSingleton <InstantiateManager> .IsValid() && !base.isLoading && loadedObject != null)
{
base.isLoading = true;
InstantiateManager.Request(resLoad, loadedObject, OnInstantiate, true);
}
}
public LoadAndInstantiateObject LoadAndInstantiate(RESOURCE_CATEGORY category, string resource_name)
{
LoadAndInstantiateObject loadAndInstantiateObject = new LoadAndInstantiateObject(monoBehaviour, category, resource_name);
if (loadAndInstantiateObject.isLoading)
{
loadQueue.Enqueue(loadAndInstantiateObject);
}
return(loadAndInstantiateObject);
}
public LoadObject Load(RESOURCE_CATEGORY category, string package_name, string[] resource_names, bool cache_package = false)
{
LoadObject loadObject = new LoadObject(monoBehaviour, category, package_name, resource_names, cache_package);
if (loadObject.isLoading)
{
loadQueue.Enqueue(loadObject);
}
return(loadObject);
}
private IEnumerator LoadObject(RESOURCE_CATEGORY category, string resource_name)
{
loadObject = null;
loadError = false;
MonoBehaviourSingleton <ResourceManager> .I.Load(this, category, resource_name, OnLoadComplate, OnLoadError, false, null);
while (loadObject == null && !loadError)
{
yield return((object)0);
}
}
public static void LoadWithSetUITexture(UITexture ui_tex, RESOURCE_CATEGORY category, string name)
{
LoadIconTexture(ui_tex, category, name, delegate
{
ui_tex.mainTexture = null;
}, delegate(Texture tex)
{
if (ui_tex != null)
{
ui_tex.mainTexture = tex;
}
});
}
private int FindStockRequestIndex(RESOURCE_CATEGORY category, string name, int hash_code)
{
int i = 0;
for (int size = requests.size; i < size; i++)
{
StockData stockData = requests.buffer[i].stockData;
if (stockData != null && stockData.hashCode == hash_code && stockData.category == category && stockData.name == name)
{
return(i);
}
}
return(-1);
}
private int FindStockIndex(RESOURCE_CATEGORY category, string name, int hash_code)
{
for (int num = stocks.size - 1; num >= 0; num--)
{
StockData stockData = stocks.buffer[num];
if (stockData.hashCode == hash_code && stockData.category == category && stockData.name == name)
{
if (stockData.instantiatedObject != null)
{
return(num);
}
RemoveStockAt(num, false);
}
}
return(-1);
}
public ResourceObject GetCachedResourceObject(RESOURCE_CATEGORY category, string resource_name)
{
if (objectCaches == null)
{
return(null);
}
StringKeyTable <ResourceObject> stringKeyTable = objectCaches[(int)category];
if (stringKeyTable == null)
{
return(null);
}
ResourceObject resourceObject = stringKeyTable.Get(resource_name);
if (resourceObject == null)
{
resourceObject = systemCaches.Find((ResourceObject o) => o.obj.get_name() == resource_name);
}
return(resourceObject);
}
public LoadObject LoadEffect(RESOURCE_CATEGORY category, string name, bool check_cache = false)
{
if (string.IsNullOrEmpty(name))
{
return(null);
}
name = ResourceName.AddAttributID(name);
if (check_cache)
{
ResourceObject cachedResourceObject = MonoBehaviourSingleton <ResourceManager> .I.cache.GetCachedResourceObject(category, name);
if (cachedResourceObject != null)
{
ResourceLoad resourceLoad = ResourceLoad.GetResourceLoad(monoBehaviour, false);
resourceLoad.SetReference(cachedResourceObject);
return(null);
}
}
return(Load(category, name, false));
}
public ResourceObject GetCachedResourceObject(RESOURCE_CATEGORY category, string package_name, string resource_name, bool inc_ref_count)
{
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Expected O, but got Unknown
ResourceObject resourceObject = GetCachedResourceObject(category, resource_name);
if (resourceObject == null && objectCaches != null)
{
PackageObject cachedPackage = GetCachedPackage(package_name);
if (cachedPackage != null)
{
if (!ResourceManager.enableLoadDirect)
{
if (ResourceManager.isDownloadAssets)
{
if (cachedPackage.obj is AssetBundle)
{
resourceObject = ResourceObject.Get(category, resource_name, (cachedPackage.obj as AssetBundle).LoadAsset(resource_name));
}
}
else
{
bool enableLoadDirect = ResourceManager.enableLoadDirect;
ResourceManager.enableLoadDirect = true;
resourceObject = ResourceObject.Get(category, resource_name, ResourceManager.LoadDirect(category, package_name, resource_name));
ResourceManager.enableLoadDirect = enableLoadDirect;
}
}
else
{
resourceObject = ResourceObject.Get(category, resource_name, ResourceManager.LoadDirect(category, package_name, resource_name));
}
}
}
if (resourceObject == null)
{
resourceObject = systemCaches.Find((ResourceObject o) => o.obj.get_name() == resource_name);
}
return(resourceObject);
}
private void AddLoadInfoList(List <LoadInfo> list, List <PredownloadTable.Data> datas)
{
if (datas != null)
{
Type typeFromHandle = typeof(RESOURCE_CATEGORY);
int i = 0;
for (int count = datas.Count; i < count; i++)
{
PredownloadTable.Data data = datas[i];
RESOURCE_CATEGORY category = (RESOURCE_CATEGORY)(int)Enum.Parse(typeFromHandle, data.categoryName);
int j = 0;
for (int count2 = data.packages.Count; j < count2; j++)
{
PredownloadTable.Package package = data.packages[j];
if (package != null && !string.IsNullOrEmpty(package.packageName))
{
List <string> resourceNames = package.resourceNames;
if (package.packageName == null || !package.packageName.StartsWith("Debug"))
{
resourceNames = new List <string>();
int k = 0;
for (int count3 = package.resourceNames.Count; k < count3; k++)
{
if (!package.resourceNames[k].StartsWith("Debug"))
{
resourceNames.Add(package.resourceNames[k]);
}
}
LoadInfo loadInfo = new LoadInfo();
loadInfo.category = category;
loadInfo.pakageName = package.packageName;
loadInfo.resourceNames = resourceNames.ToArray();
list.Add(loadInfo);
}
}
}
}
}
}
public static string ToAssetBundleName(this RESOURCE_CATEGORY category, string package_name = null)
{
string text = category.ToString();
if (ResourceDefine.types[(int)category] != ResourceManager.CATEGORY_TYPE.PACK)
{
text = text + "/" + package_name;
}
if (category == RESOURCE_CATEGORY.UI_ATLAS)
{
if (!text.EndsWith("_bundle"))
{
text += "_bundle";
}
text = text + ResourceDefine.suffix[(int)category] + GoGameResourceManager.GetDefaultAssetBundleExtension();
}
else
{
text = text + ResourceDefine.suffix[(int)category] + GoGameResourceManager.GetDefaultAssetBundleExtension();
}
return(text.ToLower());
}
public static void RequestStock(RESOURCE_CATEGORY category, Object original_object, string name, bool is_one)
{
if (MonoBehaviourSingleton <InstantiateManager> .IsValid() && !(original_object == null))
{
int hashCode = name.GetHashCode();
if (!is_one || (MonoBehaviourSingleton <InstantiateManager> .I.FindStockRequestIndex(category, name, hashCode) == -1 && MonoBehaviourSingleton <InstantiateManager> .I.FindStockIndex(category, name, hashCode) == -1))
{
InstantiateData instantiateData = rymTPool <InstantiateData> .Get();
instantiateData.master = MonoBehaviourSingleton <InstantiateManager> .I;
instantiateData.callback = MonoBehaviourSingleton <InstantiateManager> .I.Stock;
instantiateData.originalObject = original_object;
instantiateData.isInactivateInstantiatedObject = true;
instantiateData.stockData = rymTPool <StockData> .Get();
instantiateData.stockData.hashCode = name.GetHashCode();
instantiateData.stockData.category = category;
instantiateData.stockData.name = name;
Request(instantiateData);
}
}
}
public void Load(MonoBehaviour mono_behaviour, RESOURCE_CATEGORY category, string package_name, string[] resource_names, bool cache_package = false)
{
isLoading = false;
if (resource_names != null && resource_names.Length >= 1)
{
loadedObjects = MonoBehaviourSingleton <ResourceManager> .I.cache.GetCachedResourceObjects(category, resource_names);
if (loadedObjects != null)
{
if (loadedObjects[0] != null)
{
loadedObject = loadedObjects[0].obj;
}
int i = 0;
for (int num = loadedObjects.Length; i < num; i++)
{
if (loadedObjects[i] == null)
{
loadedObjects = null;
break;
}
}
}
}
if (resLoad == null)
{
resLoad = ResourceLoad.GetResourceLoad(mono_behaviour, false);
}
if (loadedObjects == null)
{
isLoading = true;
MonoBehaviourSingleton <ResourceManager> .I.Load(resLoad, category, package_name, resource_names, OnLoadComplate, OnLoadError, cache_package, null);
}
else
{
resLoad.SetReference(loadedObjects);
}
}
public void Load(MonoBehaviour mono_behaviour, RESOURCE_CATEGORY category, string resource_name, bool cache_package)
{
isLoading = false;
if (!string.IsNullOrEmpty(resource_name))
{
if (resLoad == null)
{
resLoad = ResourceLoad.GetResourceLoad(mono_behaviour, false);
}
ResourceObject cachedResourceObject = MonoBehaviourSingleton <ResourceManager> .I.cache.GetCachedResourceObject(category, resource_name);
if (cachedResourceObject != null)
{
loadedObject = cachedResourceObject.obj;
resLoad.SetReference(cachedResourceObject);
}
if (loadedObject == null)
{
isLoading = true;
MonoBehaviourSingleton <ResourceManager> .I.Load(resLoad, category, resource_name, OnLoadComplate, OnLoadError, cache_package, null);
}
}
}
public static Object FindStock(RESOURCE_CATEGORY category, string name)
{
if (!MonoBehaviourSingleton <InstantiateManager> .IsValid())
{
return(null);
}
int num = MonoBehaviourSingleton <InstantiateManager> .I.FindStockIndex(category, name);
if (num == -1)
{
return(null);
}
StockData stockData = MonoBehaviourSingleton <InstantiateManager> .I.stocks.buffer[num];
Object instantiatedObject = stockData.instantiatedObject;
Object originalObject = stockData.originalObject;
MonoBehaviourSingleton <InstantiateManager> .I.RemoveStockAt(num, false);
if ((category == RESOURCE_CATEGORY.EFFECT_ACTION || category == RESOURCE_CATEGORY.EFFECT_UI) && originalObject != null)
{
RequestStock(category, originalObject, name, false);
}
return(instantiatedObject);
}
private static AudioClip GetAudioClip(RESOURCE_CATEGORY category, string package_name, string name)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Expected O, but got Unknown
return(MonoBehaviourSingleton <ResourceManager> .I.cache.GetCachedObject(category, package_name, name));
}
public static string ToHash256String(this RESOURCE_CATEGORY category, byte hash)
{
return($"{category.ToString()}_{hash:X2}");
}
public ResourceInfo(RESOURCE_CATEGORY category, string packageName)
{
this.category = category;
this.packageName = packageName;
}
public LoadObject(MonoBehaviour mono_behaviour, RESOURCE_CATEGORY category, string package_name, string[] resource_names, bool cache_package = false)
{
Load(mono_behaviour, category, package_name, resource_names, cache_package);
}
public static string ToHash256String(this RESOURCE_CATEGORY category, string name)
{
return($"{category.ToString()}_{(byte)Utility.GetHash(name):X2}");
}
private int FindStockRequestIndex(RESOURCE_CATEGORY category, string name)
{
return(FindStockRequestIndex(category, name, name.GetHashCode()));
}
public Object GetCachedObject(RESOURCE_CATEGORY category, string package_name, string resource_name)
{
return(GetCachedResourceObject(category, package_name, resource_name, false)?.obj);
}
private static Transform GetEffect(RESOURCE_CATEGORY category, string effect_name, Transform parent = null, int layer = -1, bool enable_stock = false)
{
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Expected O, but got Unknown
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Expected O, but got Unknown
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Expected O, but got Unknown
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Expected O, but got Unknown
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Expected O, but got Unknown
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Expected O, but got Unknown
if (string.IsNullOrEmpty(effect_name))
{
return(null);
}
if (MonoBehaviourSingleton <EffectManager> .IsValid())
{
EffectManager i = MonoBehaviourSingleton <EffectManager> .I;
effect_name = ResourceName.AddAttributID(effect_name);
if (MonoBehaviourSingleton <ResourceManager> .IsValid())
{
if (parent == null)
{
parent = i._transform;
}
GameObject val = null;
GameObject inactive_inctance = null;
Transform val2 = null;
bool flag = i.enableStock && enable_stock;
if (flag)
{
Transform val3 = i.stockParent.FindChild(effect_name);
if (val3 != null)
{
val3.GetComponent <EffectStock>().Recycle(parent, layer);
return(val3);
}
}
inactive_inctance = InstantiateManager.FindStock(category, effect_name);
if (inactive_inctance != null)
{
val2 = InstantiateManager.Realizes(ref inactive_inctance, parent, layer);
inactive_inctance = val2.get_gameObject();
}
else
{
val = ((!ResourceManager.enableLoadDirect) ? MonoBehaviourSingleton <ResourceManager> .I.cache.GetCachedObject(category, effect_name) : MonoBehaviourSingleton <ResourceManager> .I.LoadDirect(category, effect_name));
if (val != null)
{
val2 = ResourceUtility.Realizes(val, parent, layer);
inactive_inctance = val2.get_gameObject();
}
}
if (inactive_inctance != null)
{
if (flag)
{
inactive_inctance.AddComponent <EffectStock>();
}
return(val2);
}
}
}
return(null);
}
