unity-doc-换装

注意点

1. 主骨骼必须包含所有部件的骨骼信息（建议不包含任何网格）
2. 制作的部件预制体必须自带骨骼信息
3. SkinnedMeshRenderer不可优化，每一个都是一个DrawCall，需要进行合并成1个
4. 部件骨骼要是跟主骨骼对不上，合并后的模型会显示不出来

主骨骼示意图

部件示意图

代码

XSkinnedMeshRenderer

using System.Collections.Generic;
using UnityEngine;

namespace XFrame
{
    public class XSkinnedMeshRenderer : MonoBehaviour
    {
        private GameObject m_goSkeleton;		// 骨骼
        private GameObject[] m_arrSkinPart;		// 皮肤网格部件集合
        private GameObject[] m_arrMeshPart;		// 普通网格部件集合

        private Transform[] m_arrSkeletonNodes;	// 骨骼的所有节点
        
        private int m_combineTextureSize = COMBINE_TEXTURE_SIZE;						// 合并后贴图大小
        private string m_shaderTexturePropertyName = SHADER_TEXTURE_PROPERTY_NAME;		// shader设置纹理贴图的特性名称
        
        public const int COMBINE_TEXTURE_SIZE = 512;						// 合并后贴图大小
        public const string SHADER_TEXTURE_PROPERTY_NAME = "_MainTex";		// shader设置纹理贴图的特性名称
        
        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="maxPartType">最大部件类型</param>
        public void Init(int maxPartType)
        {
	        m_arrSkinPart = new GameObject[maxPartType];
	        m_arrMeshPart = new GameObject[maxPartType];
        }

        /// <summary>
        /// 设置合并信息
        /// </summary>
        /// <param name="combineTextureSize">合并贴图大小</param>
        /// <param name="shaderTexProName">shader主纹理特性名称</param>
        public void SetCombineInfo(int combineTextureSize, string shaderTexProName)
        {
	        m_combineTextureSize = combineTextureSize;
	        m_shaderTexturePropertyName = shaderTexProName;
        }
        
        /// <summary>
        /// 设置骨骼
        /// </summary>
        /// <param name="go">骨骼实例</param>
        public void SetSkeleton(GameObject go)
        {
            m_goSkeleton = go;
            m_arrSkeletonNodes = GetTransformAllNode(m_goSkeleton.transform);
        }

        /// <summary>
        /// 更换皮肤网格部件
        /// </summary>
        /// <param name="partType">部件类型</param>
        /// <param name="goPart">部件实例</param>
        /// <param name="lineToSkeleton">是否要链接新部件到骨骼上</param>
        /// <returns>老的部件实例</returns>
        public GameObject ChangeSkinMeshPart(int partType, GameObject goPart, bool lineToSkeleton)
        {
            GameObject oldPart = m_arrSkinPart[partType];
            if (oldPart != null)
            {
	            // 移除老的网格
            }

            if (goPart != null)
            {
	            // 添加新的网格
	            if (lineToSkeleton)
	            {
		            LinePartToSkeleton(goPart);
	            }
            }

            m_arrSkinPart[partType] = goPart;
            return oldPart;
        }

        /// <summary>
        /// 移除皮肤网格部件
        /// </summary>
        /// <param name="partType">部件类型</param>
        /// <returns>部件实例</returns>
        public GameObject RemoveSkinMeshPart(int partType)
        {
	        GameObject oldPart = m_arrSkinPart[partType];
	        m_arrSkinPart[partType] = null;

	        return oldPart;
        }

        /// <summary>
        /// 合并皮肤网格
        /// </summary>
        public void CombineSkinMeshRender()
        {
	        List<SkinnedMeshRenderer> listSkinMesh = new List<SkinnedMeshRenderer>();
	        foreach (var part in m_arrSkinPart)
	        {
		        if (part == null)
		        {
			        continue;
		        }

		        SkinnedMeshRenderer[] arrSkinMesh = part.GetComponentsInChildren<SkinnedMeshRenderer>();
		        listSkinMesh.AddRange(arrSkinMesh);
	        }
	        
	        CombineSkinMeshRender(listSkinMesh);
	        
	        // 隐藏合并参考的皮肤部件
	        foreach (var part in m_arrSkinPart)
	        {
		        if (part == null)
		        {
			        continue;
		        }
		        
		        part.SetActive(false);
	        }
        }

