Unity5打包assetbundle

Unity5打包assetbundle

using System;
using System.Collections.Generic;
using System.IO;
using UnityEditor;
using UnityEngine;

public class AssetBundleExporterGUI
{
    private static readonly string BUNDLE_PATH_ART = System.Environment.CurrentDirectory +
		"/../../../../../starts-art/Assetbundles/";
    private static readonly string BUNDLE_PATH_GAME = System.Environment.CurrentDirectory +
        "/../../../../../starts-game-assets/trunk/assetbundles/";
    
    private const string IOS_BUNDLE_PATH = "ios/";
    private const string ANDROID_BUNDLE_PATH = "android/";
    private const string WEBPLAYER_BUNDLE_PATH = "webplayer/";
    
    private const string ASSETBUNDLE_EXT = ".assetbundle";
    
    private const string PREFAB_PATH = "Assets/_prefabs/{0}.prefab";
    
    // This is our one-and-only dependency bundle. Any downloaded bundle can reference this,
    // which means any assets within it won't be duplicated in any dependent bundle.
    private static string PREFAB_EXT = ".prefab";
    private static string SHARED_PREFAB = "gui_shared";
    private static string SHARED_PREFAB_PATH = "Assets/_prefabs/" + SHARED_PREFAB;

    private const string SHARED_BUNDLE = "gui_shared";
    
    // These are the bundles that do not have any dependency. These bundles are intended to be
    // loaded on-demand on the client because they can contain textures that we do not want to
    // have always loaded in memory.
    //
    // IMPORTANT: None of these bundles should be in GUI_PRELOADED_SCREENS in AssetConstants.cs
    // located in the starts client codebase. If you are adding a new independent bundle, please
    // ensure this or communicate this to the dev implementing it.
    //
    // Bundles come in two categories:
    //   1. always-loaded, does not contain its own textures, depends on gui_shared
    //   2. loaded on-demand, does not depend on gui_shared
    // All of the following are true:
    //   "If a bundle is always loaded, then it's dependent on gui_shared"
    //   "If a bundle is not always loaded, then it's not dependent on gui_shared"
    //   "If a bundle is dependent on gui_shared, then it's always loaded"
    //   "If a bundle is not dependent on gui_shared, then it's not always loaded"
    // We have 1 exception:
    //   gui_hud depends on gui_shared and also has a few textures
    //
    private static readonly string[] independentBundles = new string[]
    {
        // The shared bundle doesn't depend on itself.
        SHARED_BUNDLE,
        
        "gui_xxxxxxxxx",
        
    };
    
    private const string HUD_BUNDLE = "gui_hud";
    
    private static string selectedPath;
    
    [MenuItem("Assets/StaRTS/Build Selected AssetBundle(s) - Android", false, 1)]
    public static void ExportSelectionAndroid()
    {
        ExportSelectionTarget(BuildTarget.Android);
    }
    
    [MenuItem("Assets/StaRTS/Build Selected AssetBundle(s) - iOS", false, 2)]
    public static void ExportSelectionIOS()
    {
        ExportSelectionTarget(BuildTarget.iOS);
    }
    
    [MenuItem("Assets/StaRTS/Build Selected AssetBundle(s) - WebPlayer", false, 3)]
    public static void ExportSelectionWebPlayer()
    {
        ExportSelectionTarget(BuildTarget.WebPlayer);
    }
    
    // Useful for when you only want to export to a single target and no others.
    private static void ExportSelectionTarget(BuildTarget target)
    {
        if (!Start())
        {
            return;
        }
        
        /*UnityEngine.Object[] prefabs;
        List<string> dependencies;
        if (!GetSelectedPrefabs(out prefabs, out dependencies))
        {
            return;
        }*/
        UnityEngine.Object[] prefabs = Selection.GetFiltered(typeof(UnityEngine.Object), SelectionMode.DeepAssets);

        if (!ExportPrefabs(prefabs, target))
        {
            return;
        }
        
        Success();
    }
    
