Try & Error

using UnityEngine;
using System.Collections;
/*
Attach this script as a parent to some game objects. Then by using the corresponding controls you may generate combined meshes (with lightmapping UVs).
This is useful as a performance optimization since it is faster to render one big mesh than many small meshes. See the docs on graphics performance optimization for more info.
 
Different materials will cause multiple meshes to be created, thus it is useful to share as many textures/material as you can.
NOTE: Using multiple materials may break things due to lightmapping generation. So lightmapping UVs as well as splitting the combined geometry is not supported.
Workaround: Create hierarchies in which the children only have exactly one material.
*/
 
[AddComponentMenu("Mad Vulture Games/Combine Children 1.5")]
public class CombineChildrenAdvanced : MonoBehaviour {
    
    /// Usually rendering with triangle strips is faster.
    /// However when combining objects with very low triangle counts, it can be faster to use triangles.
    /// Best is to try out which value is faster in practice.
    public bool generateTriangleStrips = true;
    public bool generateLightmappingUVs = true;
    public bool isCombined = false;
    
    public void Combine() {
        Component[] filters  = GetComponentsInChildren(typeof(MeshFilter));
        
        if (filters.Length <= 1) {
            Debug.LogWarning ("Not enough meshes to combine!");
            return;
        }
        
        Matrix4x4 myTransform = transform.worldToLocalMatrix;
        Hashtable materialToMesh= new Hashtable();
        
        for (int i=0;i<filters.Length;i++) {
            MeshFilter filter = (MeshFilter)filters[i];
            Renderer curRenderer  = filters[i].renderer;
            MeshCombineUtility.MeshInstance instance = new MeshCombineUtility.MeshInstance ();
            instance.mesh = filter.sharedMesh;
            if (curRenderer != null && curRenderer.enabled && instance.mesh != null) {
                instance.transform = myTransform * filter.transform.localToWorldMatrix;
                
                Material[] materials = curRenderer.sharedMaterials;
                for (int m=0;m<materials.Length;m++) {
                    instance.subMeshIndex = System.Math.Min(m, instance.mesh.subMeshCount - 1);
    
                    ArrayList objects = (ArrayList)materialToMesh[materials[m]];
                    if (objects != null) {
                        objects.Add(instance);
                    }
                    else
                    {
                        objects = new ArrayList ();
                        objects.Add(instance);
                        materialToMesh.Add(materials[m], objects);
                    }
                }
                
                curRenderer.enabled = false;
            }
        }
    
        foreach (DictionaryEntry de  in materialToMesh) {
            ArrayList elements = (ArrayList)de.Value;
            MeshCombineUtility.MeshInstance[] instances = (MeshCombineUtility.MeshInstance[])elements.ToArray(typeof(MeshCombineUtility.MeshInstance));
 
            // We have a maximum of one material, so just attach the mesh to our own game object
            if (materialToMesh.Count == 1)
            {
                // Make sure we have a mesh filter & renderer
                if (GetComponent(typeof(MeshFilter)) == null)
                    gameObject.AddComponent(typeof(MeshFilter));
                if (!GetComponent("MeshRenderer"))
                    gameObject.AddComponent("MeshRenderer");
    
                MeshFilter filter = (MeshFilter)GetComponent(typeof(MeshFilter));
                filter.mesh = MeshCombineUtility.Combine(instances, generateTriangleStrips);
                renderer.material = (Material)de.Key;
                renderer.enabled = true;
            }
            // We have multiple materials to take care of, build one mesh / gameobject for each material
            // and parent it to this object
            else
            {
                GameObject go = new GameObject("Combined mesh");
                go.transform.parent = transform;
                go.transform.localScale = Vector3.one;
                go.transform.localRotation = Quaternion.identity;
                go.transform.localPosition = Vector3.zero;
                go.AddComponent(typeof(MeshFilter));
                go.AddComponent("MeshRenderer");
                go.renderer.material = (Material)de.Key;
                MeshFilter filter = (MeshFilter)go.GetComponent(typeof(MeshFilter));
                filter.mesh = MeshCombineUtility.Combine(instances, generateTriangleStrips);
            }
        }
        
        isCombined = true;
    }
}

using UnityEngine;
using UnityEditor;
using System.Collections;
 
[CustomEditor(typeof(CombineChildrenAdvanced))]
public class CombineChildrenAdvancedEditor : Editor {
 
    CombineChildrenAdvanced _target;
    
    void OnEnable() {
        _target = (CombineChildrenAdvanced)target;
    }
    
    
    
    public override void OnInspectorGUI() {
        
        EditorGUIUtility.LookLikeInspector();
        
        _target.generateTriangleStrips = EditorGUILayout.Toggle("Generate Triangle Strips", _target.generateTriangleStrips);
        _target.generateLightmappingUVs = EditorGUILayout.Toggle ("Generate Lightmapping UVs", _target.generateLightmappingUVs);
        
        if (!_target.isCombined) {
            if (GUILayout.Button ("Combine now (May take a while!)")) {
                _target.Combine();
                
                if (_target.generateLightmappingUVs) {
                    GenerateLightmappingUVs();
                }
            }
        }
        
        if (_target.isCombined) {
            if (GUILayout.Button ("Generate Lightmap UVs")) {
                GenerateLightmappingUVs();
            }
            
            if (GUILayout.Button ("Split Mesh")) {
                DestroyImmediate(_target.GetComponent (typeof(MeshFilter)));
                DestroyImmediate(_target.GetComponent (typeof(MeshRenderer)));
                
                foreach (MeshRenderer mr in _target.GetComponentsInChildren(typeof(MeshRenderer))) {
                    mr.enabled = true;
                }
                
                _target.isCombined = false;
            }
        }
    }
    
    
    
    
    void GenerateLightmappingUVs() {
        MeshFilter mf = _target.GetComponent(typeof(MeshFilter)) as MeshFilter;
        
        // make null check because if not enough meshes are present no combined mesh would have been created!
        if (mf != null) {
            Unwrapping.GenerateSecondaryUVSet(mf.sharedMesh);
        }
    }
    
}