using System;
using System.Collections.Generic;

using UnityEngine;

public class GameObjectKeyName
{
	public static readonly string Level = "level";
	public static readonly string LevelLiving = "level_living";
	public static readonly string LevelDead = "level_dead";

	//
	public static readonly string FadeOut = "FadeOut";

	//
	public static readonly string LOD = "LOD_";

	public static readonly string LOD_HEIGHT = "LOD_H";
	public static readonly string LOD_LOW = "LOD_L";

	//
	public static readonly string BODY_LOW = "BodyLow";
}

public static class UnityComponentList<T>
		where T : Component
{
	public static int Count
	{ get { return _list.Count; } }

	public static List<T> List
	{ get { return _list; } }

	public static void Begin(GameObject obj)
	{
		Begin(obj, false);
	}

	public static void Begin(GameObject obj, bool includeInactive)
	{
		_list.Clear();
		if (obj != null)
		{
			obj.GetComponentsInChildren<T>(includeInactive, _list);
		}
	}

	public static void End()
	{
		_list.Clear();
	}

	private static List<T> _list = new List<T>();
}

public static class UnityAssisstant
{
	public static readonly string GROUP_PRO = "pro";
	public static readonly string GROUP_VIB = "vib";
	public static readonly string GROUP_RES = "pro";
	public static readonly string GROUP_BUNDLE = "bundle";
	public static readonly string GROUP_PATCH = "patch";

	public static Quaternion CameraRotation = Quaternion.identity;
	public static float CameraYaw = 0.0f;

	public static void SetActive(GameObject obj, bool value)
	{
		if (obj != null)
		{
			obj.SetActive(value);
		}
	}

	public static void Dispose<T>(ref T obj) where T : IDisposable
	{
		if (obj == null)
		{
			return;
		}
		obj.Dispose();
		obj = default; // 这里和null本质上没有区别
	}

	public static void DelayDispose<T>(float delay, ref T obj) where T : IDisposable
	{
		if (obj == null)
		{
			return;
		}
		var tempObj = obj;
		obj = default;
		// 这里计时器不需要持有，因为tempObj就算被其他地方销毁了，也不会报错
		ViTimerInstance.SetTime(new ViTimeNode1(), delay, node => Dispose(ref tempObj));
	}
	//
	public static void Dispose<T>(ref List<T> list) where T : IDisposable
	{
		if (list == null)
		{
			return;
		}
		//
		foreach (var obj in list)
		{
			obj.Dispose();
		}
		list.Clear();
	}
	//
	public static void Dispose<T1,T2>(ref Dictionary<T1,T2> dictionary) where T2 : IDisposable
	{
		if (dictionary == null)
		{
			return;
		}
		//
		foreach (var obj in dictionary.Values)
		{
			obj.Dispose();
		}
		dictionary.Clear();
	}
	//
	public static void Dispose<T1,T2>(ref Dictionary<T1, List<T2>> dictionary) where T2 : IDisposable
	{
		if (dictionary == null)
		{
			return;
		}
		//
		foreach (var obj in dictionary.Values)
		{
			var list = obj;
			Dispose(ref list);
		}
		dictionary.Clear();
	}

	public static void Destroy<T>(ref T obj) where T : UnityEngine.Object
	{
		if (obj == null)
		{
			return;
		}
		UnityEngine.GameObject gameObj = obj as UnityEngine.GameObject;
		if (gameObj != null)
		{
			gameObj.SetActive(false);
			gameObj.transform.parent = null;
		}
		UnityEngine.Object.Destroy(obj);
		obj = null;
	}

	public static void Destroy(ref UnityEngine.GameObject obj)
	{
		if (obj == null)
		{
			return;
		}
		obj.transform.SetParent(null);
		obj.SetActive(false);
		UnityEngine.Object.Destroy(obj);
		obj = null;
	}

	public static void Destroy(List<UnityEngine.Object> objList)
	{
		if (objList == null)
		{
			return;
		}
		for (int iter = 0; iter < objList.Count; ++iter)
		{
			UnityEngine.Object iterObj = objList[iter];
			Destroy(ref iterObj);
		}
		objList.Clear();
	}


	public static void Destroy(List<UnityEngine.GameObject> objList)
	{
		if (objList == null)
		{
			return;
		}
		for (int iter = 0; iter < objList.Count; ++iter)
		{
			UnityEngine.GameObject iterObj = objList[iter];
			Destroy(ref iterObj);
		}
		objList.Clear();
	}

	
	/*
	public static GameObject InstantiateScene(GameObject gameObj)
	{
		GameObject newObj = UnityEngine.Object.Instantiate(gameObj);
		newObj.transform.localPosition = Vector3.zero;
		newObj.transform.localRotation = Quaternion.identity;
		newObj.transform.localScale = Vector3.one;
		newObj.SetActive(true);
		if (Application.isEditor)
		{
			SceneConfig sceneConfig = newObj.GetComponent<SceneConfig>();
			if (sceneConfig.Skybox != null)
			{
				Int32 renderQueue = sceneConfig.Skybox.renderQueue;
				Shader shader = Shader.Find(sceneConfig.Skybox.shader.name);
				if (shader != null)
				{
					sceneConfig.Skybox.shader = shader;
					//sceneConfig.Skybox.renderQueue = renderQueue;
				}
			}
			//
			ReplaceMaterialShader(newObj);
		}
		return newObj;
	}
	*/