		/// <summary>
		/// 更换网格部件
		/// </summary>
		/// <param name="partType">部件类型</param>
		/// <param name="boneName">绑定的骨骼名称</param>
		/// <param name="goPart">部件实例</param>
		/// <returns>老部件</returns>
        public GameObject ChangeMeshPart(int partType, string boneName, GameObject goPart)
		{
			GameObject oldPart = m_arrMeshPart[partType];

			if (m_goSkeleton != null && goPart != null)
			{
				Transform[] arrBones = m_goSkeleton.GetComponentsInChildren<Transform>();
				foreach (Transform bone in arrBones) {
					if (bone.name == boneName) {
						goPart.transform.SetParent(bone);
						goPart.transform.localScale = Vector3.one;
						goPart.transform.localPosition = Vector3.zero;
						goPart.transform.localRotation = Quaternion.identity;
						break;
					}	
				}
			}

			m_arrMeshPart[partType] = goPart;

			return oldPart;
		}

		/// <summary>
		/// 移除网格部件
		/// </summary>
		/// <param name="partType">部件类型</param>
		/// <returns>部件实例</returns>
		public GameObject RemoveMeshPart(int partType)
		{
			GameObject oldPart = m_arrMeshPart[partType];
			m_arrMeshPart[partType] = null;

			return oldPart;
		}

		/// <summary>
		/// 连接部件到骨骼
		/// </summary>
		/// <param name="goPart">部件实例</param>
		private void LinePartToSkeleton(GameObject goPart)
		{
			if (goPart == null)
			{
				return;
			}
			
			SkinnedMeshRenderer[] arrSkinMesh = goPart.GetComponentsInChildren<SkinnedMeshRenderer>();
			foreach (var meshRenderer in arrSkinMesh)
			{
				if (meshRenderer.rootBone != null)
				{
					Transform rootBone = FindSkeletonNode(meshRenderer.rootBone.name);
					if (rootBone != null)
					{
						meshRenderer.rootBone = rootBone;
					}
				}
				
				Transform[] arrSkeletonNode = new Transform[meshRenderer.bones.Length];
				for (int i = 0; i < meshRenderer.bones.Length; i++)
				{
					Transform oldBone = meshRenderer.bones[i];
					if (oldBone != null)
					{
						Transform bone = FindSkeletonNode(oldBone.name);
						arrSkeletonNode[i] = bone;
					}
				}
				
				meshRenderer.bones = arrSkeletonNode;
			}
		}

		/// <summary>
		/// 获取变换的所有节点
		/// 包裹自己
		/// </summary>
		/// <param name="tf"></param>
		/// <returns>节点实例</returns>
		private Transform[] GetTransformAllNode(Transform tf)
		{
			if (tf == null)
			{
				return new Transform[]{};
			}
			
			// List<Transform> listTf = new List<Transform>();
			// listTf.Add(tf);
			// listTf.AddRange(tf.GetComponentsInChildren<Transform>(true));

			return tf.GetComponentsInChildren<Transform>(true);
		}

		/// <summary>
		/// 寻找骨骼下节点
		/// </summary>
		/// <param name="nodeName">节点名称</param>
		/// <returns>节点</returns>
		private Transform FindSkeletonNode(string nodeName)
		{
			if (m_goSkeleton == null)
			{
				return null;
			}
			
			Transform childNode = FindChildNode(m_arrSkeletonNodes, nodeName);
			return childNode;
		}

		/// <summary>
		/// 查找子节点
		/// </summary>
		/// <param name="arrChildNode">子节点集合</param>
		/// <param name="nodeName">节点名称</param>
		/// <returns>节点实例</returns>
		private Transform FindChildNode(Transform[] arrChildNode, string nodeName)
		{
			if (arrChildNode == null)
			{
				return null;
			}

			bool checkRepeat = true;
			if (checkRepeat)
			{
				int repeatNum = 0;
				Transform tfNode = null;
				foreach (Transform node in arrChildNode) 
				{
					if (node.name == nodeName)
					{
						tfNode = node;
						repeatNum++;
					}
				}

				if (repeatNum > 1)
				{
					Debug.LogErrorFormat("模型有问题，该模型下骨骼又重名，不好找骨骼点{0}",nodeName);
				}

				return tfNode;
			}
			else
			{
				foreach (Transform node in arrChildNode) 
				{
					if (node.name == nodeName)
					{
						return node;
					}
				}
			}
			

			return null;
		}
	    
