using System;
using System.IO;
using UnityEngine;

namespace XUtliPoolLib
{
	public sealed class ShaderManager : XSingleton<ShaderManager>
	{
		public static Shader _skin_effect
		{
			get
			{
				bool flag = ShaderManager.m_skin_effect == null;
				if (flag)
				{
					ShaderManager.m_skin_effect = XSingleton<ShaderManager>.singleton.FindShader("Skin-Effect", "Custom/Skin/Effect");
				}
				return ShaderManager.m_skin_effect;
			}
		}

		public static Shader _skin8
		{
			get
			{
				bool flag = ShaderManager.m_skin8 == null;
				if (flag)
				{
					ShaderManager.m_skin8 = XSingleton<ShaderManager>.singleton.FindShader("Skin-RimLightBlend8", "Custom/Skin/RimlightBlend8");
				}
				return ShaderManager.m_skin8;
			}
		}

		public static Shader _skin_blend
		{
			get
			{
				bool flag = ShaderManager.m_skin_blend == null;
				if (flag)
				{
					ShaderManager.m_skin_blend = XSingleton<ShaderManager>.singleton.FindShader("Skin-RimLightBlend", "Custom/Skin/RimlightBlend");
				}
				return ShaderManager.m_skin_blend;
			}
		}

		public static Shader _skin_cutout
		{
			get
			{
				bool flag = ShaderManager.m_skin_cutout == null;
				if (flag)
				{
					ShaderManager.m_skin_cutout = XSingleton<ShaderManager>.singleton.FindShader("Skin-RimLightBlendCutout", "Custom/Skin/RimlightBlendCutout");
				}
				return ShaderManager.m_skin_cutout;
			}
		}

		public static Shader _skin_cutout4
		{
			get
			{
				bool flag = ShaderManager.m_skin_cutout4 == null;
				if (flag)
				{
					ShaderManager.m_skin_cutout4 = XSingleton<ShaderManager>.singleton.FindShader("Skin-RimLightBlendCutout4", "Custom/Skin/RimlightBlendCutout4");
				}
				return ShaderManager.m_skin_cutout4;
			}
		}

		public static Shader _fade_maskR_noLight
		{
			get
			{
				bool flag = ShaderManager.m_fade_maskR_noLight == null;
				if (flag)
				{
					ShaderManager.m_fade_maskR_noLight = XSingleton<ShaderManager>.singleton.FindShader("FadeMaskRNoLight", "Custom/Common/FadeMaskRNoLight");
				}
				return ShaderManager.m_fade_maskR_noLight;
			}
		}

		public static Shader _transparentGrayMaskRNoLight
		{
			get
			{
				bool flag = ShaderManager.m_transparentGrayMaskRNoLight == null;
				if (flag)
				{
					ShaderManager.m_transparentGrayMaskRNoLight = XSingleton<ShaderManager>.singleton.FindShader("TransparentGrayMaskRNoLight", "Custom/Common/TransparentGrayMaskRNoLight");
				}
				return ShaderManager.m_transparentGrayMaskRNoLight;
			}
		}

		public static Shader _color
		{
			get
			{
				bool flag = ShaderManager.m_color == null;
				if (flag)
				{
					ShaderManager.m_color = Shader.Find("Custom/Effect/Color");
				}
				return ShaderManager.m_color;
			}
		}

		public static Shader _maskR
		{
			get
			{
				bool flag = ShaderManager.m_maskR == null;
				if (flag)
				{
					ShaderManager.m_maskR = XSingleton<ShaderManager>.singleton.FindShader("CustomShadowR", "Custom/Scene/CustomShadowR");
				}
				return ShaderManager.m_maskR;
			}
		}

		public static Shader _radialBlur
		{
			get
			{
				bool flag = ShaderManager.m_radialBlur == null;
				if (flag)
				{
					ShaderManager.m_radialBlur = XSingleton<ShaderManager>.singleton.FindShader("RadialBlur", "Hidden/radialBlur");
				}
				return ShaderManager.m_radialBlur;
			}
		}

		public static Shader _blackWhite
		{
			get
			{
				bool flag = ShaderManager.m_blackWhite == null;
				if (flag)
				{
					ShaderManager.m_blackWhite = XSingleton<ShaderManager>.singleton.FindShader("BlackWhite", "Hidden/blackWhite");
				}
				return ShaderManager.m_blackWhite;
			}
		}

		public static Shader _gausBlur
		{
			get
			{
				bool flag = ShaderManager.m_gausBlur == null;
				if (flag)
				{
					ShaderManager.m_gausBlur = XSingleton<ShaderManager>.singleton.FindShader("BlurEffectConeTaps", "Hidden/BlurEffectConeTap");
				}
				return ShaderManager.m_gausBlur;
			}
		}