	public static GameObject Instantiate(GameObject gameObj, Vector3 position, Quaternion rotation)
	{
		if (gameObj == null)
		{
			return null;
		}

		GameObject newObj = UnityEngine.Object.Instantiate(gameObj, position, rotation) as GameObject;
		newObj.SetActive(true);
		if (Application.isEditor)
		{
			ReplaceMaterialShader(newObj);
		}
		return newObj;
	}

	public static GameObject Instantiate(GameObject gameObj)
	{
		if (gameObj == null)
		{
			return null;
		}

		GameObject newObj = UnityEngine.Object.Instantiate(gameObj);
		newObj.SetActive(true);
		if (Application.isEditor)
		{
			ReplaceMaterialShader(newObj);
		}
		return newObj;
	}

	public static GameObject InstantiateAsChild(GameObject gameObj, Transform tran, bool worldPosStays)
	{
		if (gameObj == null)
		{
			return null;
		}

		return InstantiateAsChild(gameObj, tran, Vector3.zero, true, worldPosStays);
	}

	public static GameObject InstantiateAsChild(GameObject gameObj, Transform tran)
	{
		if (gameObj == null)
		{
			return null;
		}

		return InstantiateAsChild(gameObj, tran, Vector3.zero, true);
	}

	public static GameObject InstantiateAsChild(GameObject gameObj, Transform tran, Vector3 offset, bool inheritScale, bool worldPosStays = true)
	{
		if (gameObj == null)
		{
			return null;
		}

		Vector3 position = Vector3.zero;
		Quaternion rotation = Quaternion.identity;
		if (tran != null)
		{
			position = tran.position + offset;
			rotation = tran.rotation;
		}
		GameObject newObj = UnityEngine.Object.Instantiate(gameObj, position, rotation) as GameObject;
		if (!inheritScale)
		{
			newObj.transform.localScale = Vector3.one;
		}
		newObj.SetActive(true);
		if (tran != null)
		{
			newObj.transform.SetParent(tran, worldPosStays);
		}
		if (inheritScale)
		{
			newObj.transform.localScale = Vector3.one;
		}
		if (Application.isEditor)
		{
			ReplaceMaterialShader(newObj);
		}
		return newObj;
	}

	public static void SetLossyScale(Transform tran, float value)
	{
		Transform parent = tran.parent;
		Vector3 scale = Vector3.one * value;
		if (parent != null)
		{
			Vector3 parentScale = parent.lossyScale;
			scale.x /= parentScale.x;
			scale.y /= parentScale.y;
			scale.z /= parentScale.z;
		}
		tran.localScale = scale;
	}

	public static void SetStaticRecursively(UnityEngine.GameObject obj, bool value)
	{
		_SetStaticRecursively(obj, value);
	}

	private static void _SetStaticRecursively(UnityEngine.GameObject obj, bool value)
	{
		obj.isStatic = value;
		for (int iter = 0; iter < obj.transform.childCount; ++iter)
		{
			Transform iterTran = obj.transform.GetChild(iter);
			_SetStaticRecursively(iterTran.gameObject, value);
		}
	}

	public static void SetLayerRecursively(UnityEngine.GameObject obj, int value)
	{
		_SeLayerRecursively(obj, value);
	}

	private static void _SeLayerRecursively(UnityEngine.GameObject obj, int value)
	{
		obj.layer = value;
		for (int iter = 0; iter < obj.transform.childCount; ++iter)
		{
			Transform iterTran = obj.transform.GetChild(iter);
			_SeLayerRecursively(iterTran.gameObject, value);
		}
	}

	public static Transform GetChildRecursively(this Transform root, string name)
	{
		return GetChildRecursively(root, name, null);
	}

	public static Transform GetChildRecursively(this Transform root, string name, Transform defaultTranform)
	{
		Transform tran = _GetChildRecursively(root, name, false);
		if (tran == null)
		{
			tran = _GetChildRecursively(root, name, true);
		}
		if (tran == null)
		{
			tran = defaultTranform;
		}
		return tran;
	}

	private static Transform _GetChildRecursively(Transform root, string name, bool ignoreDeactive)
	{
		if (!ignoreDeactive && !root.gameObject.activeSelf)
		{
			return null;
		}
		if (root.gameObject.name == name)
		{
			return root;
		}
		for (int iter = 0; iter < root.childCount; ++iter)
		{
			Transform iterTran = root.GetChild(iter);
			Transform iterTarget = _GetChildRecursively(iterTran, name, ignoreDeactive);
			if (iterTarget != null)
			{
				return iterTarget;
			}
		}
		return null;
	}

	public static string GetTranFullHierarchy(GameObject go)
	{
		if (go == null)
		{
			return string.Empty;
		}
		Transform current = go.transform;
		string path = current.name;
		while (current.parent != null)
		{
			current = current.parent;
			path = current.name + "/" + path;
		}
		return path;
	}

