using UnityEngine;
using System.Collections.Generic;

public class CombineMesh : MonoBehaviour
{
 public GameObject skeleton;

 public GameObject face;
 public GameObject hands;
 public GameObject lower;
 public GameObject upper;

 public GameObject weapon;

 void EquipWeapon(int hand, GameObject avatar, GameObject weapon)
 {
 Transform handTransform = null;
 
 if (hand == 1)
 {
 handTransform = avatar.transform.FindChild("Bip01/dummy_right_weapon_at");
 }
 else
 {
 handTransform = avatar.transform.FindChild("Bip01/dummy_left_weapon_at");
 }
 
 var weaponTransform = weapon.transform;
 weaponTransform.SetParent(handTransform);
 weaponTransform.localPosition = Vector3.zero;
 weaponTransform.localRotation = Quaternion.identity;
 weaponTransform.localScale = Vector3.one;
 }

 void ReplaceElement(int elementType, GameObject avatar, GameObject dummy)
 {
 if (elementType == 1) //头
 {
 var dummyElement = dummy.transform.FindChild("face").gameObject;
 var avatarElement = avatar.transform.FindChild("face").gameObject;

 dummyElement.transform.SetParent(avatar.transform);
 GameObject.Destroy(dummy);
 GameObject.Destroy(avatarElement);

 var skinnedMeshRenderer = dummyElement.GetComponent<SkinnedMeshRenderer>();
 var avatarBones = avatar.GetComponentsInChildren<Transform>();

 List<Transform> newBones = new List<Transform>();
 foreach (Transform bone in skinnedMeshRenderer.bones)
 {
 foreach (Transform avatarBone in avatarBones)
 {
 //找对应骨骼进行替换
 if (avatarBone.name.Equals(bone.name))
 {
 newBones.Add(avatarBone);
 break;
 }
 }
 }

 skinnedMeshRenderer.bones = newBones.ToArray();
 }
 }

