Unity Edior下合并场景合并网格合并贴图

最新推荐文章于 2024-04-26 15:37:08 发布

置顶 Q_Qiiii

最新推荐文章于 2024-04-26 15:37:08 发布

阅读量4.5k

点赞数

分类专栏： unity-3d 文章标签：合并场景合并网格

本文链接：https://blog.csdn.net/qq_28663903/article/details/79290426

版权

unity-3d 专栏收录该内容

9 篇文章 2 订阅

订阅专栏

声明：这篇绝不是网上那些转来转去千篇一律的合并方法搜老半天看的都是同一篇博客这里写图片描述
一点帮助都没有还是自己写个吧

1.工程里面合并场景主要是为了降低draw call
2、不同shader的尽量不要合并不同shader 参数的也尽量不要合并
3、本篇博客主要是合并场景里的不会动的不考虑人物只考虑MeshRenderer

步骤：
一、首先要找出场景里用到最多的shader 不一定是一个可能是两个三个个至少这些shader在90%的物体上用到了
二、打开这个场景 EditorSceneManger.OpenScene(path) 在Editor下打开这个场景拿到一个Scene对象
三、用Scene.GetRootGameObjects() 获取到根目录下的游戏物体
四、遍历这个根目录拿到所有符合条件的MeshRenderer组件（材质球只有一个、shader是满足条件的shader、贴图大小满足条件、组件是激活的等等）
五、遍历这些MeshRenderer 将这些按照合并策略分类（我这个项目合并策略是场景里一个15x15的格子里 shader一样、shader参数一样的才进行合并）（坐标|shader|参数为字典的Key List为字典的Value）
六、遍历这个字典的每一项开始进行合并
1、先合并这些对应的贴图我用的是texturePacker进行合并贴图这样省去很多功夫
①写好一个.bat文件用于直接进行命令行处理TexturePacker合并文件
需要设置环境变量
具体参数可以去TexturePacker官网上查

set "Max_Size=%1" 
set "Poweroftow=%2"
set "BorderPadding=%3"
set "ShapePadding=%4"
set "TargetPath=%5"
set "SourcePaths=%~6"

TexturePacker --sheet %TargetPath%_tp{n}.tga ^
--data %TargetPath%_tp{n}_cfg.txt ^
--texture-format tga ^
--disable-rotation ^
--format unity ^
--multipack  ^
--max-size %Max_Size% ^
--trim-mode None ^
--extrude 0 ^
--opt RGBA8888 ^
--png-opt-level 2 ^
--border-padding %BorderPadding% ^
--shape-padding %ShapePadding% ^
--disable-auto-alias ^
--size-constraints %Poweroftow%  %SourcePaths%

②先将要合并的资源拷呗到一个文件夹下
③然后执行这个.bat文件具体怎么执行用Process 类再具体就百度吧
④执行完之后合并出来的可能不只一张图片如果超过一张图片就要重新合并此时要讲原来的MeshRenderer二分，用递归再次合并两个一半的MeshRenderer数组直到合并出来只有一个图集同时会生成一个cfg配置文件用来显示原来的图片在生成的图片在那一部分
2、贴图合并成功之后就该进行网格合并了
①拿到上一步贴图合并成功的MeshRenderer数组再拿到MeshRenderer对象上的MeshFilter身上的sharedMesh
②用Unity Api Mesh.Combine(CombineInstance[]) 进行合并网格
3、网格合并成功之后要修改这个网格的UV坐标
一个网格有多少个顶点就有多少个Uv坐标这个坐标用来控制这个顶点显示图片上哪一部分的内容
所以这一步很重要要重新刷一遍网格的所有UV坐标
根据之前合并贴图成功时生成的配置文件，这个文件是个Json文件,
将原来的MeshUV 根据映射转换成大的图集上的UV坐标
4、创建个空物体带有MeshRenderer MeshFilter 的组件用于接收生成的网格和材质球
创建材质球设置shader 和参数和贴图
给MeshRenderer设置这个材质球 MeshFilter设置这个Mesh
5、最后将生成的Material 和Mesh 分别生成一个资源 AssetDatabase.CreateAssert(Obejc,path)
因为之前生成的Material和Mesh只是在内存里一切换场景就没有了所有要生成.asset文件

