Пример #1
0
 private static void MakeBatch(List <MeshSubsetCombineUtility.MeshContainer> meshes, Transform staticBatchRootTransform, int batchIndex)
 {
     if (meshes.Count >= 2)
     {
         List <MeshSubsetCombineUtility.MeshInstance>    list  = new List <MeshSubsetCombineUtility.MeshInstance>();
         List <MeshSubsetCombineUtility.SubMeshInstance> list2 = new List <MeshSubsetCombineUtility.SubMeshInstance>();
         foreach (MeshSubsetCombineUtility.MeshContainer mesh2 in meshes)
         {
             MeshSubsetCombineUtility.MeshContainer current = mesh2;
             list.Add(current.instance);
             list2.AddRange(current.subMeshInstances);
         }
         string str = "Combined Mesh";
         str = str + " (root: " + ((!(staticBatchRootTransform != null)) ? "scene" : staticBatchRootTransform.name) + ")";
         if (batchIndex > 0)
         {
             str = str + " " + (batchIndex + 1);
         }
         Mesh mesh = StaticBatchingHelper.InternalCombineVertices(list.ToArray(), str);
         StaticBatchingHelper.InternalCombineIndices(list2.ToArray(), mesh);
         int num = 0;
         foreach (MeshSubsetCombineUtility.MeshContainer mesh3 in meshes)
         {
             MeshSubsetCombineUtility.MeshContainer current2 = mesh3;
             MeshFilter meshFilter = (MeshFilter)current2.gameObject.GetComponent(typeof(MeshFilter));
             meshFilter.sharedMesh = mesh;
             int      num2      = current2.subMeshInstances.Count();
             Renderer component = current2.gameObject.GetComponent <Renderer>();
             component.SetStaticBatchInfo(num, num2);
             component.staticBatchRootTransform = staticBatchRootTransform;
             component.enabled = false;
             component.enabled = true;
             MeshRenderer meshRenderer = component as MeshRenderer;
             if (meshRenderer != null)
             {
                 meshRenderer.additionalVertexStreams = null;
             }
             num += num2;
         }
     }
 }