	public static void GetChildren(this GameObject parent, string name, List<GameObject> objList)
	{
		for (int iter = 0; iter < parent.transform.childCount; ++iter)
		{
			GameObject iterObject = parent.transform.GetChild(iter).gameObject;
			if (iterObject.name == name)
			{
				objList.Add(iterObject);
			}
		}
	}

	public static GameObject GetChild(this GameObject parent, string name)
	{
		Transform childTransform = parent.transform.Find(name);
		if (childTransform != null)
		{
			return childTransform.gameObject;
		}
		else
		{
			return null;
		}
	}

	public static void SetChildStateRecursively(Transform root, string name, bool value)
	{
		Transform child = GetChildRecursively(root, name, null);
		if (child != null)
		{
			child.gameObject.SetActive(value);
		}
	}

	public static void UpdateSoundVolume(GameObject obj, float volume)
	{
		if (obj == null)
		{
			return;
		}
		//
		UnityComponentList<AudioSource>.Begin(obj);
		for (int iter = 0; iter < UnityComponentList<AudioSource>.List.Count; ++iter)
		{
			AudioSource iterComponent = UnityComponentList<AudioSource>.List[iter];
			iterComponent.volume = volume;
		}
		UnityComponentList<AudioSource>.End();
	}

	public static void SetSoundLoop(GameObject obj, bool value)
	{
		if (obj == null)
		{
			return;
		}
		//
		UnityComponentList<AudioSource>.Begin(obj);
		for (int iter = 0; iter < UnityComponentList<AudioSource>.List.Count; ++iter)
		{
			AudioSource iterComponent = UnityComponentList<AudioSource>.List[iter];
			iterComponent.loop = value;
		}
		UnityComponentList<AudioSource>.End();
	}

	public static T GetChildComponent<T>(GameObject parent, string name) where T : Component
	{
		Transform childTransform = parent.transform.Find(name);
		if (childTransform != null)
		{
			return childTransform.gameObject.GetComponent<T>();
		}
		else
		{
			return null;
		}
	}

	public static T GetComponentRecursively<T>(GameObject obj)
		where T : Component
	{
		if (obj == null)
		{
			return null;
		}
		T component = obj.GetComponent<T>();
		if (component != null)
		{
			return component;
		}
		return obj.GetComponentInChildren<T>();
	}

	public static void GetComponentRecursively<T>(GameObject obj, List<T> list)
		where T : Component
	{
		list.Clear();
		if (obj == null)
		{
			return;
		}
		obj.GetComponentsInChildren<T>(list);
		//T component = obj.GetComponent<T>();
		//if (component != null)
		//{
		//    list.Add(component);
		//}
	}

	public static Animation GetAvatarAnimation(GameObject obj)
	{
		if (obj == null)
		{
			return null;
		}
		Animation animation = obj.GetComponentInChildren<Animation>();
		if (animation != null)
		{
			return animation;
		}
		//UnityComponentList<Animation>.Begin()
		//Animation[] animationList = obj.GetComponentsInChildren<Animation>();
		//for (int iter = 0; iter < animationList.Length; ++iter)
		//{
		//    Animation iterAnim = animationList[iter];
		//    if (iterAnim["Idle"] != null)
		//    {
		//        return iterAnim;
		//    }
		//}
		//if (animationList.Length > 0)
		//{
		//    return animationList[0];
		//}
		return null;
	}

	public static void JionTransform(Transform parent, Transform child)
	{
		Quaternion oldQuat = child.transform.localRotation;
		if (parent != null)
		{
			child.parent = parent;
		}
		child.localPosition = Vector3.zero;
		child.localRotation = oldQuat;
	}

	public static void JionTransform(GameObject parent, GameObject child)
	{
		Quaternion oldQuat = child.transform.localRotation;
		if (parent != null)
		{
			child.transform.parent = parent.transform;
		}
		child.transform.localPosition = Vector3.zero;
		child.transform.localRotation = oldQuat;
	}

	public static void JionTransform(Transform parent, Transform child, Vector3 offset, Quaternion rot)
	{
		if (parent != null)
		{
			child.parent = parent;
		}
		child.localPosition = offset;
		child.localRotation = rot;
	}

	public static void JionTransform(GameObject parent, GameObject child, Vector3 offset, Quaternion rot)
	{
		if (parent != null)
		{
			child.transform.parent = parent.transform;
		}
		child.transform.localPosition = offset;
		child.transform.localRotation = rot;
	}

	public static void SetScale(GameObject obj, float scale)
	{
		SetScale(obj, new Vector3(scale, scale, scale));
	}

	public static void SetScale(GameObject obj, Vector3 scale)
	{
		if (obj != null)
		{
			obj.transform.localScale = scale;
			Transform parent = obj.transform.parent;
			if (parent != null)
			{
				Vector3 parentScale = parent.lossyScale;
				scale.x /= parentScale.x;
				scale.y /= parentScale.y;
				scale.z /= parentScale.z;
				obj.transform.localScale = scale;
			}
			else
			{
				obj.transform.localScale = scale;
			}
		}
	}

	public static GameObject CreateChild(Transform root, string name, bool force)
	{
		Transform child = root.Find(name);
		if (child != null && !force)
		{
			return child.gameObject;
		}
		GameObject newObj = new GameObject(name);
		JionTransform(root, newObj.transform);
		return newObj;
	}