代码：

using UnityEngine;
using System.Collections;
using UnityEditor;
using System;
using UnityEditor.SceneManagement;
using System.Linq;
using System.Collections.Generic;
using System.IO;

public class CombineTool : Editor
{
    private const int GRIDSIDE = 15;
    private const string PATH = "Assets/Resources/scene/";
    private static string ASSET_PATH = EditorConfig.assetPath;

    [MenuItem("Test/Test")]
    public static void Test()
    {
    }

    [MenuItem("Debug/合并场景不烘焙")]
    public static void CombineSceneNotBake()
    {
        CombineScene(false);
    }

    /// <summary>
    /// 合并所有场景
    /// </summary>
    /// <param name="bake"></param>
    private static void CombineScene(bool bake)
    {
       var files=AssetDatebase.GetAllAssetPath().where(s=>s.EndWith(".unity"));
       foreach(var item in files){
        CombineOneScene(item, bake);
       }  
        EditorUtility.ClearProgressBar();
    }
    /// <summary>
    /// 合并一个场景
    /// </summary>
    /// <param name="path"></param>
    private static void CombineOneScene(string path, bool bake)
    {
        var scene = EditorSceneManager.OpenScene(path);
        PBTitle = "正在合并场景：" + scene.name;
        SceneData sd = GetSceneData(scene);
        if (sd == null) return;
        var combineGO = CreatCombineObj(scene);
        var dic = ClassifyByPositionAndShaderAndProprity(scene);
        int count = 0;
        foreach (var item in dic)
        {
            PBContent = count + "/" + dic.Count;
            PBProcess = (float)count / dic.Count;
            string[] ss = item.Key.Split('|');   //0是坐标 1是shader 2是颜色 3是cutoff值
            Combine(item.Value.Where(s => s != null).ToArray(), scene.name, ref count, ss, combineGO.transform);
        }
        sd.Export(bake);
        Debug.Log("合并场景：" + scene.name);
    }