Пример #2
0
        public static void CombineGameObjects(GameObject[] gos, GameObject staticBatchRoot, bool isEditorPostprocessScene)
        {
            Matrix4x4 lhs = Matrix4x4.identity;
            Transform staticBatchRootTransform = null;

            if (staticBatchRoot)
            {
                lhs = staticBatchRoot.transform.worldToLocalMatrix;
                staticBatchRootTransform = staticBatchRoot.transform;
            }
            int batchIndex = 0;
            int num        = 0;
            List <MeshSubsetCombineUtility.MeshContainer> list = new List <MeshSubsetCombineUtility.MeshContainer>();

            Array.Sort(gos, new InternalStaticBatchingUtility.SortGO());
            foreach (GameObject gameObject in gos)
            {
                MeshFilter meshFilter = gameObject.GetComponent(typeof(MeshFilter)) as MeshFilter;
                if (!(meshFilter == null))
                {
                    Mesh sharedMesh = meshFilter.sharedMesh;
                    if (!(sharedMesh == null) && (isEditorPostprocessScene || sharedMesh.canAccess))
                    {
                        Renderer component = meshFilter.GetComponent <Renderer>();
                        if (!(component == null) && component.enabled)
                        {
                            if (component.staticBatchIndex == 0)
                            {
                                Material[] array = component.sharedMaterials;
                                if (!array.Any((Material m) => m != null && m.shader != null && m.shader.disableBatching != DisableBatchingType.False))
                                {
                                    int vertexCount = sharedMesh.vertexCount;
                                    if (vertexCount != 0)
                                    {
                                        MeshRenderer meshRenderer = component as MeshRenderer;
                                        if (meshRenderer != null && meshRenderer.additionalVertexStreams != null)
                                        {
                                            if (vertexCount != meshRenderer.additionalVertexStreams.vertexCount)
                                            {
                                                goto IL_387;
                                            }
                                        }
                                        if (num + vertexCount > 64000)
                                        {
                                            InternalStaticBatchingUtility.MakeBatch(list, staticBatchRootTransform, batchIndex++);
                                            list.Clear();
                                            num = 0;
                                        }
                                        MeshSubsetCombineUtility.MeshInstance instance = default(MeshSubsetCombineUtility.MeshInstance);
                                        instance.meshInstanceID     = sharedMesh.GetInstanceID();
                                        instance.rendererInstanceID = component.GetInstanceID();
                                        if (meshRenderer != null && meshRenderer.additionalVertexStreams != null)
                                        {
                                            instance.additionalVertexStreamsMeshInstanceID = meshRenderer.additionalVertexStreams.GetInstanceID();
                                        }
                                        instance.transform                   = lhs * meshFilter.transform.localToWorldMatrix;
                                        instance.lightmapScaleOffset         = component.lightmapScaleOffset;
                                        instance.realtimeLightmapScaleOffset = component.realtimeLightmapScaleOffset;
                                        MeshSubsetCombineUtility.MeshContainer item = new MeshSubsetCombineUtility.MeshContainer
                                        {
                                            gameObject       = gameObject,
                                            instance         = instance,
                                            subMeshInstances = new List <MeshSubsetCombineUtility.SubMeshInstance>()
                                        };
                                        list.Add(item);
                                        if (array.Length > sharedMesh.subMeshCount)
                                        {
                                            Debug.LogWarning(string.Concat(new object[]
                                            {
                                                "Mesh '",
                                                sharedMesh.name,
                                                "' has more materials (",
                                                array.Length,
                                                ") than subsets (",
                                                sharedMesh.subMeshCount,
                                                ")"
                                            }), component);
                                            Material[] array2 = new Material[sharedMesh.subMeshCount];
                                            for (int j = 0; j < sharedMesh.subMeshCount; j++)
                                            {
                                                array2[j] = component.sharedMaterials[j];
                                            }
                                            component.sharedMaterials = array2;
                                            array = array2;
                                        }
                                        for (int k = 0; k < Math.Min(array.Length, sharedMesh.subMeshCount); k++)
                                        {
                                            MeshSubsetCombineUtility.SubMeshInstance item2 = default(MeshSubsetCombineUtility.SubMeshInstance);
                                            item2.meshInstanceID       = meshFilter.sharedMesh.GetInstanceID();
                                            item2.vertexOffset         = num;
                                            item2.subMeshIndex         = k;
                                            item2.gameObjectInstanceID = gameObject.GetInstanceID();
                                            item2.transform            = instance.transform;
                                            item.subMeshInstances.Add(item2);
                                        }
                                        num += sharedMesh.vertexCount;
                                    }
                                }
                            }
                        }
                    }
                }
                IL_387 :;
            }
            InternalStaticBatchingUtility.MakeBatch(list, staticBatchRootTransform, batchIndex);
        }