		/// <summary>
		/// 合并皮肤网格
		/// </summary>
		/// <param name="skeleton">根骨骼</param>
		/// <param name="listSkinMesh">皮肤网格列表</param>
		private void CombineSkinMeshRender (List<SkinnedMeshRenderer> listSkinMesh)
		{
			// Transform[] arrSkeletonNode = GetTransformAllNode(skeleton.transform);
			List<Material> listSkinMaterials = new List<Material>();
			List<CombineInstance> listCombineInstances = new List<CombineInstance>();
			List<Transform> listBones = new List<Transform>();
			
			// 采集皮肤网格信息
			for (int i = 0; i < listSkinMesh.Count; i ++)
			{
				SkinnedMeshRenderer smr = listSkinMesh[i];
				
				// 材质
				listSkinMaterials.AddRange(smr.materials);
				
				// 网格
				for (int sub = 0; sub < smr.sharedMesh.subMeshCount; sub++)
				{
					CombineInstance ci = new CombineInstance();
					ci.mesh = smr.sharedMesh;
					ci.subMeshIndex = sub;
					listCombineInstances.Add(ci);
					
					break;
				}
				
				// 骨骼
				for (int j = 0 ; j < smr.bones.Length; j ++)
				{
					Transform bone = smr.bones[j];
					if (bone == null)
					{
						continue;
					}
					
					Transform tfBoneNode = FindChildNode(m_arrSkeletonNodes, bone.name);
					if (tfBoneNode != null)
					{
						listBones.Add(tfBoneNode);
					}
				}
			}
	
			// 老uv记录
			List<Vector2[]> oldUV = new List<Vector2[]>();
			for (int i = 0; i < listCombineInstances.Count; i++)
			{
				oldUV.Add(listCombineInstances[i].mesh.uv);
			}
			
	        // 合并材质
	        Material newMaterial = null;
	        if (listSkinMaterials.Count > 0)
	        {
		        newMaterial = new Material(listSkinMaterials[0]);
	        
		        // 合并贴图
		        List<Texture2D> listSkinTexture = new List<Texture2D>();
		        for (int i = 0; i < listSkinMaterials.Count; i++)
		        {
			        Texture matTex = listSkinMaterials[i].GetTexture(m_shaderTexturePropertyName);
			        if (matTex == null)
			        {
				        continue;
			        }
			        
			        listSkinTexture.Add(matTex as Texture2D);
		        }

		        Texture2D newTexture = new Texture2D(m_combineTextureSize, m_combineTextureSize, TextureFormat.RGBA32, true);
		        Rect[] uvs = newTexture.PackTextures(listSkinTexture.ToArray(), 0);
		        newMaterial.mainTexture = newTexture;

		        // 重置网格uv
		        Vector2[] uva, uvb;
		        for (int i = 0; i < listCombineInstances.Count; i++)
		        {
			        uva = listCombineInstances[i].mesh.uv;
			        uvb = new Vector2[uva.Length];
			        for (int j = 0; j < uva.Length; j++)
			        {
				        uvb[j] = new Vector2((uva[j].x * uvs[i].width) + uvs[i].x, (uva[j].y * uvs[i].height) + uvs[i].y);
			        }
		        
			        listCombineInstances[i].mesh.uv = uvb;
		        }
	        }
		
			// 移除老的皮肤网格
			SkinnedMeshRenderer oldSkinMesh = m_goSkeleton.GetComponent<SkinnedMeshRenderer> ();
			if (oldSkinMesh != null) {

				DestroyImmediate (oldSkinMesh);
			}
			
			// 创建新的皮肤网格
			SkinnedMeshRenderer newSkinMesh = m_goSkeleton.AddComponent<SkinnedMeshRenderer>();
			newSkinMesh.sharedMesh = new Mesh();
			newSkinMesh.sharedMesh.CombineMeshes(listCombineInstances.ToArray(), true, false);
			newSkinMesh.bones = listBones.ToArray();
			newSkinMesh.material = newMaterial;
			
			// uv还原
			for (int i = 0 ; i < listCombineInstances.Count ; i ++)
			{
				listCombineInstances[i].mesh.uv = oldUV[i];
			}
		}
    }

}

场景示意图

创建部件示意图

链接部件示意图

合并部件示意图

测试1-分步操作

XSkinnedMeshRendererTest

using System;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

namespace XFrame
{
    [Serializable]
    public struct MeshPartInfo
    {
        public GameObject GoPrefab;
        public string MountNodeName;
    }
    
    public class XSkinnedMeshRendererTest : MonoBehaviour
    {
        public GameObject m_goSkeletonPrefab;           // 骨骼预制体-包含所有骨骼
        public GameObject[] m_arrPartPrefab;            // 皮肤网格部件预制体集合
        public MeshPartInfo[] m_arrMeshPartInfo;        // 网格部件预制体集合
        