    /// <summary>
    /// 指定位置创建一个Combine物体 用于存放合并后的物体
    /// </summary>
    /// <param name="scene"></param>
    /// <returns></returns>
    private static GameObject CreatCombineObj(UnityEngine.SceneManagement.Scene scene)
    {
        var roots = scene.GetRootGameObjects();
        GameObject combineGO = new GameObject("Combine");
        foreach (var item in roots)
        {
            if (item.name == scene.name)
            {
                combineGO.transform.SetParent(item.transform);
                break;
            }
        }
        return combineGO;
    }
    /// <summary>
    /// 获取场景里的所有只有一个材质球的MeshRenderer shader为Scene/Diffuse  或者 是 Scene/Cutout/Diffuse  且 贴图长和宽不能大于1024
    /// </summary>
    /// <param name="s"></param>
    private static MeshRenderer[] GetAllMeshsInScene(UnityEngine.SceneManagement.Scene scene)
    {
        PBState = "查找符合标准的MeshRenderer";
        const int texture_MaxSize = 1024;
        var roots = scene.GetRootGameObjects();
        var meshrenders = new List<MeshRenderer>();
        foreach (var item in roots)
        {
            meshrenders.AddRange(item.GetComponentsInChildren<MeshRenderer>());
        }
        return meshrenders.Where(s => s
        && s.enabled == true
        && s.sharedMaterials.Length == 1
        && s.sharedMaterial
        && (s.sharedMaterial.shader.name == "scenes/Diffuse"
        || s.sharedMaterial.shader.name == "scenes/Cutout/Diffuse")
        && s.sharedMaterial.GetTexture("_MainTex")
        && s.sharedMaterial.GetTexture("_MainTex").texelSize.x <= texture_MaxSize
        && s.sharedMaterial.GetTexture("_MainTex").texelSize.y <= texture_MaxSize)
        .ToArray();
    }
    /// <summary>
    /// 保存资源
    /// </summary>
    /// <param name="go">对象</param>
    /// <param name="path">相对于Resource/scene/的路经</param>
    /// <param name="name">名字</param>
    private static void CreateAsset(UnityEngine.Object go, string path, string name)
    {
        PBState = "保存资源";
        if (!Directory.Exists(PATH + path)) Directory.CreateDirectory(PATH + path);
        AssetDatabase.CreateAsset(go, PATH + path + "/" + name);
    }
    /// <summary>
    /// 根据坐标，shader，参数分类
    /// </summary>
    /// <param name="meshrenderers"></param>
    private static Dictionary<string, List<MeshRenderer>> ClassifyByPositionAndShaderAndProprity(UnityEngine.SceneManagement.Scene scene)
    {
        PBState = "分类MeshRenderer";
        Dictionary<string, List<MeshRenderer>> dic = new Dictionary<string, List<MeshRenderer>>();
        foreach (var item in GetAllMeshsInScene(scene))
        {
            Material mt = item.sharedMaterial;
            string tag;
            if (mt.shader.name == "scenes/Cutout/Diffuse")
                tag = GetGridIndex(item.transform) + "|" + mt.shader.name + "|" + mt.GetColor("_Color") + "|" + mt.GetFloat("_Cutoff");
            else
                tag = GetGridIndex(item.transform) + "|" + mt.shader.name + "|" + mt.GetColor("_Colors");
            if (!dic.ContainsKey(tag))
            {
                dic.Add(tag, new List<MeshRenderer>() { item });
            }
            else
            {
                dic[tag].Add(item);
            }
        }
        //清除只有1个的List
        List<string> checkOneRenderList = new List<string>();
        foreach (var item in dic)
        {
            if (item.Value.Count == 1) checkOneRenderList.Add(item.Key);
        }
        foreach (var item in checkOneRenderList)
        {
            dic.Remove(item);
        }
        return dic;
    }
    /// <summary>
    /// 合并网格
    /// </summary>
    /// <param name="renderers"></param>
    ///  <param name="filePath">_tp0_cfg.txt的路径</param>
    /// <returns></returns>
    private static Mesh CombineMesh(MeshRenderer[] renderers, string filePath)
    {
        PBState = "合并网格";
        var dicOfPackFrame = GetPackedFram(filePath);//根据图片名称 拿到在合并后的图片里的信息
        List<Vector2> uvs = new List<Vector2>();   //存放原来的Mesh的UV
        CombineInstance[] cis = new CombineInstance[renderers.Length];
        int uvCount = 0;
        for (int i = 0; i < cis.Length; i++)
        {
            cis[i].mesh = renderers[i].GetComponent<MeshFilter>().sharedMesh;
            cis[i].transform = renderers[i].transform.localToWorldMatrix;
            Texture t = renderers[i].sharedMaterial.GetTexture("_MainTex");
            string textureName = Path.GetFileName(AssetDatabase.GetAssetPath(t));
            uvs.AddRange(cis[i].mesh.uv.Select(s => TransfromUV(s, dicOfPackFrame[textureName], t.wrapMode)).ToArray());
            uvCount += cis[i].mesh.uv.Length;
        }
        Mesh m = new Mesh();
        m.CombineMeshes(cis, true, true);
        m.uv = uvs.ToArray();
        return m;
    }
    /// <summary>
    /// 合并   合并一个List MeshRnder 的  整个逻辑
    /// </summary>
    /// <param name="renderers"></param>
    /// <param name="sceneName">场景名称 用于标记</param>
    /// <param name="index">计数器</param>
    /// <param name="parameter">material的各个参数   //0是坐标 1是shader 2是颜色 3是cutoff值</param>
    /// <param name="combineRoot">合并的根物体 所有合并产生的物体都要放到这个物体下面</param>
    /// <returns></returns>
    private static void Combine(MeshRenderer[] renderers, string sceneName, ref int index, string[] parameter, Transform combineRoot)
    {
        if (renderers.Length < 2) return;
        PBState = "合并";
        var textures = renderers.Select(s => {
            if (s == null)
            {
                Debug.Log(s);
                Debug.Log("有贴图为空");
            }
            return s.sharedMaterial ? s.sharedMaterial.GetTexture("_MainTex") : null;
        });
        var texturePaths = textures.Select(s => ASSET_PATH + AssetDatabase.GetAssetPath(s)).ToArray();//获取贴图的绝对路径 
        string path = CopyFileToDirectiory(texturePaths, PATH + sceneName + "/" + index);//将其拷呗到指定文件夹下
        if (CombineTexture(path))//若果合并成功
        {
            Mesh m = CombineMesh(renderers, path + "/_tp0_cfg.txt");
            Texture t = AssetDatabase.LoadAssetAtPath<Texture>(path + "/_tp0.tga");
            Material mat = new Material(Shader.Find(parameter[1]));
            if (parameter[1].Contains("Cutoff"))
            {
                mat.SetColor("_Color", ColorParse(parameter[2]));
                mat.SetFloat("_Cutoff", float.Parse(parameter[3]));
            }
            else
            {
                mat.SetColor("_Colors", ColorParse(parameter[2]));
            }
            mat.SetTexture("_MainTex", t);
            GameObject go = new GameObject(index + "", typeof(MeshRenderer), typeof(MeshFilter));
            go.transform.SetParent(combineRoot.transform);
            go.GetComponent<MeshFilter>().sharedMesh = m;
            go.GetComponent<MeshRenderer>().sharedMaterial = mat;
            CreateAsset(m, sceneName + "/" + index, index + "_mesh.asset");
            CreateAsset(mat, sceneName + "/" + index, index + "_mat.asset");
            index++;
            foreach (var item in renderers)
            {
                if (item) DestroyImmediate(item.gameObject, false);
            }
        }
        else//合并贴图失败
        {
            if (renderers.Length > 2)
            {
                MeshRenderer[] r1 = new MeshRenderer[renderers.Length / 2];
                MeshRenderer[] r2 = new MeshRenderer[renderers.Length - r1.Length];
                for (int i = 0; i < r1.Length; i++)
                {
                    r1[i] = renderers[i];
                }
                for (int i = 0; i < r2.Length; i++)
                {
                    r2[i] = renderers[r1.Length + i];
                }
                if (r1.Length > 1) Combine(r1, sceneName, ref index, parameter, combineRoot);
                Combine(r2, sceneName, ref index, parameter, combineRoot);
            }
        }
    }
    /// <summary>
    /// 找到一个场景里的SceneData
    /// </summary>
    /// <param name="scene"></param>
    /// <returns></returns> 
    private static SceneData GetSceneData(UnityEngine.SceneManagement.Scene scene)
    {
        var roots = scene.GetRootGameObjects();
        foreach (var item in roots)
        {
            SceneData m = item.GetComponentInChildren<SceneData>();
            if (m) return m;
        }
        return null;
    }