    // Useful for when you want all targets.  It makes sure to order the targets smartly.
    [MenuItem("Assets/StaRTS/Build Selected AssetBundle(s) - All Platforms", false, 4)]
    public static void ExportSelectionAll()
    {
        if (!Start())
        {
            return;
        }
        
        /*UnityEngine.Object[] prefabs;
        List<string> dependencies;
        if (!GetSelectedPrefabs(out prefabs, out dependencies))
        {
            return;
        }*/
        
        List<BuildTarget> targets = new List<BuildTarget>();
        targets.Add(BuildTarget.Android);
        targets.Add(BuildTarget.iOS);
        targets.Add(BuildTarget.WebPlayer);
        
        // Ensure that the current build target is the first target in the
        // list to minimize the amount of asset re-importing that is done.
        // Whichever was used last will be used first in the subsequent export
        for (int i = 0; i < targets.Count; i++)
        {
            if (targets[i] == EditorUserBuildSettings.activeBuildTarget)
            {
                if (i != 0)
                {
                    targets.Insert(0, targets[i]);
                    targets.RemoveAt(i + 1);
                }
                break;
            }
        }

        UnityEngine.Object[] prefabs = Selection.GetFiltered(typeof(UnityEngine.Object), SelectionMode.DeepAssets);

        for (int i = 0; i < targets.Count; i++)
        {
            if (!ExportPrefabs(prefabs, targets[i]))
            {
                return;
            }
        }
        
        Success();
    }
    
    static private bool GetSelectedPrefabs(out UnityEngine.Object[] prefabs, out List<string> dependencies)
    {
        dependencies = new List<string>();
        
        // Begin() already ensured this was non-empty.
        UnityEngine.Object[] selection = Selection.GetFiltered(typeof(UnityEngine.Object), SelectionMode.DeepAssets);
        
        // Store prefab objects in a new array for multiple target
        // exports. When the editor re-imports assets for a new target,
        // the selection is lost.
        prefabs = new UnityEngine.Object[selection.Length];
        for (int i = 0; i < selection.Length; i++)
        {
            string bundleName = selection[i].name;
            
            
            List<string> deps = new List<string>();
            deps.Add(SHARED_BUNDLE);
            for (int j = 0, jlen = independentBundles.Length; j < jlen; j++)
            {
                if (bundleName == independentBundles[j])
                {
                    deps.Clear();
                    break;
                }
            }
            
            if (i == 0)
            {
                dependencies.AddRange(deps);
            }
            else
            {
                bool matches = deps.Count == dependencies.Count;
                if (matches)
                {
                    for (int j = 0; j < deps.Count; j++)
                    {
                        if (dependencies[j].IndexOf(deps[j]) < 0)
                        {
                            matches = false;
                            break;
                        }
                    }
                }

                if (!matches)
                {
                    // We require that all bundles to be built have the same dependencies.
                    Error("The selected bundles don't have the same dependencies.\n" +
                          "Try building self-contained bundles separately " +
                          "from those that depend on the shared bundle.");
                    return false;
                }
            }
            
            prefabs[i] = selection[i];
        }
        
        return true;
    }
    
    private static bool ExportPrefabs(
        UnityEngine.Object[] prefabs, BuildTarget target)
    {
        Debug.Log("Exporting bundles for " + target);
        
        EditorUserBuildSettings.SwitchActiveBuildTarget(target);
        SetPathAndExportBundle(prefabs, target);
        return true;
    }
    
