Unity3D静态对象优化系列

 Unity3D对于静态对象优化，一种方式是使用Unity自带的功能比如可以选择Static，这样Unity引擎内部会对其进行优化批处理，无需使用者关心，比较简单，但是还是不够理想。另一种方式是我们用脚本进行控制，用脚本对其进行优化，相对前者效率方面比如在DrawCall上可以减少。接下来我们逐步解析，优化直至达到我们的要求为止，本次作为一个系列来讲解，为了让大家更能透彻的理解。

   我们先看一下，没选择Static和选择Static的比较结果，我们是以三个Cube为例采用同样的材质，如图所示：

 

 

基本上没啥影响，这说明Unity会自动为我们处理的，但是这不是我们需要的结果，接下来我们去优化它，优化的思路就是将这三个对象根据其MeshFilter将其组合成一个大的Mesh，这个Mesh是我们自己生成的，最后将材质赋值给它。接下来我们书写代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

using  UnityEngine; using  System.Collections; public  class  Combine : MonoBehaviour {      void  Start()      {          MeshFilter[] meshFilters = GetComponentsInChildren<MeshFilter>();          CombineInstance[] combine =  new  CombineInstance[meshFilters.Length];          for  ( int  i = 0; i < meshFilters.Length; i++)          {              combine[i].mesh = meshFilters[i].sharedMesh;              combine[i].transform = meshFilters[i].transform.localToWorldMatrix;              meshFilters[i].gameObject.active =  false ;          }          transform.GetComponent<MeshFilter>().mesh =  new  Mesh();          transform.GetComponent<MeshFilter>().mesh.CombineMeshes(combine);          transform.gameObject.active =  true ;                } }

以上是代码实现，那我们如何去绑定到对象上，首先我们需要给对象加一个MeshFilter组件，为了操作方便直接将一个对象拿过来使用.如图所示：

 

图中画圆圈的地方，接下来我们将我们的脚本挂接到上面去。实现效果如下图：

相比于我们上图通过Unity自身优化，Draw Call明显减少了，达到了我们的目的，但是还有一个问题，就是用这种方式，优化后，模型位置发生了偏移。这个不是我们想要的。还有以上是相同材质，如果我们换成不同的材质，不加脚本如下图所示：

那如果我们加上优化脚本，情况如下：

红色的箱子不见了，所以这么做是不允许的，注意在使用该优化脚本的时候，我们不要选择Static，接下来我们会在系列二中继续解决这个问题。

在系列一中，我们已经知道了问题所在，一个是优化后我们模型位置改变了，另一个是如果是不同的材质的物体一起优化的时候，不同的材质的对象会消失掉，我们在系列二中主要是解决这两个问题：

    接下来我们改进的思路是查找所有的MeshFilter，同时我们根据不同的材质对我们需要优化的对象进行分离。这就需要我们定义两个链表：

1 2	ArrayList materials =  new  ArrayList();          ArrayList combineInstanceArrays =  new  ArrayList();

下面我们开始遍历我们需要优化对象的MeshFilter和MeshRenderer，因为材质是与MeshRenderder相关联的代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

foreach  (GameObject obj  in  Objects)          {              if  (!obj)                  continue ;                MeshFilter[] meshFilters = obj.GetComponentsInChildren<MeshFilter>();                foreach  (MeshFilter meshFilter  in  meshFilters)              {                  MeshRenderer meshRenderer = meshFilter.GetComponent<MeshRenderer>();                    if  (!meshRenderer)                  {                      Debug.LogError( "MeshFilter does not have a coresponding MeshRenderer." );                      continue ;                  }                  if  (meshRenderer.materials.Length != meshFilter.sharedMesh.subMeshCount)                  {                      Debug.LogError( "Mismatch between material count and submesh count. Is this the correct MeshRenderer?" );                      continue ;                  }                    for  ( int  s = 0; s < meshFilter.sharedMesh.subMeshCount; s++)                  {                      int  materialArrayIndex = 0;                      for  (materialArrayIndex = 0; materialArrayIndex < materials.Count; materialArrayIndex++)                      {                          if  (materials[materialArrayIndex] == meshRenderer.sharedMaterials[s])                              break ;                      }                        if  (materialArrayIndex == materials.Count)                      {                          materials.Add(meshRenderer.sharedMaterials[s]);                          combineInstanceArrays.Add( new  ArrayList());                      }                        CombineInstance combineInstance =  new  CombineInstance();                      combineInstance.transform = meshRenderer.transform.localToWorldMatrix;                      combineInstance.subMeshIndex = s;                      combineInstance.mesh = meshFilter.sharedMesh;                      (combineInstanceArrays[materialArrayIndex]  as  ArrayList).Add(combineInstance);                  }              }          }

下面是针对MeshFilter的处理代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