    /// <summary>
    /// 输入一个原本的uv 转换成合并后贴图的uv
    /// </summary>
    /// <param name="uv"></param>
    /// <param name="packedFrame"></param>
    /// <param name="twm">5.3.7版本 只有两种 以后可能会有多种</param>
    /// <returns></returns>
    /// 
    static int tempppp = 0;
    private static Vector2 TransfromUV(Vector2 uv, TexturePacker.PackedFrame packedFrame, TextureWrapMode twm)
    {
        Vector2 temp = uv;
        Vector2 temp2 = uv;
        Vector2 temp3 = uv;
        Vector2 temp4 = uv;
        if (twm == TextureWrapMode.Clamp)
        {
            uv.x = Mathf.Clamp(uv.x, 0, 1);
            uv.y = Mathf.Clamp(uv.y, 0, 1);
        }
        else if (twm == TextureWrapMode.Repeat)//*****************以后可能会有多种
        {
            uv.x = Mathf.Repeat(uv.x, 1);
            uv.y = Mathf.Repeat(uv.y, 1);
        }
        Vector2 altaSize = packedFrame.atlasSize;
        Rect frame = packedFrame.frame;
        Vector2 smallZuoxiaJiao = new Vector2(frame.x, altaSize.y - frame.y - frame.height);//原来图片的左下角相对于合并后的图片的位置
        Vector2 point = new Vector2(smallZuoxiaJiao.x + Mathf.CeilToInt(uv.x * frame.width), smallZuoxiaJiao.y + Mathf.CeilToInt(uv.y * frame.height));
        Vector2 result = new Vector2(point.x / altaSize.x, point.y / altaSize.y);
        return result;
    }