Пример #3
0
        static public void CombineGameObjects(GameObject[] gos, UnityEngine.GameObject staticBatchRoot, bool isEditorPostprocessScene)
        {
            Matrix4x4 staticBatchInverseMatrix = Matrix4x4.identity;
            Transform staticBatchRootTransform = null;

            if (staticBatchRoot)
            {
                staticBatchInverseMatrix = staticBatchRoot.transform.worldToLocalMatrix;
                staticBatchRootTransform = staticBatchRoot.transform;
            }

            int batchIndex      = 0;
            int verticesInBatch = 0;
            List <MeshSubsetCombineUtility.MeshContainer> meshes = new List <MeshSubsetCombineUtility.MeshContainer>();

            Array.Sort(gos, new SortGO());

            foreach (GameObject go in gos)
            {
                MeshFilter filter = go.GetComponent(typeof(MeshFilter)) as MeshFilter;
                if (filter == null)
                {
                    continue;
                }

                Mesh instanceMesh = filter.sharedMesh;

                // reject if has no mesh or (mesh not readable and not called from Editor PostprocessScene.cs)
                // Editor is allowed to modify meshes even if they are marked as read-only e.g. Applicatiopn.LoadLevel() called from a script inside the editor player
                if (instanceMesh == null || (!isEditorPostprocessScene && !instanceMesh.canAccess))
                {
                    continue;
                }

                Renderer renderer = filter.GetComponent <Renderer>();

                // reject if has not renderer or renderer is disabled
                if (renderer == null || !renderer.enabled)
                {
                    continue;
                }

                // reject if already combined for static batching
                if (renderer.staticBatchIndex != 0)
                {
                    continue;
                }

                Material[] materials = renderer.sharedMaterials;

                // reject if any of the material's shader is using DisableBatching tag
                if (materials.Any(m => m != null && m.shader != null && m.shader.disableBatching != DisableBatchingType.False))
                {
                    continue;
                }

                int vertexCount = instanceMesh.vertexCount;
                // Use same tests as MeshCombiner::IsMeshBatchable to stay consistent with C++ code
                if (vertexCount == 0)
                {
                    continue;
                }

                MeshRenderer meshRenderer = renderer as MeshRenderer;
                if ((meshRenderer != null) && (meshRenderer.additionalVertexStreams != null))
                {
                    if (vertexCount != meshRenderer.additionalVertexStreams.vertexCount)
                    {
                        continue;
                    }
                }

                // check if we have enough space inside the current batch
                if (verticesInBatch + vertexCount > MaxVerticesInBatch)
                {
                    MakeBatch(meshes, staticBatchRootTransform, batchIndex++);
                    meshes.Clear();
                    verticesInBatch = 0;
                }

                MeshSubsetCombineUtility.MeshInstance instance = new MeshSubsetCombineUtility.MeshInstance();
                instance.meshInstanceID     = instanceMesh.GetInstanceID();
                instance.rendererInstanceID = renderer.GetInstanceID();
                if (meshRenderer != null && meshRenderer.additionalVertexStreams != null)
                {
                    instance.additionalVertexStreamsMeshInstanceID = meshRenderer.additionalVertexStreams.GetInstanceID();
                }

                instance.transform                   = staticBatchInverseMatrix * filter.transform.localToWorldMatrix;
                instance.lightmapScaleOffset         = renderer.lightmapScaleOffset;
                instance.realtimeLightmapScaleOffset = renderer.realtimeLightmapScaleOffset;

                MeshSubsetCombineUtility.MeshContainer mesh = new MeshSubsetCombineUtility.MeshContainer();
                mesh.gameObject       = go;
                mesh.instance         = instance;
                mesh.subMeshInstances = new List <MeshSubsetCombineUtility.SubMeshInstance>();

                //;;Debug.Log("New static mesh (" + go.name + ")verts: " + instanceMesh.vertexCount +
                //  ", tris: " + instanceMesh.triangles.Length +
                //  ", materials: " + renderer.sharedMaterials.Length +
                //  ", subs: " + instanceMesh.subMeshCount
                //  );

                meshes.Add(mesh);

                if (materials.Length > instanceMesh.subMeshCount)
                {
                    Debug.LogWarning("Mesh '" + instanceMesh.name + "' has more materials (" + materials.Length + ") than subsets (" + instanceMesh.subMeshCount + ")", renderer);
                    // extra materials don't have a meaning and it screws the rendering as Unity
                    // tries to render with those extra materials.
                    Material[] newMats = new Material[instanceMesh.subMeshCount];
                    for (int i = 0; i < instanceMesh.subMeshCount; ++i)
                    {
                        newMats[i] = renderer.sharedMaterials[i];
                    }
                    renderer.sharedMaterials = newMats;
                    materials = newMats;
                }

                for (int m = 0; m < System.Math.Min(materials.Length, instanceMesh.subMeshCount); ++m)
                {
                    //;;Debug.Log("   new subset : " + m + ", tris " + instanceMesh.GetTriangles(m).Length);
                    MeshSubsetCombineUtility.SubMeshInstance subMeshInstance = new MeshSubsetCombineUtility.SubMeshInstance();
                    subMeshInstance.meshInstanceID       = filter.sharedMesh.GetInstanceID();
                    subMeshInstance.vertexOffset         = verticesInBatch;
                    subMeshInstance.subMeshIndex         = m;
                    subMeshInstance.gameObjectInstanceID = go.GetInstanceID();
                    subMeshInstance.transform            = instance.transform;
                    mesh.subMeshInstances.Add(subMeshInstance);
                }
                verticesInBatch += instanceMesh.vertexCount;
            }

            MakeBatch(meshes, staticBatchRootTransform, batchIndex);
        }