{              MeshFilter meshFilterCombine = gameObject.GetComponent<MeshFilter>();              if  (!meshFilterCombine)                  meshFilterCombine = gameObject.AddComponent<MeshFilter>();                Mesh[] meshes =  new  Mesh[materials.Count];              CombineInstance[] combineInstances =  new  CombineInstance[materials.Count];                for  ( int  m = 0; m < materials.Count; m++)              {                  CombineInstance[] combineInstanceArray = (combineInstanceArrays[m]  as  ArrayList).ToArray( typeof (CombineInstance))  as  CombineInstance[];                  meshes[m] =  new  Mesh();                  meshes[m].CombineMeshes(combineInstanceArray,  true ,  true );                    combineInstances[m] =  new  CombineInstance();                  combineInstances[m].mesh = meshes[m];                  combineInstances[m].subMeshIndex = 0;              }                meshFilterCombine.sharedMesh =  new  Mesh();              meshFilterCombine.sharedMesh.CombineMeshes(combineInstances,  false ,  false );                foreach  (Mesh mesh  in  meshes)              {                  mesh.Clear();                  DestroyImmediate(mesh);              }          }

将其组合成一个Mesh，接下来也是最后一步创建Mesh Renderer并将材质赋值给它

1 2 3 4 5 6 7 8 9

{              MeshRenderer meshRendererCombine = gameObject.GetComponent<MeshRenderer>();              if  (!meshRendererCombine)                  meshRendererCombine = gameObject.AddComponent<MeshRenderer>();                Material[] materialsArray = materials.ToArray( typeof (Material))  as  Material[];              meshRendererCombine.materials = materialsArray;          }      }

下面我们看一下优化前后有啥变化，首先我们用四个Cube和一个Sphere，三种材质。效果图如下：

下面我们将我们优化的图展示一下：

对比上图我们可以看到Saved by batching减少了，Used Textures 较少了，Render Textures使用的纹理大小也较少了，虽然相对来说Draw Call增加了，但是由于Render Textures少了，我们的优化效果达到了，而且位置也没变，多种材质也没问题了，但是还有个问题，就是我们的Cube有三个是相同的，但是我们看其材质的效果图：

相同的材质写了三次，这说明我们的程序还需要继续去优化，以上代码只要将其组合在一起就可以使用了，我们将在讲台优化系列三中继续优化我们的优化程序。

我们接着系列二的问题继续讲解，系列二中的问题是如果多个材质是相同的，它没有去优化，接下来我们将其优化一下，首先要找到在哪里去优化，我们看下面的for循环语句也是系列二的代码，如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

for  ( int  s = 0; s < meshFilter.sharedMesh.subMeshCount; s++)                  {                      int  materialArrayIndex = 0;                      for  (materialArrayIndex = 0; materialArrayIndex < materials.Count; materialArrayIndex++)                      {                          if  (materials[materialArrayIndex] == meshRenderer.sharedMaterials[s])                              break ;                      }                      if  (materialArrayIndex == materials.Count)                      {                          materials.Add(meshRenderer.sharedMaterials[s]);                          combineInstanceArrays.Add( new  ArrayList());                      }                      CombineInstance combineInstance =  new  CombineInstance();                      combineInstance.transform = meshRenderer.transform.localToWorldMatrix;                      combineInstance.subMeshIndex = s;                      combineInstance.mesh = meshFilter.sharedMesh;                      (combineInstanceArrays[materialArrayIndex]  as  ArrayList).Add(combineInstance);                  }

这个代码里它没有判断是否有相同的材质，接下来我们将其重新修改一下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

for  ( int  s = 0; s < meshFilter.sharedMesh.subMeshCount; s++)                  {                      int  materialArrayIndex = Contains(materials, meshRenderer.sharedMaterials[s].name);                      if  (materialArrayIndex == -1)                      {                          materials.Add(meshRenderer.sharedMaterials[s]);                          materialArrayIndex = materials.Count - 1;                      }                      combineInstanceArrays.Add( new  ArrayList());                      CombineInstance combineInstance =  new  CombineInstance();                      combineInstance.transform = meshRenderer.transform.localToWorldMatrix;                      combineInstance.subMeshIndex = s;                      combineInstance.mesh = meshFilter.sharedMesh;                      (combineInstanceArrays[materialArrayIndex]  as  ArrayList).Add(combineInstance);                  }

我们看到上面有个函数Contains它就是用于判断是否有相同的材质，如果有就作为一张材质，Contains函数代码如下所示：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

private  int  Contains(ArrayList searchList,  string  searchName)        {            for  ( int  i = 0; i < searchList.Count; i++)            {                if  (((Material)searchList[i]).name == searchName)                {                    return  i;                }            }            return  -1;        }

作用是用于返回相同材质的索引，效果如下：

看上图红色的部分，有两个材质是一样的，材质只显示一个了，将其优化了。整个静态对象的优化就给大家解答完了。