ConcaveCollider.FH_CreateHullsFromVrml C# (CSharp) Method

    private static void FH_CreateHullsFromVrml(GameObject obj, string vrml, ProgressDelegate progress)
    {
        Debug.Log("Loading VRML for " + obj.name);
        List<Mesh> meshes = ReadVrml(vrml, progress, obj.name);
        for (int i = 0; i < meshes.Count; ++i)
        {
            if (meshes[i] == null)
            {
                Debug.LogWarningFormat("Found null mesh at #{0} in {1}. Aborting early.\n{2}", i, obj.name, vrml);
                return;
            }
        }
        int nMeshCount = 0;

        progress("Finding collision mesh asset paths", 0.0f);
        string strMeshAssetPath = "";
        bool CreateMeshAssets = true;
        bool DebugLog = true;
        PhysicMaterial PhysMaterial = new PhysicMaterial();
        bool IsTrigger = false;
        bool CreateHullMesh = true;

        if(CreateMeshAssets)
        {
            string uniqueID = null;;
            Debug.LogFormat("Obj: {0} of type {1}", obj.transform.FullPath(), UnityEditor.PrefabUtility.GetPrefabType(obj));
            if (UnityEditor.PrefabUtility.GetPrefabParent(obj) != null)
            {
                string prefabPath = UnityEditor.AssetDatabase.GetAssetPath(UnityEditor.PrefabUtility.GetPrefabParent(obj));
                int startIndex = 1 + prefabPath.LastIndexOf("/");
                prefabPath = prefabPath.Substring(startIndex, prefabPath.LastIndexOf(".") - startIndex);
                uniqueID = string.Format("{0}_{1}", prefabPath, UnityEditor.PrefabUtility.GetPrefabParent(obj).name);
            }
            else
                uniqueID = string.Format("{0}_{1}", obj.name, obj.GetInstanceID().ToString());
            strMeshAssetPath = "ColliderMeshes\\" + uniqueID + " _colMesh.asset";
            if (!InBatchSaveMode)
                strMeshAssetPath = UnityEditor.EditorUtility.SaveFilePanelInProject("Save mesh asset", strMeshAssetPath, "asset", "Save collider mesh for " + obj.name);
            else
                strMeshAssetPath = "Assets/" + strMeshAssetPath;

            if(strMeshAssetPath.Length == 0)
            {
                return;
            }
        }

        progress("Clearing old colliders", 0.0f);
        int nHullsOut = meshes.Count;
        if(DebugLog)
            Debug.Log(string.Format("Created {0} hulls from VRML for {1}", nHullsOut, obj.name));

        Transform hullParent = obj.transform.Find("Generated Colliders");
        if(hullParent != null)
        {
            if(Application.isEditor && Application.isPlaying == false)
                DestroyImmediate(hullParent.gameObject);
            else
                Destroy(hullParent.gameObject);
        }
        hullParent = (new GameObject("Generated Colliders")).transform;
        hullParent.transform.SetParent(obj.transform, false);

        foreach(Collider collider in obj.GetComponents<Collider>())
        {
            collider.enabled = false;
        }

        GameObject[] m_aGoHulls = new GameObject[nHullsOut];

        obj.transform.rotation = Quaternion.Euler(new Vector3(0,0f,0));
        Vector3 newScale = obj.transform.localScale;
        //        newScale.z = -newScale.z;
        for(int nHull = 0; nHull < nHullsOut && !shouldCancelBatch; nHull++)
        {
            progress("Transforming VRML vertices and saving out mesh data", 100f * (nHull + 0.5f) / nHullsOut);
            Mesh refMesh = meshes[nHull];
            if (refMesh == null)
                Debug.LogWarningFormat("Found null mesh at #{0} in {1}", nHull, obj.name);
            if(refMesh != null && refMesh.vertexCount > 0)
            {
                m_aGoHulls[nHull] = new GameObject("Hull " + nHull);
                m_aGoHulls[nHull].transform.position = obj.transform.position;
                m_aGoHulls[nHull].transform.rotation = obj.transform.rotation;
                m_aGoHulls[nHull].transform.parent   = hullParent;
                m_aGoHulls[nHull].layer              = obj.layer;

                Vector3[] hullVertices = refMesh.vertices;

        //                    float fHullVolume     = -1.0f;
        //                    float fInvMeshRescale = 1.0f / fMeshRescale;

                for(int nVertex = 0; nVertex < hullVertices.Length; nVertex++)
                    hullVertices[nVertex] = Vector3.Scale(hullVertices[nVertex], newScale);

                Mesh hullMesh = refMesh;
                hullMesh.vertices  = hullVertices;

                Collider hullCollider = null;

        //                    fHullVolume *= Mathf.Pow(fInvMeshRescale, 3.0f);

                // Create mesh collider
                MeshCollider meshCollider = m_aGoHulls[nHull].AddComponent<MeshCollider>() as MeshCollider;

                meshCollider.sharedMesh = hullMesh;
                meshCollider.convex     = true;

                hullCollider = meshCollider;

                if(CreateHullMesh)
                {
                    MeshFilter meshf = m_aGoHulls[nHull].AddComponent<MeshFilter>();
                    meshf.sharedMesh = hullMesh;
                }

                if(CreateMeshAssets)
                {
                    if(nMeshCount == 0)
                    {
                        // Avoid some shader warnings
                        hullMesh.RecalculateNormals();
                        hullMesh.uv = new Vector2[hullVertices.Length];

                        UnityEditor.AssetDatabase.CreateAsset(hullMesh, strMeshAssetPath);
                    }
                    else
                    {
                        // Avoid some shader warnings
                        hullMesh.RecalculateNormals();
                        hullMesh.uv = new Vector2[hullVertices.Length];

                        UnityEditor.AssetDatabase.AddObjectToAsset(hullMesh, strMeshAssetPath);
                        UnityEditor.AssetDatabase.ImportAsset(UnityEditor.AssetDatabase.GetAssetPath(hullMesh));
                    }
                }

                nMeshCount++;

                if(hullCollider)
                {
                    hullCollider.material  = PhysMaterial;
                    hullCollider.isTrigger = IsTrigger;
                }
            }
        }

        if(CreateMeshAssets)
        {
            UnityEditor.AssetDatabase.Refresh();
        }
    }