private static BundlerManifest GenerateBundlerManifest(ref BundlesInfo bundlesInfo)
{
var manifest = new BundlerManifest();
foreach (var kv in bundlesInfo)
{
var bundleName = kv.Key;
var assets = kv.Value.assets;
var dependencies = kv.Value.dependencies;
// No assets in this bundle, skips.
if (assets.Count <= 0)
{
continue;
}
// Generate assets data
foreach (var asset in assets)
{
if (manifest.assets.ContainsKey(asset))
{
throw new BundleException(string.Format(
"Asset duplicated: {0}, already reference in bundle: {1}, conflict with: {2}",
asset, manifest.assets[asset].bundle, bundleName));
}
var assetData = new AssetData
{
//name = asset, // Memory optimized
bundle = bundleName
};
manifest.assets.Add(asset, assetData);
}
// Generate bundles data
if (manifest.bundles.ContainsKey(bundleName))
{
throw new BundleException(string.Format("Bundle duplicated: {0}", bundleName));
}
//manifest.bundles.Add(bundleName, new BundleData {name = bundleName}); // Memory optimized
manifest.bundles.Add(bundleName, new BundleData {
assets = assets.ToList()
});
foreach (var depName in dependencies)
{
manifest.bundles[bundleName].dependencies.Add(depName);
}
}
foreach (var kv in manifest.bundles)
{
kv.Value.assets.Sort();
kv.Value.dependencies.Sort();
}
return(manifest);
}
public static void GenerateAssetBundles(BundlerManifest manifest, BuildTarget platform, string outputPath)
{
var builds = GenerateAssetBundleBuilds(manifest);
Debug.Log(string.Format("Generate asset bundles to path: {0}, build count: {1}", outputPath, builds.Length));
var assetBundleManifest = BuildPipeline.BuildAssetBundles(outputPath, builds, BundlerBuildSettings.kAssetBundleBuildOptions, platform);
if (null == assetBundleManifest)
{
throw new BundleBuildFailedException(
"Asset bundle build failed with errors, see the console output to get more information.");
}
}
private static void SaveManifest(ref BundlerManifest manifest, string outputPath)
{
var directory = Path.GetDirectoryName(outputPath);
if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
var jsonData = JsonUtility.ToJson(manifest);
File.WriteAllText(outputPath, jsonData);
}
public static void StripUnmanagedFiles(BundlerBuildRule buildRule, BundlerManifest manifest)
{
var managedFiles = GetManagedFilesByRules(buildRule);
var toRemoved = new List <string>();
foreach (var kv in manifest.assets)
{
if (!managedFiles.Contains(kv.Key))
{
toRemoved.Add(kv.Key);
}
}
toRemoved.ForEach(v => manifest.assets.Remove(v));
Debug.Log(string.Format("{0} unmanaged files removed from manifest.", toRemoved.Count));
}
private static AssetBundleBuild[] GenerateAssetBundleBuilds(BundlerManifest manifest)
{
var bundles = new Dictionary <string, HashSet <string> >();
foreach (var kv in manifest.assets)
{
if (!bundles.ContainsKey(kv.Value.bundle))
{
bundles.Add(kv.Value.bundle, new HashSet <string>());
}
// Editor only objects cannot be included in AssetBundles
if (kv.Key.EndsWith("LightingData.asset"))
{
continue;
}
if (!IsAssetBundleResources(kv.Key))
{
continue;
}
bundles[kv.Value.bundle].Add(kv.Key);
}
var builds = new List <AssetBundleBuild>();
foreach (var kv in bundles)
{
if (kv.Value.Count <= 0)
{
continue;
}
var build = new AssetBundleBuild
{
assetBundleName = kv.Key,
assetNames = kv.Value.ToArray()
};
builds.Add(build);
}
return(builds.ToArray());
}
/// <summary>
/// Re-generate target asset bundle. Dependencies WON'T be re-generated.
/// </summary>
/// <param name="manifest"></param>
/// <param name="path"></param>
/// <param name="platform"></param>
/// <param name="outputPath"></param>
public static void RegenerateAssetBundle(BundlerManifest manifest, string path, BuildTarget platform,
string outputPath)
{
var bundleName = PathUtility.NormalizeAssetBundlePath(path);
var assets = manifest.assets.Where(v => v.Value.bundle == bundleName);
var build = new AssetBundleBuild
{
assetNames = assets.Select(v => v.Key).ToArray(),
assetBundleName = bundleName
};
var assetBundleManifest = BuildPipeline.BuildAssetBundles(outputPath, new[] { build }, BundlerBuildSettings.kAssetBundleBuildOptions, platform);
if (null == assetBundleManifest)
{
throw new BundleBuildFailedException(
"Asset bundle build failed with errors, see the console output to get more information.");
}
}
internal ModeBase(BundlerManifest manifest, List <string> searchPaths, BundlerContext context)
{
_manifest = manifest;
_searchPaths = searchPaths;
_context = context;
}
= new Dictionary <ILoadRequestAsync, Dictionary <Type, IAssetAsync> >(); // Load request <=> Asset typed dict.
internal BundleMode(BundlerManifest manifest, List <string> searchPaths, BundlerContext context)
: base(manifest, searchPaths, context)
{
}
/// <summary>
/// Validate bundle dependencies
/// </summary>
/// <param name="manifest"></param>
/// <param name="outputPath"></param>
/// <exception cref="BundleException"></exception>
public static void ValidateBundleDependencies(BundlerManifest manifest, string outputPath)
{
var abManifestPath = string.Format("{0}/{1}", outputPath, new DirectoryInfo(outputPath).Name);
var abManifestRelativePath = PathUtility.AbsolutePathToRelativeProjectPath(abManifestPath);
var ab = AssetBundle.LoadFromFile(abManifestRelativePath);
if (!ab)
{
throw new BundleException("Load asset bundle failed: " + abManifestPath);
}
var abManifest = ab.LoadAsset <AssetBundleManifest>("AssetBundleManifest");
if (!abManifest)
{
ab.Unload(true);
throw new BundleException("Load asset bundle manifest failed: " + abManifestPath);
}
void ValidateBundle(string assetBundle, List <string> validated)
{
if (validated.Contains(assetBundle))
{
throw new BundleException("Circular dependency detected: " + assetBundle);
}
validated.Add(assetBundle);
if (!manifest.bundles.ContainsKey(assetBundle))
{
throw new BundleException("Bundle does not contain in manifest: " + assetBundle);
}
var dependencies = abManifest.GetDirectDependencies(assetBundle);
foreach (var dependency in dependencies)
{
if (!manifest.bundles[assetBundle].dependencies.Contains(dependency))
{
throw new BundleException(string.Format(
"Bundle dependencies lost, bundle name: {0}, dependency: {1}", assetBundle, dependency));
}
//Debug.Log("Validating dependency: " + dependency);
ValidateBundle(dependency, validated);
}
validated.Remove(assetBundle);
}
var index = 0f;
var abs = abManifest.GetAllAssetBundles();
try {
foreach (var assetBundle in abs)
{
EditorUtility.DisplayProgressBar("Validating asset bundle", assetBundle, index++ / abs.Length);
//Debug.Log("Validating asset bundle: " + assetBundle);
ValidateBundle(assetBundle, new List <string>());
}
}
finally {
EditorUtility.ClearProgressBar();
ab.Unload(true);
AssetBundle.UnloadAllAssetBundles(true);
}
}