    // Returns true if the given prefab has no textures of its own,
    // outside of the given dependency prefab.
    // If returns false, assetNames will be set to a newline-separated list of offending assets.
    private static bool IsValidDependency(UnityEngine.Object prefab, UnityEngine.Object dependencyPrefab,
                                          out string assetNames)
    {
        bool valid = true;
        assetNames = null;
        
        string[] prefabPaths = new string[] { string.Format(PREFAB_PATH, prefab.name) };
        string[] prefabAssets = AssetDatabase.GetDependencies(prefabPaths);
        
        string[] dependencyPaths = new string[]
        { string.Format(PREFAB_PATH, dependencyPrefab.name) };
        string[] dependencyAssets = AssetDatabase.GetDependencies(dependencyPaths);
        
        // If everything in the prefab is also in the dependency bundle, then none of it will
        // actually get bundled with the prefab, and that's the goal.
        for (int i = 0, iCount = prefabAssets.Length; i < iCount; i++)
        {
            string assetName = prefabAssets[i];
            
            // These are the legal asset types.  Anything else is considered illegal to have in an
            // depdendent bundle that isn't also inside the depdendency bundle.
            // NOTE: Mainly we want to check .png, .ttf, .prefab, .shader, but rather than only
            // checking those, it's safer to do the reverse: allow known legal assets to be skipped.
            // That way, any new type of asset that we find will not be skipped and either it's a
            // proper dependency, or it'll cause the error to pop, and we'll consider what to do
            // about it.  Either fix the asset, or add the new extension to our "legal" list.
            if (assetName == prefabPaths[0] || // Ignore the root object.
                assetName.EndsWith(".cs") ||   // Scripts only have references bundled.
                assetName.EndsWith(".mat") ||  // Materials are lightweight, they reference shaders
                // and textures, which themselves are prevented.
                assetName.EndsWith(".controller") ||
                assetName.EndsWith(".anim") ||
                assetName.EndsWith(".fbx"))
            {
                continue;
            }
            
            bool found = false;
            for (int j = 0, jCount = dependencyAssets.Length; j < jCount; j++)
            {
                if (assetName == dependencyAssets[j])
                {
                    found = true;
                    break;
                }
            }
            
            if (!found)
            {
                valid = false;
                assetNames = assetNames == null ? assetName : assetNames + "\n" + assetName;
            }
        }
        
        return valid;
    }
    
    private static bool Start()
    {
        UnityEngine.Object[] selection = Selection.GetFiltered(typeof(UnityEngine.Object), SelectionMode.DeepAssets);
        if (selection.Length < 1)
        {
            Debug.Log("No prefabs were selected to bundle!");
            return false;
        }
        
        return AskForExportPath();
    }
    
    private static void Success()
    {
		EditorUtility.DisplayDialog("Export complete!", string.Empty , "OK", string.Empty );
    }
    
    private static void Error(string error)
    {
        Debug.LogError(error);
		EditorUtility.DisplayDialog("Error", error, "OK", string.Empty);
    }
    
    private static bool AskForExportPath()
    {
        int option = EditorUtility.DisplayDialogComplex(
            "Where would you like the bundles saved?",
            "Choose starts-art to export the bundle for an engineer to grab " +
            "for integration. Choose starts-game-assets to test the bundle " +
            "locally and potentially commit to production.",
            "starts-art",
            "Other",
            "starts-game-assets");
        
		string baseDirectory = string.Empty ;
        
        switch (option)
        {
        case 0:
            baseDirectory = BUNDLE_PATH_ART;
            break;
        case 1:
            baseDirectory = EditorUtility.OpenFolderPanel(
				"Select the base export directory", string.Empty , string.Empty) + "/";
            break;
        case 2:
            baseDirectory = BUNDLE_PATH_GAME;
            break;
        default:
            Debug.Log("Invalid selection for export."); // Shouldn't be possible.
            return false;
        }
        
        // Verify path exists
        if (baseDirectory == string.Empty || !Directory.Exists(baseDirectory))
        {
            Error("Base directory does not exist: " + baseDirectory);
            return false;
        }
        
        selectedPath = baseDirectory;
        
        // Create subdirectories if they do not exist
        if (!Directory.Exists(baseDirectory + ANDROID_BUNDLE_PATH))
        {
            Directory.CreateDirectory(baseDirectory + ANDROID_BUNDLE_PATH);
        }

        if (!Directory.Exists(baseDirectory + IOS_BUNDLE_PATH))
        {
            Directory.CreateDirectory(baseDirectory + IOS_BUNDLE_PATH);
        }

        if (!Directory.Exists(baseDirectory + WEBPLAYER_BUNDLE_PATH))
        {
            Directory.CreateDirectory(baseDirectory + WEBPLAYER_BUNDLE_PATH);
        }
        
        return true;
    }

