/// <summary>
        /// Export meshes to a Unity asset.
        /// </summary>
        /// <param name="meshes"></param>
        /// <returns></returns>
        public static string ExportWithFileDialog(IList <ProBuilderMesh> meshes, ExportAssetOptions options)
        {
            if (meshes == null || !meshes.Any())
            {
                return("");
            }

            string res = null;

            if (meshes.Count() < 2)
            {
                ProBuilderMesh first = meshes.FirstOrDefault();

                if (first == null)
                {
                    return(null);
                }

                res = options.makePrefab
                    ? ExportPrefab(first, options.replaceOriginal)
                    : ExportMesh(first, options.replaceOriginal);
            }
            else
            {
                string path = UnityEditor.EditorUtility.SaveFolderPanel("Export to Asset", "Assets", "");

                if (string.IsNullOrEmpty(path) || !Directory.Exists(path))
                {
                    return(null);
                }

                meshes = meshes.ToList();
                for (int i = 0, c = meshes.Count; i < c; i++)
                {
                    var pb        = meshes[i];
                    var assetPath = string.Format("{0}/{1}.asset", path, pb.name);

                    if (options.makePrefab)
                    {
                        res = ExportPrefab(assetPath, pb, options.replaceOriginal, true);
                    }
                    else
                    {
                        res = ExportMesh(assetPath, pb, options.replaceOriginal, true);

                        if (options.replaceOriginal)
                        {
                            StripProBuilderScripts.DestroyProBuilderMeshAndDependencies(pb.gameObject, pb, true, true);
                        }
                    }
                }
            }

            ProBuilderEditor.Refresh();
            AssetDatabase.Refresh();

            return(res);
        }
        static string ExportMesh(ProBuilderMesh mesh, bool replaceOriginal)
        {
            string path = AskForPath(mesh.name, "asset");

            if (string.IsNullOrEmpty(path))
            {
                return(null);
            }

            ExportMesh(path, mesh, replaceOriginal, false);

            if (replaceOriginal)
            {
                StripProBuilderScripts.DestroyProBuilderMeshAndDependencies(mesh.gameObject, mesh, true, true);
            }
            else
            {
                mesh.mesh = null;
                EditorUtility.SynchronizeWithMeshFilter(mesh);
            }

            return(path);
        }
        static string ExportPrefab(string path, ProBuilderMesh pb, bool replaceOriginal, bool batchExport)
        {
            string name     = Path.GetFileNameWithoutExtension(path);
            string basePath = AssetPathFromFullPath(path, null);

            pb.ToMesh();
            pb.Refresh();
            pb.Optimize();

            string meshPath   = string.Format("{0}.asset", basePath);
            string prefabPath = string.Format("{0}.prefab", basePath);

            if (batchExport)
            {
                // Never overwrite during batch export.
                meshPath   = AssetDatabase.GenerateUniqueAssetPath(meshPath);
                prefabPath = AssetDatabase.GenerateUniqueAssetPath(prefabPath);
            }
            else
            {
                var existingMesh = AssetDatabase.LoadAssetAtPath <Mesh>(meshPath);
                if (existingMesh)
                {
                    // Overwriting mesh.
                    var existingPrefab = AssetDatabase.LoadAssetAtPath <GameObject>(prefabPath);
                    if (existingPrefab)
                    {
                        // Overwriting prefab as well.
                        var meshFilter = existingPrefab.GetComponent <MeshFilter>();
                        if (!meshFilter || meshFilter.sharedMesh != existingMesh)
                        {
                            // Prefab and mesh being overwritten are not related, pick different path.
                            meshPath = PickDifferentAssetPath(meshPath);
                        }
                        // Else allow overwrite both as they are related.
                    }
                    else
                    {
                        // Unrelated mesh is being overriden, pick different path.
                        meshPath = PickDifferentAssetPath(meshPath);
                    }
                }
            }

            Mesh meshAsset = pb.mesh;

            meshAsset.name = name;
            meshAsset      = CreateOrReplaceAsset(meshAsset, meshPath);

            var go = replaceOriginal ? pb.gameObject : Object.Instantiate(pb.gameObject);

            var component = go.GetComponent <ProBuilderMesh>();

            Undo.RecordObject(component, "Export ProBuilderMesh as Replacement");
            StripProBuilderScripts.DestroyProBuilderMeshAndDependencies(go, component, true, true);

            go.GetComponent <MeshFilter>().sharedMesh = meshAsset;
            var meshCollider = go.GetComponent <MeshCollider>();

            if (meshCollider)
            {
                meshCollider.sharedMesh = meshAsset;
            }

            if (replaceOriginal)
            {
                PrefabUtility.SaveAsPrefabAssetAndConnect(go, prefabPath, InteractionMode.UserAction);
            }
            else
            {
                // if we're about to overwrite the prefab asset of the source mesh, first disconnect it so that we're not
                // overwriting the instance
                if (PrefabUtility.IsPartOfAnyPrefab(pb) &&
                    PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(pb) == prefabPath)
                {
                    PrefabUtility.UnpackPrefabInstance(pb.gameObject, PrefabUnpackMode.OutermostRoot, InteractionMode.AutomatedAction);
                }
                PrefabUtility.SaveAsPrefabAsset(go, prefabPath);
            }

            if (!replaceOriginal)
            {
                pb.mesh = null;
                EditorUtility.SynchronizeWithMeshFilter(pb);
                Object.DestroyImmediate(go);
            }

            return(meshPath);
        }