	public static T CreateComponent<T>(GameObject obj) where T : Component
	{
		T component = obj.GetComponent<T>();
		if (component == null)
		{
			component = obj.AddComponent<T>();
		}
		return component;
	}

	public static void DelComponent<T>(GameObject obj) where T : Component
	{
		T component = obj.GetComponent<T>();
		if (component != null)
		{
			UnityEngine.Object.Destroy(component);
		}
	}

	public static void SetComponentState<T>(GameObject obj, bool active) where T : Behaviour
	{
		T component = obj.GetComponent<T>();
		if (component != null)
		{
			component.enabled = active;
		}
	}

	public static void SetComponentsState<T>(GameObject obj, bool active) where T : Behaviour
	{
		UnityComponentList<T>.Begin(obj, true);
		for (int iter = 0; iter < UnityComponentList<T>.Count; ++iter)
		{
			T iterComponent = UnityComponentList<T>.List[iter];
			iterComponent.enabled = active;
		}
		UnityComponentList<T>.End();
	}

	#region UI

	public static Vector3 WorldToNGUIPixel(Camera camera, Vector3 pos)
	{
		Vector3 screenPos = camera.WorldToScreenPoint(pos);
		float x = screenPos.x - Screen.width * 0.5f;
		float y = screenPos.y - Screen.height * 0.5f;
		return new Vector3(x, y, 0.0f);
	}

	public static Vector3 WorldToNGUIScale(Camera camera, Vector3 pos)
	{
		Vector3 screenPos = camera.WorldToScreenPoint(pos);
		float horizScale = (float)Screen.width / (float)Screen.height;
		float x = (1.0f + (screenPos.x - Screen.width) / Screen.width * 2) * horizScale;
		float y = 1.0f + (screenPos.y - Screen.height) / Screen.height * 2;
		return new Vector3(x, y, 0.0f);
	}

	public static Vector3 ScreenToNGUIScale(Vector3 screenPos)
	{
		float horizScale = (float)Screen.width / (float)Screen.height;
		float x = (1.0f + (screenPos.x - Screen.width) / Screen.width * 2) * horizScale;
		float y = 1.0f + (screenPos.y - Screen.height) / Screen.height * 2;
		return new Vector3(x, y, 0.0f);
	}

	#endregion UI

	#region Gree&Angle

	public static float Translate360To2Pi(float value)
	{
		return (180.0f - value) * 3.14f / 180.0f;
	}

	public static float Translate2PiTo360(float value)
	{
		return 180.0f - value / 3.14f * 180.0f;
	}

	#endregion Gree&Angle

	//public static void SetColor(Renderer renderer, Color color)
	//{
	//    Material[] materials = renderer.materials;
	//    for (int iter = 0; iter < materials.Length; ++iter)
	//    {
	//        Material material = materials[iter];
	//        material.color = color;
	//    }
	//}

	#region Color

	public static void SetColor(Renderer renderer, Color color, Dictionary<Int32, Color> oldColors)
	{
		Material[] materials = renderer.materials;
		for (int iter = 0; iter < materials.Length; ++iter)
		{
			Material material = materials[iter];
			if (!material.HasProperty("_Color"))
			{
				continue;
			}
			if (oldColors != null)
			{
				oldColors[material.GetInstanceID()] = material.color;
			}
			material.color = color;
		}
	}

	public static void SetColor(List<Renderer> renderers, Color color, Dictionary<Int32, Color> oldColors)
	{
		for (int iter = 0; iter < renderers.Count; ++iter)
		{
			SetColor(renderers[iter], color, oldColors);
		}
	}

	public static void SetColor(Renderer renderer, Dictionary<Int32, Color> colors)
	{
		Material[] materials = renderer.materials;
		for (int iter = 0; iter < materials.Length; ++iter)
		{
			Material material = materials[iter];
			if (!material.HasProperty("_Color"))
			{
				continue;
			}
			Color color;
			if (colors.TryGetValue(material.GetInstanceID(), out color))
			{
				material.color = color;
			}
		}
	}

	public static void SetColor(List<Renderer> renderers, Dictionary<Int32, Color> colors)
	{
		for (int iter = 0; iter < renderers.Count; ++iter)
		{
			SetColor(renderers[iter], colors);
		}
	}

	public static void SetColor(GameObject obj, Color color)
	{
		UnityComponentList<Renderer>.Begin(obj);
		SetColor(UnityComponentList<Renderer>.List, null);
		UnityComponentList<Renderer>.End();
	}

	public static void SetColor(GameObject obj, Color color, Dictionary<Int32, Color> oldColors)
	{
		UnityComponentList<Renderer>.Begin(obj);
		SetColor(UnityComponentList<Renderer>.List, color, oldColors);
		UnityComponentList<Renderer>.End();
	}

	public static void SetColor(GameObject obj, Dictionary<Int32, Color> colors)
	{
		UnityComponentList<Renderer>.Begin(obj);
		SetColor(UnityComponentList<Renderer>.List, colors);
		UnityComponentList<Renderer>.End();
	}

	#endregion Color