        private GameObject m_goInst;
        private GameObject m_goSkeletonInst;
        
        private List<GameObject> m_listSkinPartInst = new List<GameObject>();
        private List<GameObject> m_listMeshPartInst = new List<GameObject>();
        
        public void OnGUI()
        {
            if (GUILayout.Button("创建部件"))
            {
                GameObject goInst = new GameObject("goInst");
                XSkinnedMeshRenderer xSkin = goInst.AddComponent<XSkinnedMeshRenderer>();
                xSkin.Init(m_arrPartPrefab.Length + m_arrMeshPartInfo.Length);

                m_goInst = goInst;
                
                // 创建骨骼
                m_goSkeletonInst = CreatePrefab(m_goSkeletonPrefab, goInst.transform);
                
                // 创建皮肤部件
                foreach (var part in m_arrPartPrefab)
                {
                    if (part == null)
                    {
                        continue;
                    }
                    
                    GameObject inst = CreatePrefab(part, goInst.transform);
                    m_listSkinPartInst.Add(inst);
                }
                
                // 创建网格部件
                foreach (var partInfo in m_arrMeshPartInfo)
                {
                    if (partInfo.GoPrefab == null)
                    {
                        m_listMeshPartInst.Add(null);
                        continue;
                    }
                    
                    GameObject inst = CreatePrefab(partInfo.GoPrefab, goInst.transform);
                    m_listMeshPartInst.Add(inst);
                }
            }
            
            if (GUILayout.Button("链接部件"))
            {
                XSkinnedMeshRenderer xSkin = m_goInst.GetComponent<XSkinnedMeshRenderer>();
                xSkin.SetSkeleton(m_goSkeletonInst);

                // 链接皮肤部件
                for (int i = 0; i < m_listSkinPartInst.Count; i++)
                {
                    GameObject part = m_listSkinPartInst[i];
                    if (part == null)
                    {
                        continue;
                    }
                    
                    xSkin.ChangeSkinMeshPart(i, part, true);
                }
                
                // 挂载网格部件
                for(int i = 0; i < m_listMeshPartInst.Count; i++)
                {
                    GameObject part = m_listMeshPartInst[i];
                    if (part == null)
                    {
                        continue;
                    }
                    
                    MeshPartInfo partInfo = m_arrMeshPartInfo[i];
                    xSkin.ChangeMeshPart(m_listSkinPartInst.Count + i, partInfo.MountNodeName, part);
                }
            }

            if (GUILayout.Button("合并部件"))
            {
                XSkinnedMeshRenderer xSkin = m_goInst.GetComponent<XSkinnedMeshRenderer>();
                xSkin.CombineSkinMeshRender();
            }

            if (GUILayout.Button("播放动画测试"))
            {
                Animator ani = m_goSkeletonInst.GetComponent<Animator>();
                ani.Play("StandA_idleA");
            }
        }

        /// <summary>
        /// 创建预制体实例
        /// </summary>
        /// <param name="goPrefab"></param>
        /// <param name="parent"></param>
        /// <returns></returns>
        private GameObject CreatePrefab(GameObject goPrefab, Transform parent)
        {
            GameObject goInst = GameObject.Instantiate(goPrefab);
            goInst.name = goPrefab.name;
            goInst.transform.SetParent(parent);
            goInst.transform.localPosition = Vector3.zero;
            goInst.transform.localScale = Vector3.one;
            goInst.transform.localRotation = Quaternion.identity;

            return goInst;
        }
    }
}

测试2-直接合并

XSkinnedMeshRendererTest2

using System;
using UnityEngine;

namespace XFrame
{
    public class XSkinnedMeshRendererTest2 : MonoBehaviour
    {
        public GameObject m_skeleton;       // 骨骼实例
        public GameObject[] m_arrPart;      // 部件集合

        public void OnGUI()
        {
            if (GUILayout.Button("合并网格"))
            {
                XSkinnedMeshRenderer render = GetComponent<XSkinnedMeshRenderer>();
                render.Init(10);
                render.SetSkeleton(m_skeleton);

                for (int i = 0; i < m_arrPart.Length; i++)
                {
                    render.ChangeSkinMeshPart(i, m_arrPart[i], false);
                }
                
                render.CombineSkinMeshRender();
            }
        }
    }
}

场景示意图

合并前示意图

合并后示意图