    /// <summary>
    /// 合并一个路径下的图片 还是放在这个路径下
    /// </summary>
    /// <param name="path"> 绝对路径 最后不要加/</param>
    private static bool CombineTexture(string path)
    {
        PBState = "合并贴图";
        string[] files = Directory.GetFiles(path);
        var maxSize = 2048;
        var poweroftow = "POT";
        var borderPadding = 0;
        var shapePadding = 0;
        var command = GlobalEditorHelper.GetAssetsPath(ASSET_PATH + PATH + "combinetexture.bat");
        Util.ExecuteCmd(EditorConfig.processPath, command, string.Format(" {0} {1} {2} {3} {4} {5}", maxSize, poweroftow, borderPadding, shapePadding, path + "/", path));
        foreach (var item in files)
        {
            File.Delete(item);
        }
        if (Directory.GetFiles(path).Length > 2)  //如果大于2 说明合并了1个以上的贴图
        {
            foreach (var item in Directory.GetFiles(path))
            {
                File.Delete(item);
            }
            return false;
        }
        else
        {
            AssetDatabase.Refresh();
            return true;
        }
    }

    /// <summary>
    /// 将一个txt文件解析成List PacekdFram
    /// </summary>
    /// <param name="path"></param>
    private static Dictionary<string, TexturePacker.PackedFrame> GetPackedFram(string path)
    {
        TextAsset txt = AssetDatabase.LoadAssetAtPath<TextAsset>(path.Substring(path.IndexOf("Assets")));
        if (txt == null) Debug.Log(path);
        TexturePacker.MetaData meta = TexturePacker.GetMetaData(txt.text);
        Hashtable table = txt.text.hashtableFromJson();
        List<TexturePacker.PackedFrame> frames = new List<TexturePacker.PackedFrame>();
        Hashtable frameTable = (Hashtable)table["frames"];
        foreach (DictionaryEntry entry in frameTable)
        {
            frames.Add(new TexturePacker.PackedFrame((string)entry.Key, meta.size, (Hashtable)entry.Value));
        }
        return frames.ToDictionary(s => s.name, s => s);
    }

    /// <summary>
    /// 拷呗一些文件 到另一个文件夹下面
    /// </summary>
    /// <param name="files"></param>
    /// <param name="path">绝对路径 最后不要加斜线</param>
    private static string CopyFileToDirectiory(string[] files, string path)
    {

        PBState = "拷呗贴图";
        if (!Directory.Exists(path)) Directory.CreateDirectory(path);
        foreach (var item in files)
        {
            if (File.Exists(item)) File.Copy(item, path + "/" + item.Substring(item.LastIndexOf('/')), true);
        }
        return path;
    }

    /// <summary>
    /// 将一个特定字符串解析成Color 
    /// </summary>
    /// <param name="s"></param>
    /// <returns></returns>
    private static Color ColorParse(string s)
    {
        s = s.Substring(5, s.Length - 6);
        string[] ss = s.Split(',');
        return new Color(float.Parse(ss[0]), float.Parse(ss[1]), float.Parse(ss[2]), float.Parse(ss[3]));
    }
    /// <summary>
    /// 判读两个物体是不是在同一个格子里
    /// </summary>
    /// <param name="t1"></param>
    /// <param name="t2"></param>
    /// <returns></returns>
    private static bool InSameGrid(Transform t1, Transform t2)
    {
        return (GetGridIndex(t1) == GetGridIndex(t2));
    }
    /// <summary>
    /// 计算一个物体的格子坐标
    /// </summary>
    /// <param name="t"></param>
    /// <returns></returns>
    private static Vector2 GetGridIndex(Transform t)
    {
        return new Vector2((int)(t.position.x / GRIDSIDE), (int)(t.position.z / GRIDSIDE));
    }
}

