原理就是将使用同一套骨骼的模型部分，单独独立起来，制作成可以加载利用的资源。然后加载这些单独的部分，组合成模型。如果要替换某个部分，就将合成的部分资源换成其他就好了。

每个模型部分的骨骼数据要和原来的骨骼数据一致，这样就可以通过一个只有骨骼数据的GameObject，然后加上SkinnedMeshRenderer，用各个部分蒙皮成为一个千变万化的人物了。

因为使用的是骨骼动画，各部分的顶点和骨骼的绑定是预定好的，所有不管部分的变化，动画还是可以正常播放的。

using System.Collections.Generic;
using UnityEngine;

[RequireComponent(typeof(SkinnedMeshRenderer))]
public class AvatarPipi : MonoBehaviour {

    //事先准备好的部件，美术做好的，可以做成prefab，需要时再通过名字来加载
    public List<GameObject> eyes = new List<GameObject>();
    public List<GameObject> faces = new List<GameObject>();
    public List<GameObject> hairs = new List<GameObject>();
    public List<GameObject> pants = new List<GameObject>();
    public List<GameObject> shoes = new List<GameObject>();
    public List<GameObject> tops = new List<GameObject>();
    
    private List<CombineInstance> mList = new List<CombineInstance>();//子网格信息
    private List<Transform> bones = new List<Transform>();//骨骼
    private List<Material> mats = new List<Material>();//材质

    private List<Transform> allBones = new List<Transform>();
    
	void Start () {
        //获取所有的骨骼
        allBones.AddRange(transform.GetComponentsInChildren<Transform>());
        GeneraterAvatar();
	}

    void GeneraterAvatar()
    {
        ChangeMeshType(eyes);
        ChangeMeshType(faces);
        ChangeMeshType(hairs);
        ChangeMeshType(pants);
        ChangeMeshType(shoes);
        ChangeMeshType(tops);

        SkinnedMeshRenderer my = this.GetComponent<SkinnedMeshRenderer>();
        //整合所有信息到一个SkinnedMeshRenderer来渲染
        Mesh m = new Mesh();
        m.CombineMeshes(mList.ToArray(),false,false);//合并子网格
        my.sharedMesh = m;
        my.materials = mats.ToArray();
        my.bones = bones.ToArray();
    }

    void ChangeMeshType(List<GameObject> type)
    {
        if (type.Count < 1) return;
        GameObject go = type[Random.Range(0, type.Count)];
        SkinnedMeshRenderer skin = go.GetComponent<SkinnedMeshRenderer>();
        if (skin == null) return;

        //获取部件的网格、材质、骨骼，聚合起来到列表中
        CombineInstance combine = new CombineInstance();
        combine.mesh = skin.sharedMesh;
        mList.Add(combine);
        mats.AddRange(skin.materials);
        GetBones(skin.bones);
    }

    void GetBones(Transform[] termB)
    {
        //遍历得到部位组件对应的骨骼
         foreach (var bb in termB)
         {
            foreach (var b in allBones)
            {
                if (b.name.Equals(bb.name))
                {
                    bones.Add(b);
                }
            }
        }
    }
	
	void Update () {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            ResetAvatar();
            GeneraterAvatar();
        }
	}

    void ResetAvatar()
    {
        mList.Clear();
        bones.Clear();
        mats.Clear();
    }
}

代码就不分析了，注释都有的。记一下合并网格函数的用法：

Mesh.CombineMeshes(CombineInstance[] combine, bool mergeSubMeshes = true, bool useMatrices = true, bool hasLightmapData = false)

第一个参数就是要合并的网格们，网格的定义在combine.mesh；

第二个参数确定是否和合并网格到一个sub mesh中，不是的话各网格会独立开来，使用不同的材质。如果使用的是合并的材质，那么设置为true。

第三个参数确定是否使用CombineInstance.transform

private static StringBuilder ret = new StringBuilder(13);
public static string FormateGoldString(string gold)
{
    ret.Remove(0, ret.Length);
    int length = gold.Length;
    string result = string.Empty;
    if (length > 2)
    {
        ret.Append(gold.Substring(0, length - 2));
        string str2 = gold.Substring(length - 2, 2);
        if (str2 != "00")
        {
            ret.Append(".");
            if (str2[1] == '0')
            {
                ret.Append(str2[0]);
            }
            else
            {
                ret.Append(str2);
            }
        }
    }
    else
    {
        if (length == 1)
        {
            if (gold == "0")
            {
                ret.Append(0);
            }
            else
            {
                ret.Append("0.0");
                ret.Append(gold);
            }
        }
        else
        {
            ret.Append("0.");
            if (gold[1] == '0')
            {
                ret.Append(gold[0]);
            }
            else
            {
                ret.Append(gold);
            }
        }
    }
    return ret.ToString();

}

很简单的就是分析各种可能出现的情况，将小数部分提取出来，加个点连接起来。

Texture2D是在UnityEngine命名空间中的，用来设置NGUI的UITexture的mainTexture属性显示图片，网络下载图片格式等。

一、保存为Png文件

web = UnityWebRequest.GetTexture(codeUrl);
yield return web.Send();
Texture2D t = DownloadHandlerTexture.GetContent(web);
web.Dispose();

string BaseCodePath = System.IO.Path.Combine(Application.persistentDataPath, "qrcode");
if (t != null)
{
    byte[] bts = t.EncodeToPNG();//主要在
    string PathName = BaseCodePath;
    if (!Directory.Exists(PathName))
    {
        Directory.CreateDirectory(PathName);
    }

    File.WriteAllBytes(PathName + "/" + userId.ToString() + ".png", bts);
}

二、加载图片为Texture2D

