Unity5.x 动态加载lightmaps(烘培贴图)

using UnityEngine;

using System.Linq;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;

[System.Serializable]
public class Texture2Ds
{
    public Texture2D[] LightMap;
}

internal class LightmapDatas
{
    internal LightmapData[] LightData;
}

public class CC_LightMapSwitch : MonoBehaviour
{
    public int LightingMapsIndex = 0;
    public Texture2Ds[] LightingMaps;
    private List<LightmapDatas> LightingDatas = new List<LightmapDatas> ();

    void Start ()
    {
        if (LightingMaps.Length > 0) {

            for (int i = 0; i < LightingMaps.Length; i++) {
                LightmapDatas LtD = new LightmapDatas ();
                LightingDatas.Add (LtD);
            }
            for (int i = 0; i < LightingMaps.Length; i++) {
                Texture2D[] Near = LoadLightMapsAsset (LightingMaps [i].LightMap, "dir",i);
                Texture2D[] Far = LoadLightMapsAsset (LightingMaps [i].LightMap, "light",i);
                if (Near.Length != Far.Length) {
                    Debug.Log ("LightingMaps[" + i + "]里的远近贴图不一致.dir的数量为:" + Near.Length + ",light的数量为:" + Far.Length + ".");
                    return;
                }

                Near = Near.OrderBy (t2d => t2d.name, new NaturalSortComparer<string> ()).ToArray ();
                Far = Far.OrderBy (t2d => t2d.name, new NaturalSortComparer<string> ()).ToArray ();

                LightingDatas [i].LightData = new LightmapData[Near.Length];
                for (int j=0; j<LightingDatas[i].LightData.Length; j++) {
                    LightingDatas [i].LightData [j] = new LightmapData ();
                    LightingDatas [i].LightData [j].lightmapNear = Near [j];
                    LightingDatas [i].LightData [j].lightmapFar = Far [j];
                }
            }
        }
    }

    public Texture2D[] LoadLightMapsAsset (Texture2D[] texture, string Distance,int Idx)
    {
        //int len = texture.Length * 0.5;
        Texture2D[] objList = new Texture2D[texture.Length / 2];
        try {
            int j = 0;
            for (int i = 0; i < texture.Length; i++) {
                string p = texture [i].name;
                if (p.EndsWith (Distance)) {
                    objList [j] = texture [i];    
                    j++;
                }
            }
        } catch (System.Exception ex) {
            Debug.Log ("加载LightingMaps["+Idx+"]的时候"+Distance+"为空");
        }
        if (objList.Length > 0)
            return objList;
        return null;
    }

    public static string[] SplitWithString (string sourceString, string splitString)
    {
        string tempSourceString = sourceString;
        List<string> arrayList = new List<string> ();  
        string s = string.Empty;  
        while (sourceString.IndexOf(splitString) > -1) {  //切割  
            s = sourceString.Substring (0, sourceString.IndexOf (splitString));  
            sourceString = sourceString.Substring (sourceString.IndexOf (splitString) + splitString.Length);  
            arrayList.Add (s);  
        } 
        arrayList.Add (sourceString); 
        return arrayList.ToArray ();  
    }
    #region Publics
    public void setToLightmapDate (int Idx)
    {
        try {
            LightmapSettings.lightmaps = LightingDatas [Idx].LightData;
        } catch (System.Exception ex) {
            Debug.Log ("LightMapsIndex可能超过LightingMaps的界限或你的LightingMaps没加载成功,错误:" + ex);
        }
    }
    #endregion
    
    #region Debug
    [ContextMenu ("Set to LightMaps")]
    void LightMapsInspactor ()
    {
        setToLightmapDate (LightingMapsIndex);
    }
    #endregion
}

using UnityEngine;
using System.Collections;
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class NaturalSortComparer<T> : IComparer<string>, IDisposable
{
    private readonly bool isAscending;
    
    public NaturalSortComparer(bool inAscendingOrder = true)
    {
        this.isAscending = inAscendingOrder;
    }
    
    #region IComparer<string> Members
    public int Compare(string x, string y)
    {
        throw new NotImplementedException();
    }
    #endregion
    
    #region IComparer<string> Members
    int IComparer<string>.Compare(string x, string y)
    {
        if (x == y)
            return 0;
        
        string[] x1, y1;
        
        if (!table.TryGetValue(x, out x1))
        {
            x1 = Regex.Split(x.Replace(" ", ""), "([0-9]+)");
            table.Add(x, x1);
        }
        
        if (!table.TryGetValue(y, out y1))
        {
            y1 = Regex.Split(y.Replace(" ", ""), "([0-9]+)");
            table.Add(y, y1);
        }
        
        int returnVal;
        
        for (int i = 0; i < x1.Length && i < y1.Length; i++)
        {
            if (x1[i] != y1[i])
            {
                returnVal = PartCompare(x1[i], y1[i]);
                return isAscending ? returnVal : -returnVal;
            }
        }
        
        if (y1.Length > x1.Length)
        {
            returnVal = 1;
        }
        else if (x1.Length > y1.Length)
        {
            returnVal = -1;
        }
        else
        {
            returnVal = 0;
        }
        
        return isAscending ? returnVal : -returnVal;
    }
    
    private static int PartCompare(string left, string right)
    {
        int x, y;
        if (!int.TryParse(left, out x))
            return left.CompareTo(right);
        
        if (!int.TryParse(right, out y))
            return left.CompareTo(right);
        
        return x.CompareTo(y);
    }
    #endregion
    
    private Dictionary<string, string[]> table = new Dictionary<string, string[]>();
    
    public void Dispose()
    {
        table.Clear();
        table = null;
    }
}