BUT!!!
There is a big Problem.
如果原来贴图的格式是Clamp格式的那么以上代码完全可行
如果是Repeat格式的就非常有可能不可行
因为转换UV坐标时要将原来的UV坐标给Math.Clamp 或者 Math.Repeat 处理到0~1
假如两个相邻的顶点uv坐标是（0.9,0.5）（1.1,0.5）那么这两个点之间本应该draw 0.2个单位
经过Math.Repeat处理一下之后就变成了（0.9,0.5）(0.1,0.5) 那么这两个点之间就会draw 0.8个单位而且还是反着draw的
所以这个问题基本上无法避免
而且很无奈的是要自己处理这个问题会非常费时费力遇到这种情况就要用插件了
推荐一款MeshBaker插件 AssetStore 有免费版的
但是这个插件是一步一步操作的所以要写工具一键全部合并还是得靠自己写代码
下载完插件之后以下代码就能运行了
代码：

using UnityEngine;
using System.Collections;
using UnityEditor;
using System;
using UnityEditor.SceneManagement;
using System.Linq;
using System.Collections.Generic;
using System.IO;
using DigitalOpus.MB.Core;

public class CombineTool : Editor
{
    private const int GRIDSIDE = 15;
    private const string PATH = "Assets/Resources/scene/";
    private static string ASSET_PATH = EditorConfig.assetPath;
    private const string LAYER_NAME = "block";
    #region ProgressBar
    private static string title = "";
    private static string PBTitle
    {
        set
        {
            title = value;
            EditorUtility.DisplayProgressBar(title, content + "   " + state, process);
        }
        get { return title; }
    }
    private static string content = "";
    private static string PBContent
    {
        get { return content; }
        set
        {
            content = value;
            EditorUtility.DisplayProgressBar(title, content + "   " + state, process);
        }
    }
    private static string state = "";
    private static string PBState
    {
        get { return state; }
        set
        {
            state = value;
            EditorUtility.DisplayProgressBar(title, content + "   " + state, process);
        }
    }
    private static float process = 0;
    private static float PBProcess
    {
        get { return process; }
        set
        {
            process = value;
            EditorUtility.DisplayProgressBar(title, content + "   " + state, process);
        }
    }
    #endregion

    [MenuItem("Debug/合并场景不烘焙")]
    public static void CombineSceneNotBake()
    {
        CombineScene(false);
    }

    /// <summary>
    /// 合并所有场景
    /// </summary>
    /// <param name="bake"></param>
    private static void CombineScene(bool bake)
    {
          var scenes = AssetDatabase.GetAllAssetPaths().Where(s => s.EndsWith(".unity"));
          foreach (var item in scenes)
          {
              CombineOneScene(item, bake);
          }
      //  CombineOneScene("Assets/Scenes/Scenes01_PLZZ.unity",bake);
        EditorUtility.ClearProgressBar();
    }
    /// <summary>
    /// 合并一个场景
    /// </summary>
    /// <param name="path"></param>
    private static void CombineOneScene(string path, bool bake)
    {
        var scene = EditorSceneManager.OpenScene(path);
        PBTitle = "正在合并场景：" + scene.name;
        SceneData sd = GetSceneData(scene);
        if (sd == null) return;
        var combineGO = CreatCombineObj(scene);
        var dic = ClassifyByPositionAndShaderAndProprity(scene);
        if (dic.Count == 0)
        {
            sd.Export(bake);
            return;
        }
        string directory = PATH + scene.name + "/";
        if (!Directory.Exists(directory)) Directory.CreateDirectory(directory);
        int count = 0;
        foreach (var item in dic)
        {
            PBContent = count + "/" + dic.Count;
            PBProcess = (float)count / dic.Count;
            Combine(item.Value.Where(s => s != null).Select(s => s.gameObject).ToArray(), scene, ref count, combineGO.transform, directory);
        }
        sd.Export(bake);
        Debug.Log("合并场景：" + scene.name);
    }