	public static void Rewind(GameObject obj)
	{
		UnityComponentList<Animation>.Begin(obj);
		for (int iter = 0; iter < UnityComponentList<Animation>.List.Count; ++iter)
		{
			Animation iterComponent = UnityComponentList<Animation>.List[iter];
			iterComponent.Rewind();
		}
		UnityComponentList<Animation>.End();
		//
		UnityComponentList<Animator>.Begin(obj);
		for (int iter = 0; iter < UnityComponentList<Animator>.List.Count; ++iter)
		{
			Animator iterComponent = UnityComponentList<Animator>.List[iter];
			iterComponent.StopPlayback();
		}
		UnityComponentList<Animator>.End();
		//
		UnityComponentList<ParticleSystem>.Begin(obj);
		for (int iter = 0; iter < UnityComponentList<ParticleSystem>.List.Count; ++iter)
		{
			ParticleSystem iterComponent = UnityComponentList<ParticleSystem>.List[iter];
			iterComponent.time = 0.0f;
			iterComponent.Play();
		}
		UnityComponentList<ParticleSystem>.End();
		//
	}
	//
	public static void ReplaceMaterialShader(Material material)
	{
		if (material == null)
		{
			return;
		}
		//
		Int32 renderQueue = material.renderQueue;
		Shader shader = Shader.Find(material.shader.name);
		if (shader != null)
		{
#if UNITY_EDITOR
			if (!material.isVariant)
			{
				material.shader = shader;
			}
#else
			material.shader = shader;
#endif
			material.renderQueue = renderQueue;
		}
	}

	public static void ReplaceMaterialShader(Renderer renderer)
	{
		for (int iter = 0; iter < renderer.sharedMaterials.Length; ++iter)
		{
			Material iterMaterial = renderer.sharedMaterials[iter];
			if (iterMaterial != null)
			{
				ReplaceMaterialShader(iterMaterial);
			}
		}
	}

	public static void ReplaceMaterialShader(GameObject gameobject)
	{
		UnityComponentList<Renderer>.Begin(gameobject, true);
		for (int iter = 0; iter < UnityComponentList<Renderer>.List.Count; ++iter)
		{
			ReplaceMaterialShader(UnityComponentList<Renderer>.List[iter]);
		}
		UnityComponentList<Renderer>.End();
	}

	public static SkinnedMeshRenderer GetMainSkin(GameObject obj)
	{
		SkinnedMeshRenderer skin = obj.GetComponent<SkinnedMeshRenderer>();
		if (skin != null)
		{
			return skin;
		}
		//
		float maxBody = 0.0f;
		UnityComponentList<SkinnedMeshRenderer>.Begin(obj);
		for (int iter = 0; iter < UnityComponentList<SkinnedMeshRenderer>.List.Count; ++iter)
		{
			SkinnedMeshRenderer iterComponent = UnityComponentList<SkinnedMeshRenderer>.List[iter];
			Vector3 iterSize = iterComponent.bounds.size;
			float iterBody = iterSize.x * iterSize.y * iterSize.z;
			if (iterBody >= maxBody)
			{
				maxBody = iterBody;
				skin = iterComponent;
			}
		}
		UnityComponentList<SkinnedMeshRenderer>.End();
		return skin;
	}

	public static void SetParticleLightEnable(GameObject obj, bool paritcalLight)
	{
		if (!paritcalLight)
		{
			return;
		}
		//
		UnityComponentList<Light>.Begin(obj);
		for (int iter = 0; iter < UnityComponentList<Light>.List.Count; ++iter)
		{
			Light iterComponent = UnityComponentList<Light>.List[iter];
			iterComponent.enabled = true;
		}
		UnityComponentList<Light>.End();
	}

	public delegate Material GhostMaterialReplace(Material old, Material newTemplate);

	public static GameObject CreateGhostAvatar(GameObject root, SkinnedMeshRenderer renderer, Material material, GhostMaterialReplace materialReplace, List<UnityEngine.Object> ownMeshList)
	{
		if (renderer.sharedMesh == null)
		{
			return null;
		}
		GameObject newObj = UnityAssisstant.CreateChild(root.transform, renderer.gameObject.name, false);
		SkinnedMeshRenderer mesh = UnityAssisstant.CreateComponent<SkinnedMeshRenderer>(newObj);
		mesh.sharedMesh = (UnityEngine.Mesh)UnityEngine.Object.Instantiate(renderer.sharedMesh);
		mesh.bones = renderer.bones;
		Material newMaterial = material;
		int materialSize = renderer.materials.Length;
		UnityEngine.Material[] materials = new UnityEngine.Material[materialSize];
		for (int iter = 0; iter < materialSize; ++iter)
		{
			if (materialReplace != null)
			{
				newMaterial = materialReplace(renderer.materials[iter], material);
			}
			//
			materials[iter] = newMaterial;
		}
		mesh.material = newMaterial;
		mesh.materials = materials;
		mesh.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
		mesh.receiveShadows = false;
		if (ownMeshList != null)
		{
			ownMeshList.Add(mesh.sharedMesh);
		}
		return newObj;
	}