		private static Shader m_skin_effect = null;

		private static Shader m_skin8 = null;

		private static Shader m_skin_blend = null;

		private static Shader m_skin_cutout = null;

		private static Shader m_skin_cutout4 = null;

		private static Shader m_fade_maskR_noLight = null;

		private static Shader m_transparentGrayMaskRNoLight = null;

		private static Shader m_color = null;

		private static Shader m_maskR = null;

		public static Shader _maskG;

		public static Shader _maskB;

		public static Shader _maskA;

		private static Shader m_radialBlur = null;

		private static Shader m_blackWhite = null;

		private static Shader m_gausBlur = null;

		private AssetBundle m_ShaderAB = null;

		public static int _ShaderKeyMainTex;

		public static int _ShaderKeyMaskTex;

		public static int _ShaderKeyIDColor0;

		public static int _ShaderKeyIDHairColor;

		public static int _ShaderKeyIDFace;

		public static int _ShaderKeyIDHair;

		public static int _ShaderKeyIDBody;

		public static int _ShaderKeyIDAlpha;

		public static int[] _ShaderKeyIDSkin = new int[8];

		public bool Awake(RuntimePlatform editorPlatform)
		{
			ShaderManager._ShaderKeyMainTex = Shader.PropertyToID("_MainTex");
			ShaderManager._ShaderKeyMaskTex = Shader.PropertyToID("_Mask");
			ShaderManager._ShaderKeyIDColor0 = Shader.PropertyToID("_Color");
			ShaderManager._ShaderKeyIDHairColor = Shader.PropertyToID("_HairColor");
			ShaderManager._ShaderKeyIDFace = Shader.PropertyToID("_Face");
			ShaderManager._ShaderKeyIDHair = Shader.PropertyToID("_Hair");
			ShaderManager._ShaderKeyIDBody = Shader.PropertyToID("_Body");
			ShaderManager._ShaderKeyIDAlpha = Shader.PropertyToID("_Alpha");
			for (int i = 0; i < ShaderManager._ShaderKeyIDSkin.Length; i++)
			{
				ShaderManager._ShaderKeyIDSkin[i] = Shader.PropertyToID("_Tex" + i.ToString());
			}
			string text = null;
			RuntimePlatform platform = Application.platform;
			if ((int) platform != 8)
			{
				if ((int)platform != 11)
				{
					if ((int)editorPlatform != 2)
					{
						if ((int)editorPlatform != 8)
						{
							if ((int)editorPlatform == 11)
							{
								text = string.Format("{0}/update/Android/AssetBundles/shaders.ab", Application.streamingAssetsPath);
							}
						}
						else
						{
							text = string.Format("{0}/update/iOS/AssetBundles/shaders.ab", Application.streamingAssetsPath);
						}
					}
					else
					{
						text = string.Format("{0}/update/AssetBundles/shaders.ab", Application.streamingAssetsPath);
					}
					bool flag = !File.Exists(text);
					if (flag)
					{
						text = null;
					}
				}
				else
				{
					text = string.Format("{0}!assets/update/Android/AssetBundles/shaders.ab", Application.dataPath);
				}
			}
			else
			{
				text = string.Format("{0}/Raw/update/iOS/AssetBundles/shaders.ab", Application.dataPath);
			}
			bool flag2 = !string.IsNullOrEmpty(text);
			if (flag2)
			{
				this.m_ShaderAB = AssetBundle.LoadFromFile(text);
			}
			return true;
		}

		public Shader FindShader(string name0, string name1)
		{
			Shader shader = null;
			bool flag = this.m_ShaderAB != null;
			if (flag)
			{
				shader = this.m_ShaderAB.LoadAsset<Shader>(name0);
			}
			bool flag2 = shader == null;
			if (flag2)
			{
				shader = Shader.Find(name1);
			}
			return shader;
		}

		public static void SetColor32(MaterialPropertyBlock mpb, Color32 color, int keyID)
		{
			mpb.SetColor(keyID, color);
		}

		public static void SetColor(MaterialPropertyBlock mpb, Color color, int keyID)
		{
			mpb.SetColor(keyID, color);
		}

		public static void SetTexture(MaterialPropertyBlock mpb, Texture tex, int keyID)
		{
			bool flag = tex != null;
			if (flag)
			{
				mpb.SetTexture(keyID, tex);
			}
		}

		public static void SetFloat(MaterialPropertyBlock mpb, float value, int keyID)
		{
			mpb.SetFloat(keyID, value);
		}
	}
}