string BaseCodePath = System.IO.Path.Combine(Application.persistentDataPath, "qrcode");
string filePath = BaseCodePath + "/" + userId.ToString() + ".png";
if (File.Exists(filePath))
{
    byte[] bts = File.ReadAllBytes(filePath);
    Texture2D t = new Texture2D(500, 500);//宽和高
    t.LoadImage(bts);//主要在这里
    Code.mainTexture = t;
}

public static string FormateGoldShow(UInt32 Gold)
{
    double result = Math.Round((double)(1.0f *Gold / 100), 2);

    return (result.ToString());
}

不知道为什么（double的强转导致的），这种方法在电脑上是可以用的，但是到了手机上，精度就开始飘了，各种不准。

所以，我就用字符串解析的方法来格式化整数变小数用来显示了。（字符串解析方式（两位小数））

以前说过，可以控制Debug.unityLogger.logEnabled为false来全局控制输出，但是单单使用Debug.Log不好区分模块，也不好单独调试某一模块，一输出就全部输出了，很乱。

下一个就是自己封装Debug，用不同的方法表示不同模块，使用不同的开关控制模块输出，富文本输出不同的颜色区分，但是双击输出会定位到封装。

所以是封装成dll导入，Unity就不会定位到dll里面，而是上一层。但是，修改添加模块困难，所以这里封装成一个可扩展性的Debug管理器。

using UnityEngine;
namespace DebugLog
{
    public class MyDebug
    {
        public string Name;
        public string Color;
        public bool IsCanDebug = true;

        public MyDebug(string name, string color)
        {
            Name = name;
            Color = color;
        }

        public void Log(string mes)
        {
            if (IsCanDebug == false) return;

            string log = string.Format("<color={0}>{1}:</color>{2}", Color, Name, mes);
            Debug.Log(log);
        }
    }
}

using System.Collections.Generic;
namespace DebugLog
{
    public class DebugManager
    {
        public MyDebug Default = new MyDebug("Default", "yellow");
        public MyDebug UI = new MyDebug("UI","blue");
        public MyDebug Net = new MyDebug("Net", "green");
        public MyDebug Error = new MyDebug("Error", "red");
        public MyDebug Logic = new MyDebug("Logic", "#FF6633");

        private Dictionary<string, MyDebug> dic = new Dictionary<string, MyDebug>();

        public DebugManager()
        {
            dic.Add(Default.Name, Default);
            dic.Add(UI.Name, UI);
            dic.Add(Net.Name, Net);
            dic.Add(Error.Name, Error);
            dic.Add(Logic.Name, Logic);
        }

        public void AddMyDebug(string name, string color)
        {
            if (!dic.ContainsKey(name))
            {
                MyDebug debug = new MyDebug(name, color);
                dic.Add(name,debug);
            }
        }

        public MyDebug GetMyDebug(string name)
        {
            MyDebug debug = Default;
            if (dic.ContainsKey(name))
            {
                debug = dic[name];
            }

            return debug;
        }

        public void OpenAllDebug()
        {
            foreach (var i in dic)
            {
                i.Value.IsCanDebug = true;
            }
        }

        public void CloseAllDebug()
        {
            foreach (var i in dic)
            {
                i.Value.IsCanDebug = false;
            }
        }

        public void DebugOnly(string name)
        {
            if (!dic.ContainsKey(name)) return;

            CloseAllDebug();
            dic[name].IsCanDebug = true;
        }
    }
}

尽可能的把有的模块写成成员变量，方便使用时有提示，而不是使用Add后再用一个字符串的名字去获取这个Debug

实在是需要扩展，就可以直接Add再Get，也不需要重新修改导入dll了

方法lerp是一个根据t来计算插值的，如果已知起始到目标都为固定，如果t每次都几乎一样，那么效果就是一下子快然后慢下来。

所以，就要控制t的大小是由小到大的，提供一个speed速度的概念，从0往上加到最高速度，因为刚开始的差值大，很小的t也会造成计算出来的插值很大，所以前面要控制t的成长变慢，后面再快。

using UnityEngine;

public class ZhuanPanMono : MonoBehaviour {

    public static bool ShowResult = false;
    public static uint Result = 0;
    private float speed = 0f;
    public static float z = 0;

    private float heightSpeed = 3f;
    private float scaleSpeed = 0.18f;

    private Transform go;

	// Use this for initialization
	void Start () {
        go = transform.GetChild(3);
	}
	
	// Update is called once per frame
	void Update () {
        if (!ShowResult) return;

        uint TargetRotation = Result * 45 + 10 * 360;
        z = Mathf.Lerp(z, TargetRotation, Time.deltaTime * speed);
        
        go.rotation = Quaternion.Euler(go.rotation.x,go.rotation.y,z);

        if (speed < heightSpeed) {
            //通过缩放来控制前期速度的增长过快
            speed += Time.deltaTime * scaleSpeed;
        }

        if (scaleSpeed < 1 && speed > 1f) {
            //后期释放加速度的限制缩放
            scaleSpeed += Time.deltaTime;
        }

        if (Mathf.Abs(z - TargetRotation) < 0.1f) {
            //转动结束
            ShowResult = false;
        }
	}
}

2D中，随机一个位置产生物体(如：Sprite)，而产生的这个物体能够被看到，那么这个物体就必须要生成在可视的范围中。

这个范围怎么确定呢？通过视口空间转变为世界坐标就行了。(0,0)表示相机视口的最下方，(1,1)表示相机视口的最上方。

Vector3 up = Camera.main.ViewportToWorldPoint(new Vector3(1, 1, 0));
Vector3 down =  Camera.main.ViewportToWorldPoint(Vector3.zero);

那么x的范围为[down.x,up.x]

y的范围为[down.y,up.y]