	public static GameObject CreateGhostAvatar(GameObject root, MeshRenderer renderer, Material material, GhostMaterialReplace materialReplace, List<UnityEngine.Object> ownMeshList)
	{
		GameObject newObj = UnityAssisstant.CreateChild(root.transform, renderer.gameObject.name, false);
		SkinnedMeshRenderer mesh = UnityAssisstant.CreateComponent<SkinnedMeshRenderer>(newObj);
		mesh.sharedMesh = (UnityEngine.Mesh)UnityEngine.Object.Instantiate(renderer.additionalVertexStreams);
		Material newMaterial = material;
		if (materialReplace != null)
		{
			newMaterial = materialReplace(mesh.material, material);
		}
		int materialSize = renderer.materials.Length;
		UnityEngine.Material[] materials = new UnityEngine.Material[materialSize];
		for (int iter = 0; iter < materialSize; ++iter)
		{
			materials[iter] = newMaterial;
		}
		mesh.material = newMaterial;
		mesh.materials = materials;
		mesh.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
		mesh.receiveShadows = false;
		if (ownMeshList != null)
		{
			ownMeshList.Add(mesh.sharedMesh);
		}
		return newObj;
	}

	public static GameObject BakeMesh(GameObject gameobject, Material replaceMaterial)
	{
		if (gameobject == null)
		{
			return null;
		}
		//
		GameObject shadowRoot = new GameObject();
		shadowRoot.name = gameobject.name + "_shadowRoot";
		//
		UnityComponentList<SkinnedMeshRenderer>.Begin(gameobject);
		for (int iter = 0; iter < UnityComponentList<SkinnedMeshRenderer>.List.Count; ++iter)
		{
			SkinnedMeshRenderer iterSkinrenderer = UnityComponentList<SkinnedMeshRenderer>.List[iter];
			if (iterSkinrenderer == null)
			{
				continue;
			}
			//
			Mesh mesh = new Mesh();
			iterSkinrenderer.BakeMesh(mesh);
			//
			GameObject iterChildrenobj = CreatMeshGameObject(mesh, iterSkinrenderer, replaceMaterial);
			//
			iterChildrenobj.transform.position = iterSkinrenderer.gameObject.transform.position - gameobject.transform.position;
			iterChildrenobj.transform.rotation = iterSkinrenderer.gameObject.transform.rotation;
			iterChildrenobj.transform.parent = shadowRoot.transform;
		}
		UnityComponentList<SkinnedMeshRenderer>.End();
		//
		UnityComponentList<MeshFilter>.Begin(gameobject);
		for (int iter = 0; iter < UnityComponentList<MeshFilter>.List.Count; ++iter)
		{
			MeshFilter iterMeshFilter = UnityComponentList<MeshFilter>.List[iter];

			if (!iterMeshFilter.gameObject.name.StartsWith("Wp"))
			{
				continue;
			}

			MeshRenderer iterMeshrenderer = iterMeshFilter.gameObject.GetComponent<MeshRenderer>();
			if (iterMeshFilter == null || iterMeshrenderer == null) continue;
			//
			Mesh mesh = UnityEngine.Object.Instantiate(iterMeshFilter.mesh);
			//
			GameObject childrenobj = CreatMeshGameObject(mesh, iterMeshrenderer, replaceMaterial);
			//
			childrenobj.transform.position = iterMeshrenderer.gameObject.transform.position - gameobject.transform.position;
			childrenobj.transform.rotation = iterMeshrenderer.gameObject.transform.rotation;
			childrenobj.transform.localScale = iterMeshrenderer.gameObject.transform.lossyScale;
			childrenobj.transform.parent = shadowRoot.transform;
		}
		UnityComponentList<MeshFilter>.End();
		//
		shadowRoot.transform.position = gameobject.transform.position;
		StaticBatchingUtility.Combine(shadowRoot);
		return shadowRoot;
	}

	public static GameObject CreatMeshGameObject(Mesh mesh, Renderer render, Material replaceMaterial)
	{
		GameObject childrenobj = new GameObject();
		MeshFilter meshfilter = childrenobj.AddComponent<MeshFilter>();
		MeshRenderer meshrender = childrenobj.AddComponent<MeshRenderer>();
		meshfilter.mesh = mesh;
		//
		if (replaceMaterial)
		{
			Material[] materials = new Material[render.materials.Length];
			for (int iter = 0; iter < materials.Length; ++iter)
			{
				materials[iter] = replaceMaterial;
			}
			meshrender.materials = materials;
		}
		else
		{
			meshrender.materials = render.materials;
		}
		//
		meshrender.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
		meshrender.receiveShadows = false;
		meshrender.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
		//
		return childrenobj;
	}

	public static Material MaterialTextureAlphaReplace(Material oldMaterial, Material newMaterialTemplate)
	{
		if (newMaterialTemplate.HasProperty("_OriginalTex"))
		{
			Material newMaterial = new Material(newMaterialTemplate.shader);
			newMaterial.CopyPropertiesFromMaterial(newMaterialTemplate);
			Texture meshMainTexture = null;
			if (oldMaterial.HasProperty("_MainTex"))
			{
				meshMainTexture = oldMaterial.GetTexture("_MainTex");
			}
			if (meshMainTexture != null)
			{
				newMaterial.SetTexture("_OriginalTex", meshMainTexture);
			}
			else
			{
				Texture2D texture = new Texture2D(1, 1, TextureFormat.ARGB32, false);
				texture.SetPixel(0, 0, Color.black);
				newMaterial.SetTexture("_OriginalTex", texture);
				newMaterial.SetColor("_RimColor", Color.black);
			}
			return newMaterial;
		}
		else
		{
			return newMaterialTemplate;
		}
	}