    private static void SetPathAndExportBundle(UnityEngine.Object[] prefabs, BuildTarget target)
    {
        string path = selectedPath;
        
        switch (target)
        {
        case BuildTarget.iOS:
            path += IOS_BUNDLE_PATH;
            break;
            
        case BuildTarget.Android:
            path += ANDROID_BUNDLE_PATH;
            break;
            
        case BuildTarget.WebPlayer:
            path += WEBPLAYER_BUNDLE_PATH;
            break;
        }

        ExportBundle(prefabs, path, target, false);
    }

    static private bool ExportBundle(UnityEngine.Object[] prefab, string path, BuildTarget target, bool combined)
    {
        string directoryPath = Path.GetDirectoryName(path);
        if (!Directory.Exists(directoryPath))
        {
            Directory.CreateDirectory(directoryPath);
        }
        
        AssetBundleBuild[] buildMap;
        List<UnityEngine.Object> independentBundles = new List<UnityEngine.Object>();
        string prefabPath;
        if (combined)
        {
            buildMap = new AssetBundleBuild[2];
            
            buildMap[0].assetBundleName = SHARED_PREFAB + ASSETBUNDLE_EXT;
            buildMap[0].assetNames = AssetDatabase.GetDependencies(new string[]{SHARED_PREFAB_PATH + PREFAB_EXT}); 
            
            buildMap[1].assetBundleName = prefab[0].name + ASSETBUNDLE_EXT;
            for (int i = 0; i < prefab.Length; i++)
            {
                prefabPath = AssetDatabase.GetAssetPath(prefab[i]);
                buildMap[1].assetNames = new string[]{prefabPath};    
            }
        }
        else
        {
            buildMap = new AssetBundleBuild[prefab.Length + 1];
            
            buildMap[0].assetBundleName = SHARED_PREFAB + ASSETBUNDLE_EXT;
            buildMap[0].assetNames = AssetDatabase.GetDependencies(new string[] {SHARED_PREFAB_PATH + PREFAB_EXT}); 
            
            for (int i = 0; i < prefab.Length; i++)
            {
                prefabPath = AssetDatabase.GetAssetPath(prefab[i]);

                if (IsIndependentBundle(prefab[i].name))
                {
                    independentBundles.Add(prefab[i]);
                }
                else 
                {
                    buildMap[i + 1].assetBundleName = prefab[i].name + ASSETBUNDLE_EXT;
                    buildMap[i + 1].assetNames = new string[]{prefabPath};
                }
            }
        }

        BuildPipeline.BuildAssetBundles(directoryPath, buildMap, BuildAssetBundleOptions.ForceRebuildAssetBundle, target);

        if (independentBundles.Count > 0)
        {
            buildMap = new AssetBundleBuild[independentBundles.Count];

            for (int i = 0; i < independentBundles.Count; i++)
            {
                prefabPath = AssetDatabase.GetAssetPath(independentBundles[i]);
                buildMap[i].assetBundleName = independentBundles[i].name + ASSETBUNDLE_EXT;
                buildMap[i].assetNames = new string[]{prefabPath};
            }

            BuildPipeline.BuildAssetBundles(directoryPath, buildMap, BuildAssetBundleOptions.ForceRebuildAssetBundle, target);
        }

        return true;
    }

    static private bool IsIndependentBundle(string prefabName)
    {
        int index = Array.FindIndex(independentBundles, item => item.Equals(prefabName));
        if (index > 0)
        {
            return true;
        }

        return false;
    }
}