    /// <summary>
    /// 指定位置创建一个Combine物体 用于存放合并后的物体
    /// </summary>
    /// <param name="scene"></param>
    /// <returns></returns>
    private static GameObject CreatCombineObj(UnityEngine.SceneManagement.Scene scene)
    {
        var roots = scene.GetRootGameObjects();
        GameObject combineGO = new GameObject("Combine");
        foreach (var item in roots)
        {
            if (item.name == scene.name)
            {
                combineGO.transform.SetParent(item.transform);
                break;
            }
        }
        return combineGO;
    }
    /// <summary>
    /// 获取场景里的所有只有一个材质球的MeshRenderer shader为Scene/Diffuse  或者 是 Scene/Cutout/Diffuse  且 贴图长和宽不能大于1024
    /// </summary>
    /// <param name="s"></param>
    private static MeshRenderer[] GetAllMeshsInScene(UnityEngine.SceneManagement.Scene scene)
    {
        const int texture_MaxSize = 1024;
        var roots = scene.GetRootGameObjects();
        var meshrenders = new List<MeshRenderer>();
        GameObject combineGO = new GameObject("Combine");
        foreach (var item in roots)
        {
            if (item.name == scene.name)
            {
                combineGO.transform.SetParent(item.transform);
                meshrenders.AddRange(item.GetComponentsInChildren<MeshRenderer>());
                break;
            }
        }
        foreach (var item in meshrenders.Where(s => s.gameObject.layer == LayerMask.NameToLayer(LAYER_NAME)))
        {
            item.transform.SetParent(combineGO.transform);
        } 
        return meshrenders.Where(s => s
        && s.gameObject.layer!=LayerMask.NameToLayer(LAYER_NAME)
        && s.enabled == true
        && s.sharedMaterials.Length == 1
        && s.sharedMaterial
        && (s.sharedMaterial.shader.name == "scenes/Diffuse"
        || s.sharedMaterial.shader.name == "scenes/Cutout/Diffuse")
        && s.sharedMaterial.GetTexture("_MainTex")
        && s.sharedMaterial.GetTexture("_MainTex").texelSize.x <= texture_MaxSize
        && s.sharedMaterial.GetTexture("_MainTex").texelSize.y <= texture_MaxSize)
        .ToArray();
    }