 void OnGUI()
 {
 if (GUI.Button(new Rect(50, 400, 100, 50), "替换骨骼"))
 {
 ReplaceElement(1, skeleton, face);
 EquipWeapon(2, skeleton, weapon);
 return;

 var faceSMR = face.GetComponentInChildren<SkinnedMeshRenderer>();

 faceSMR.transform.SetParent(skeleton.transform);
 GameObject.DestroyImmediate(skeleton.transform.FindChild("face").gameObject);

 var avatarBones = gameObject.GetComponentsInChildren<Transform>();

 List<Transform> newBones = new List<Transform>();

 foreach (Transform bone in faceSMR.bones)
 {
 foreach (Transform avatarBone in avatarBones)
 {
 if (avatarBone.name.Equals(bone.name))
 {
 avatarBone.localPosition = bone.localPosition;
 avatarBone.localScale = bone.localScale;
 avatarBone.localRotation = bone.localRotation;
 newBones.Add(avatarBone);
 break;
 }
 }
 }

 faceSMR.bones = newBones.ToArray();

 }

 if (GUI.Button(new Rect(50, 300, 100, 50), "换头2"))
 {
 SkinnedMeshRenderer[] meshes = new SkinnedMeshRenderer[4];
 GameObject[] objects = new GameObject[4];
 meshes[0] = face.GetComponentInChildren<SkinnedMeshRenderer>();
 meshes[1] = hands.GetComponentInChildren<SkinnedMeshRenderer>();
 meshes[2] = lower.GetComponentInChildren<SkinnedMeshRenderer>();
 meshes[3] = upper.GetComponentInChildren<SkinnedMeshRenderer>();

 CombineObject(skeleton, meshes, false);
 }

 if (GUI.Button(new Rect(50, 100, 100, 50), "换头1"))
 {
 MergeChild(skeleton);
 return;

 //目标部件
 //var targetSMRs = face.GetComponentsInChildren<SkinnedMeshRenderer>();
 //SkinnedMeshRenderer targetSMR = null;
 //for (int i = 0; i < targetSMRs.Length; i++)
 //{
 // if (targetSMRs[i].gameObject.name.Equals("face"))
 // {
 // targetSMR = targetSMRs[i];
 // break;
 // }
 //}

 //裸体原型
 List<Material> materials = new List<Material>();
 List<CombineInstance> combineInstances = new List<CombineInstance>();
 List<Transform> bones = new List<Transform>();
 //bones.AddRange(skeleton.transform.FindChild("Bip01").GetComponentsInChildren<Transform>(true));

 Matrix4x4 myTransform = skeleton.transform.worldToLocalMatrix;

 var nudeSMRs = skeleton.GetComponentsInChildren<SkinnedMeshRenderer>();
 for (int i = 0; i < nudeSMRs.Length; i++)
 {
 
 SkinnedMeshRenderer skinnedMeshRenderer = nudeSMRs[i];

 foreach (Transform bone in skinnedMeshRenderer.bones)
 {
 bones.Add(bone);
 }

 //材质
 materials.AddRange(skinnedMeshRenderer.materials);

 //网格
 CombineInstance combine = new CombineInstance();
 combine.mesh = skinnedMeshRenderer.sharedMesh;
 combine.transform = myTransform * skinnedMeshRenderer.transform.localToWorldMatrix;
 combineInstances.Add(combine);
 for (int sub = 0; sub < skinnedMeshRenderer.sharedMesh.subMeshCount; sub++)
 {
 combine.subMeshIndex = sub;
 //combineInstances.Add(combine);
 }

 skinnedMeshRenderer.gameObject.SetActive(false);

 //if (nudeSMRs[i].gameObject.name.Equals("face"))
 //{
 // nudeSMRs[i].gameObject.SetActive(false);
 //}
 }


 List<Matrix4x4> bindposes = new List<Matrix4x4>();
 for (int i = 0; i < bones.Count; i++)
 {
 bindposes.Add(bones[i].worldToLocalMatrix * skeleton.transform.worldToLocalMatrix);
 }

 //合并
 SkinnedMeshRenderer smr = skeleton.AddComponent<SkinnedMeshRenderer>();
 smr.materials = materials.ToArray();
 smr.sharedMesh = new Mesh();
 smr.sharedMesh.name = skeleton.name;
 smr.sharedMesh.CombineMeshes(combineInstances.ToArray(), false);
 //smr.sharedMesh.bindposes = bindposes.ToArray();
 smr.sharedMesh.RecalculateBounds();
 smr.bones = bones.ToArray();
 }
 }

 public static void MergeChild(GameObject gameObject)
 {
 if (gameObject.GetComponent<SkinnedMeshRenderer>() != null)
 {
 //LogTool.Error("合并结果对象不能有SkinnedMeshRenderer");
 return;
 }

 var meshRenderers = gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();

 List<BoneWeight> boneWeights = new List<BoneWeight>();
 List<Transform> bones = new List<Transform>();
 List<CombineInstance> combines = new List<CombineInstance>();
 List<Material> materials = new List<Material>();

 int boneOffset = 0;
 for (int i = 0; i < meshRenderers.Length; i++)
 {
 SkinnedMeshRenderer skinnedMeshRenderer = meshRenderers[i];

 if (skinnedMeshRenderer.sharedMesh.triangles.Length == 0)
 {
 Debug.LogError(skinnedMeshRenderer.gameObject.name + "模型网格顶点数据为空!检查导入模型Read/Write Enabled");
 return;
 }

 BoneWeight[] meshBoneweight = skinnedMeshRenderer.sharedMesh.boneWeights;
 foreach (BoneWeight bw in meshBoneweight)
 {
 BoneWeight bWeight = bw;
 bWeight.boneIndex0 += boneOffset;
 bWeight.boneIndex1 += boneOffset;
 bWeight.boneIndex2 += boneOffset;
 bWeight.boneIndex3 += boneOffset;
 boneWeights.Add(bWeight);
 }
 boneOffset += skinnedMeshRenderer.bones.Length;

 foreach (Transform bone in skinnedMeshRenderer.bones)
 {
 bool contain = false;
 foreach (Transform bone2 in bones)
 {
 if (bone2.name.Equals(bone.name))
 {
 contain = true;
 }
 }
 if (!contain)
 {
 bones.Add(bone);
 }
 }

 //combines[i].mesh = skinnedMeshRenderer.sharedMesh;
 //combines[i].transform = skinnedMeshRenderer.transform.localToWorldMatrix;

 //materials[i] = skinnedMeshRenderer.sharedMaterial;

 //材质
 materials.AddRange(skinnedMeshRenderer.materials);

 //网格
 CombineInstance combine = new CombineInstance();
 combine.mesh = skinnedMeshRenderer.sharedMesh;
 combine.transform = skinnedMeshRenderer.transform.localToWorldMatrix;
 for (int sub = 0; sub < skinnedMeshRenderer.sharedMesh.subMeshCount; sub++)
 {
 combine.subMeshIndex = sub;
 combines.Add(combine);
 }

 GameObject.Destroy(skinnedMeshRenderer.gameObject);
 }

 List<Matrix4x4> bindposes = new List<Matrix4x4>();
 for (int i = 0; i < bones.Count; i++)
 {
 bindposes.Add(bones[i].worldToLocalMatrix * gameObject.transform.worldToLocalMatrix);
 }

 SkinnedMeshRenderer meshRenderer = gameObject.GetComponent<SkinnedMeshRenderer>();
 if (meshRenderer == null)
 {
 meshRenderer = gameObject.AddComponent<SkinnedMeshRenderer>();
 }

 meshRenderer.sharedMesh = new Mesh();
 meshRenderer.sharedMesh.name = gameObject.name;
 meshRenderer.sharedMesh.CombineMeshes(combines.ToArray(), false);

 meshRenderer.bones = bones.ToArray();
 //meshRenderer.sharedMesh.boneWeights = boneWeights.ToArray();
 meshRenderer.sharedMesh.bindposes = bindposes.ToArray();
 meshRenderer.sharedMesh.RecalculateBounds();

 meshRenderer.sharedMaterials = materials.ToArray();
 }