	public static Material MaterialToonShaderTextureReplace(Material oldMaterial, Material newMaterialTemplate)
	{
		if (newMaterialTemplate.HasProperty("_MainTex"))
		{
			Material newMaterial = new Material(newMaterialTemplate.shader);
			newMaterial.CopyPropertiesFromMaterial(newMaterialTemplate);
			Texture meshMainTexture = null;
			if (oldMaterial.HasProperty("_MainTex"))
			{
				meshMainTexture = oldMaterial.GetTexture("_MainTex");
				newMaterial.SetTexture("_MainTex", meshMainTexture);
			}
			if (oldMaterial.HasProperty("_Ramp"))
			{
				newMaterial.SetTexture("_Ramp", oldMaterial.GetTexture("_Ramp"));
			}
			if (oldMaterial.HasProperty("_SpecColor"))
			{
				newMaterial.SetColor("_SpecColor", oldMaterial.GetColor("_SpecColor"));
			}
			if (oldMaterial.HasProperty("_Shininess"))
			{
				newMaterial.SetFloat("_Shininess", oldMaterial.GetFloat("_Shininess"));
			}
			if (oldMaterial.HasProperty("_Color"))
			{
				newMaterial.SetColor("_Color", oldMaterial.GetColor("_Color"));
			}
			if (oldMaterial.HasProperty("_SColor"))
			{
				newMaterial.SetColor("_SColor", oldMaterial.GetColor("_SColor"));
			}
			if (oldMaterial.HasProperty("_Outline"))
			{
				newMaterial.SetFloat("_Outline", oldMaterial.GetFloat("_Outline"));
			}
			if (oldMaterial.HasProperty("_OutlineColor"))
			{
				newMaterial.SetColor("_OutlineColor", oldMaterial.GetColor("_OutlineColor"));
			}
			if (oldMaterial.HasProperty("_Emission"))
			{
				newMaterial.SetColor("_Emission", oldMaterial.GetColor("_Emission"));
			}
			//
			return newMaterial;
		}
		else
		{
			return newMaterialTemplate;
		}
	}

	public static Material MaterialMatCapTextureAddReplace(Material oldMaterial, Material newMaterialTemplate)
	{
		if (newMaterialTemplate.HasProperty("_MainTex"))
		{
			Material newMaterial = new Material(newMaterialTemplate.shader);
			newMaterial.CopyPropertiesFromMaterial(newMaterialTemplate);
			Texture meshMainTexture = null;
			if (oldMaterial.HasProperty("_MainTex"))
			{
				meshMainTexture = oldMaterial.GetTexture("_MainTex");
				newMaterial.SetTexture("_MainTex", meshMainTexture);
			}
			if (oldMaterial.HasProperty("_MatCap"))
			{
				newMaterial.SetTexture("_MatCap", oldMaterial.GetTexture("_MatCap"));
			}
			//
			return newMaterial;
		}
		else
		{
			return newMaterialTemplate;
		}
	}

	public static Material CharacterShaderReplace(Material oldMaterial, Material newMaterialTemplate)
	{
		if (newMaterialTemplate.HasProperty("_MainTex"))
		{
			Material newMaterial = new Material(newMaterialTemplate.shader);
			newMaterial.CopyPropertiesFromMaterial(newMaterialTemplate);
			Texture meshMainTexture = null;
			if (oldMaterial.HasProperty("_MainTex"))
			{
				meshMainTexture = oldMaterial.GetTexture("_MainTex");
				newMaterial.SetTexture("_MainTex", meshMainTexture);
			}
			if (oldMaterial.HasProperty("_MatTex"))
			{
				newMaterial.SetTexture("_MatTex", oldMaterial.GetTexture("_MatTex"));
			}
			if (oldMaterial.HasProperty("_DiffuseRampTex"))
			{
				newMaterial.SetTexture("_DiffuseRampTex", oldMaterial.GetTexture("_DiffuseRampTex"));
			}
			if (oldMaterial.HasProperty("_SpecRampTex"))
			{
				newMaterial.SetTexture("_SpecRampTex", oldMaterial.GetTexture("_SpecRampTex"));
			}
			if (oldMaterial.HasProperty("_OutlineWidth"))
			{
				newMaterial.SetFloat("_OutlineWidth", oldMaterial.GetFloat("_OutlineWidth"));
			}
			if (oldMaterial.HasProperty("_EdgeColor"))
			{
				newMaterial.SetColor("_EdgeColor", oldMaterial.GetColor("_EdgeColor"));
			}
			if (oldMaterial.HasProperty("_LightParams"))
			{
				newMaterial.SetVector("_LightParams", oldMaterial.GetVector("_LightParams"));
			}
			if (oldMaterial.HasProperty("_LightParamsHDR"))
			{
				newMaterial.SetVector("_LightParamsHDR", oldMaterial.GetVector("_LightParamsHDR"));
			}
			if (oldMaterial.HasProperty("_HairParams"))
			{
				newMaterial.SetVector("_HairParams", oldMaterial.GetVector("_HairParams"));
			}
			if (oldMaterial.HasProperty("_AnimeEnvTex"))
			{
				newMaterial.SetTexture("_AnimeEnvTex", oldMaterial.GetTexture("_AnimeEnvTex"));
			}
			if (oldMaterial.HasProperty("_EnvParams"))
			{
				newMaterial.SetVector("_EnvParams", oldMaterial.GetVector("_EnvParams"));
			}
			if (oldMaterial.HasProperty("_SceneEnvTex"))
			{
				newMaterial.SetTexture("_SceneEnvTex", oldMaterial.GetTexture("_SceneEnvTex"));
			}
			//
			return newMaterial;
		}
		else
		{
			return newMaterialTemplate;
		}
	}