    /// <summary>
    /// 根据坐标，shader，参数分类
    /// </summary>
    /// <param name="meshrenderers"></param>
    private static Dictionary<string, List<MeshRenderer>> ClassifyByPositionAndShaderAndProprity(UnityEngine.SceneManagement.Scene

scene)
    {
        Dictionary<string, List<MeshRenderer>> dic = new Dictionary<string, List<MeshRenderer>>();
        foreach (var item in GetAllMeshsInScene(scene))
        {
            Material mt = item.sharedMaterial;
            string tag;
            if (mt.shader.name == "scenes/Cutout/Diffuse")
                tag = GetGridIndex(item.transform) + "|" + mt.shader.name + "|" + mt.GetColor("_Color") + "|" + mt.GetFloat

("_Cutoff");
            else
                tag = GetGridIndex(item.transform) + "|" + mt.shader.name + "|" + mt.GetColor("_Colors");
            if (!dic.ContainsKey(tag))
            {
                dic.Add(tag, new List<MeshRenderer>() { item });
            }
            else
            {
                dic[tag].Add(item);
            }
        }
        //清除只有1个的List
        List<string> checkOneRenderList = new List<string>();
        foreach (var item in dic)
        {
            if (item.Value.Count == 1) checkOneRenderList.Add(item.Key);
        }
        foreach (var item in checkOneRenderList)
        {
            dic.Remove(item);
        }
        return dic;
    }
    /// <summary>
    /// 合并   合并一个List MeshRnder 的  整个逻辑
    /// </summary>
    /// <param name="renderers"></param>
    /// <param name="sceneName">场景名称 用于标记</param>
    /// <param name="index">计数器</param>
    /// <param name="parameter">material的各个参数   //0是坐标 1是shader 2是颜色 3是cutoff值</param>
    /// <param name="combineRoot">合并的根物体 所有合并产生的物体都要放到这个物体下面</param>
    /// <returns></returns>
    private static void Combine(GameObject[] gos, UnityEngine.SceneManagement.Scene scene, ref int index, Transform

combineRoot, string directory)
    {
        if (gos.Length < 2) return;
        GameObject tempgo = new GameObject(scene.name + "_combine_" + index);
        tempgo.transform.SetParent(combineRoot);

        GameObject meshbaker = MB3_MeshBakerEditor.CreateNewMeshBaker();
        meshbaker.transform.SetParent(tempgo.transform);
        MB3_TextureBaker mbtb = meshbaker.GetComponent<MB3_TextureBaker>();
        MB3_MeshBaker mbmb = meshbaker.GetComponentInChildren<MB3_MeshBaker>();
        mbtb.fixOutOfBoundsUVs = true;
        mbtb.maxAtlasSize = 2048;
        mbtb.maxTilingBakeSize = 1024;
        mbtb.atlasPadding = 0;
        mbtb.considerNonTextureProperties = true;
        mbtb.meshBakerTexturePackerForcePowerOfTwo = true;
        mbtb.objsToMesh = gos.ToList();
        //mbtb.textureBakeResults  这个赋值会包含在下面这个方法里
        MB3_TextureBakerEditorInternal.CreateCombinedMaterialAssets(mbtb, directory + index + ".asset");
        mbtb.CreateAtlases(null, true, new MB3_EditorMethods());
        if (mbtb.textureBakeResults != null) EditorUtility.SetDirty(mbtb.textureBakeResults);

        mbmb.textureBakeResults = mbtb.textureBakeResults;
        mbmb.CombinedMeshContains(tempgo);
        mbmb.useObjsToMeshFromTexBaker = true;
        mbmb.meshCombiner.doNorm = true;
        mbmb.meshCombiner.doTan = true;
        mbmb.meshCombiner.doUV = true;
        mbmb.resultPrefab = tempgo;
        mbmb.meshCombiner.outputOption = MB2_OutputOptions.bakeIntoSceneObject;
        mbmb.meshCombiner.resultSceneObject = tempgo;
       // mbmb.meshCombiner.targetRenderer = tempgo.AddComponent<MeshRenderer>();
        mbmb.meshCombiner.Apply();
        MB3_MeshBakerEditorInternal.bake(mbmb);

        Mesh tempMesh = tempgo.GetComponentInChildren<MeshFilter>().sharedMesh;
        AssetDatabase.CreateAsset(tempMesh, directory + "/" + index + "-mesh.asset");
        index++;
        foreach (var item in gos)
        {
            DestroyImmediate(item, false);
        }
        DestroyImmediate(meshbaker);
    }
    /// <summary>
    /// 找到一个场景里的SceneData
    /// </summary>
    /// <param name="scene"></param>
    /// <returns></returns> 
    private static SceneData GetSceneData(UnityEngine.SceneManagement.Scene scene)
    {
        var roots = scene.GetRootGameObjects();
        foreach (var item in roots)
        {
            SceneData m = item.GetComponentInChildren<SceneData>();
            if (m) return m;
        }
        return null;
    }


    /// <summary>
    /// 判读两个物体是不是在同一个格子里
    /// </summary>
    /// <param name="t1"></param>
    /// <param name="t2"></param>
    /// <returns></returns>
    private static bool InSameGrid(Transform t1, Transform t2)
    {
        return (GetGridIndex(t1) == GetGridIndex(t2));
    }
    /// <summary>
    /// 计算一个物体的格子坐标
    /// </summary>
    /// <param name="t"></param>
    /// <returns></returns>
    private static Vector2 GetGridIndex(Transform t)
    {
        return new Vector2((int)(t.position.x / GRIDSIDE), (int)(t.position.z / GRIDSIDE));
    }

}

代码简单了很多。。。
而且不会有上述那种棘手的问题。
这个插件处理上述问题是通过合并贴图的时候压缩一下，分析UV坐标，可能合并很多张一样的，可能会进行拉伸或者缩放
这些反正都不用自己考虑了

Q_Qiiii

关注

0
点赞
踩
16

收藏

觉得还不错? 一键收藏
2
评论
Unity Edior下合并场景合并网格合并贴图

声明：这篇绝不是网上那些转来转去千篇一律的合并方法搜老半天看的都是同一篇博客一点帮助都没有还是自己写个吧1.工程里面合并场景主要是为了降低draw call 2、不同shader的尽量不要合并不同shader 参数的也尽量不要合并 3、本篇博客主要是合并场景里的不会动的不考虑人物只考虑MeshRenderer步骤：一、首先要找出场景里用到最多的shader ...
复制链接

扫一扫