 /// <summary>
 /// Combine SkinnedMeshRenderers together and share one skeleton.
 /// Merge materials will reduce the drawcalls, but it will increase the size of memory. 
 /// </summary>
 /// <param name="skeleton">combine meshes to this skeleton(a gameobject)</param>
 /// <param name="meshes">meshes need to be merged</param>
 /// <param name="combine">merge materials or not</param>
 public void CombineObject(GameObject skeleton, SkinnedMeshRenderer[] meshes, bool combine = false)
 {

 // Fetch all bones of the skeleton
 List<Transform> transforms = new List<Transform>();
 transforms.AddRange(skeleton.GetComponentsInChildren<Transform>(true));

 List<Material> materials = new List<Material>();//the list of materials
 List<CombineInstance> combineInstances = new List<CombineInstance>();//the list of meshes
 List<Transform> bones = new List<Transform>();//the list of bones

 // Collect information from meshes
 for (int i = 0; i < meshes.Length; i++)
 {
 SkinnedMeshRenderer smr = meshes[i];
 materials.AddRange(smr.materials); // Collect materials
 // Collect meshes
 for (int sub = 0; sub < smr.sharedMesh.subMeshCount; sub++)
 {
 CombineInstance ci = new CombineInstance();
 ci.mesh = smr.sharedMesh;
 ci.subMeshIndex = sub;
 combineInstances.Add(ci);
 }
 // Collect bones
 for (int j = 0; j < smr.bones.Length; j++)
 {
 int tBase = 0;
 for (tBase = 0; tBase < transforms.Count; tBase++)
 {
 if (smr.bones[j].name.Equals(transforms[tBase].name))
 {
 bones.Add(transforms[tBase]);
 break;
 }
 }
 }
 }

 // Create a new SkinnedMeshRenderer
 SkinnedMeshRenderer oldSKinned = skeleton.GetComponent<SkinnedMeshRenderer>();
 if (oldSKinned != null)
 {

 GameObject.DestroyImmediate(oldSKinned);
 }
 SkinnedMeshRenderer r = skeleton.AddComponent<SkinnedMeshRenderer>();
 r.sharedMesh = new Mesh();
 r.sharedMesh.CombineMeshes(combineInstances.ToArray(), combine, false);// Combine meshes
 r.bones = bones.ToArray();// Use new bones
 r.materials = materials.ToArray();
 }


}