	public static void SelectShareMaterial(GameObject obj, Dictionary<Int32, Material[]> materialList)
	{
		UnityComponentList<Renderer>.Begin(obj);
		SelectShareMaterial(UnityComponentList<Renderer>.List, materialList);
		UnityComponentList<Renderer>.End();
	}

	public static void SelectShareMaterial(List<Renderer> rendererList, Dictionary<Int32, Material[]> materialList)
	{
		for (int iter = 0; iter < rendererList.Count; ++iter)
		{
			SelectShareMaterial(rendererList[iter], materialList);
		}
	}

	public static void SelectShareMaterial(Renderer renderer, Dictionary<Int32, Material[]> materialList)
	{
		materialList[renderer.GetInstanceID()] = renderer.sharedMaterials;
	}

	public static void RevertShareMaterial(GameObject obj, Dictionary<Int32, Material[]> materialList)
	{
		UnityComponentList<Renderer>.Begin(obj);
		RevertShareMaterial(UnityComponentList<Renderer>.List, materialList);
		UnityComponentList<Renderer>.End();
	}

	public static void RevertShareMaterial(List<Renderer> rendererList, Dictionary<Int32, Material[]> materialList)
	{
		for (int iter = 0; iter < rendererList.Count; ++iter)
		{
			RevertShareMaterial(rendererList[iter], materialList);
		}
	}

	public static void RevertShareMaterial(Renderer renderer, Dictionary<Int32, Material[]> materialList)
	{
		Material[] materials;
		if (materialList.TryGetValue(renderer.GetInstanceID(), out materials))
		{
			renderer.materials = materials;
		}
	}

	private static Vector3 Pick(Vector3 pos, float radius, Vector3 direction, float distance, int layerMask, int reserveCount)
	{
		RaycastHit hitResult;
		if (Physics.SphereCast(pos, radius, direction, out hitResult, distance, layerMask))
		{
			float newDistance = Math.Max(hitResult.distance - 0.01f, 0.0f);
			Vector3 newPos = pos + direction * newDistance;
			//
			if (reserveCount > 1)
			{
				float cutedDistance = distance - newDistance;
				Vector3 cutedValue = direction * cutedDistance;
				Vector3 normal = -hitResult.normal;
				Vector3 normalValue = Vector3.Dot(cutedValue, normal) * normal;
				Vector3 slideValue = cutedValue - normalValue;
				Vector3 slideDir = slideValue.normalized;
				float slideDistance = slideValue.magnitude;
				return Pick(newPos, radius, slideDir, slideDistance, layerMask, reserveCount - 1);
			}
			else
			{
				return newPos;
			}
		}
		else
		{
			return pos + direction * distance;
		}
	}

	public static Vector3 ViewportCenterPos = new Vector3(0.5f, 0.5f, 0.0f);

	public static Vector3 WorldToViewportPoint(Camera camera, Vector3 worldPos, float frontDistance)
	{
		Ray ray = camera.ViewportPointToRay(ViewportCenterPos);
		Vector3 diff = worldPos - ray.origin;
		diff -= Vector3.Dot(diff, ray.direction) * ray.direction;
		worldPos = ray.origin + diff + frontDistance * ray.direction;
		return camera.WorldToViewportPoint(worldPos);
	}

	public static Vector3 ViewportRoundPoint(Vector3 viewPortPos)
	{
		Vector3 viewPortDiff = viewPortPos - ViewportCenterPos;
		viewPortDiff /= (2.0f * ViMathDefine.Max(ViMathDefine.Abs(viewPortDiff.x), ViMathDefine.Abs(viewPortDiff.y)));
		return ViewportCenterPos + viewPortDiff;
	}

	public static bool WorldPointInViewport(Camera camera, Vector3 worldPos)
	{
		Vector3 viewPos = camera.WorldToViewportPoint(worldPos);
		if (0.0f < viewPos.x && viewPos.x < 1.0f && 0.0f < viewPos.y && viewPos.y < 1.0f)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	//
	public static string GetDeviceId()
	{
		const string key = "device_id";
		if (PlayerPrefs.HasKey(key))
		{
			return PlayerPrefs.GetString(key);
		}
		string newId = System.Guid.NewGuid().ToString();
		PlayerPrefs.SetString(key, newId);
		PlayerPrefs.Save();
		return newId;
	}
}