private BuildPipelineCodes ExperimentalBuildPipeline()
{
var playerSettings = PlayerBuildPipeline.GeneratePlayerBuildSettings(m_Settings.buildTarget, m_Settings.buildGroup);
ScriptCompilationResult scriptResults;
var errorCode = PlayerBuildPipeline.BuildPlayerScripts(playerSettings, out scriptResults);
if (errorCode < BuildPipelineCodes.Success)
{
return(errorCode);
}
var bundleSettings = BundleBuildPipeline.GenerateBundleBuildSettings(scriptResults.typeDB, m_Settings.buildTarget, m_Settings.buildGroup);
BuildCompression compression = BuildCompression.DefaultLZ4;
if (m_Settings.compressionType == CompressionType.None)
{
compression = BuildCompression.DefaultUncompressed;
}
else if (m_Settings.compressionType == CompressionType.Lzma)
{
compression = BuildCompression.DefaultLZMA;
}
BundleBuildResult bundleResult;
errorCode = BundleBuildPipeline.BuildAssetBundles(BundleBuildInterface.GenerateBuildInput(), bundleSettings, compression, m_Settings.outputPath, out bundleResult, null, m_Settings.useBuildCache);
return(errorCode);
}
public static BuildPipelineCodes Build(BuildSettings settings, BuildCompression compression, string outputFolder, BuildDependencyInfo buildInfo, BuildWriteInfo writeInfo, out BuildResultInfo result, bool useCache = false, BuildProgressTracker progressTracker = null)
{
result = new BuildResultInfo();
// Write out resource files
var commandSetWriter = new BuildWriteWriter(useCache, progressTracker);
var exitCode = commandSetWriter.Convert(writeInfo, settings, buildInfo.buildGlobalUsage, out result);
if (exitCode < BuildPipelineCodes.Success)
{
return(exitCode);
}
// Archive and compress resource files
var resourceArchiver = new ResourceFileArchiver(useCache, progressTracker);
exitCode = resourceArchiver.Convert(result, compression, outputFolder, out result.bundleCRCs);
if (exitCode < BuildPipelineCodes.Success)
{
return(exitCode);
}
// Generate Unity5 compatible manifest files
//string[] manifestfiles;
//var manifestWriter = new Unity5ManifestWriter(useCache, true);
//if (!manifestWriter.Convert(commandSet, output, crc, outputFolder, out manifestfiles))
// return false;
return(exitCode);
}
private Hash128 CalculateInputHash(List <ResourceFile> resourceFiles, BuildCompression compression)
{
if (!UseCache)
{
return(new Hash128());
}
var fileHashes = new List <string>();
foreach (var file in resourceFiles)
{
fileHashes.Add(HashingMethods.CalculateFileMD5Hash(file.fileName).ToString());
}
return(HashingMethods.CalculateMD5Hash(Version, fileHashes, compression));
}
private BuildCompression ConverBundleCompressiontToBuildCompression(
BundledAssetGroupSchema.BundleCompressionMode compressionMode)
{
BuildCompression compresion = BuildCompression.LZMA;
switch (compressionMode)
{
case BundledAssetGroupSchema.BundleCompressionMode.LZMA:
break;
case BundledAssetGroupSchema.BundleCompressionMode.LZ4:
compresion = BuildCompression.LZ4;
break;
case BundledAssetGroupSchema.BundleCompressionMode.Uncompressed:
compresion = BuildCompression.Uncompressed;
break;
}
return(compresion);
}
internal static AssetBundleManifest BuildAssetBundles_Internal(string outputPath, BuildInput buildInput, BuildAssetBundleOptions assetBundleOptions, BuildTarget targetPlatform)
{
var playerSettings = PlayerBuildPipeline.GeneratePlayerBuildSettings(targetPlatform);
ScriptCompilationResult scriptResults;
var errorCode = PlayerBuildPipeline.BuildPlayerScripts(playerSettings, out scriptResults);
if (errorCode < BuildPipelineCodes.Success)
{
return(null);
}
var bundleSettings = BundleBuildPipeline.GenerateBundleBuildSettings(scriptResults.typeDB, targetPlatform);
BuildCompression compression = BuildCompression.DefaultLZMA;
if ((assetBundleOptions & BuildAssetBundleOptions.ChunkBasedCompression) != 0)
{
compression = BuildCompression.DefaultLZ4;
}
else if ((assetBundleOptions & BuildAssetBundleOptions.UncompressedAssetBundle) != 0)
{
compression = BuildCompression.DefaultUncompressed;
}
var useCache = (assetBundleOptions & BuildAssetBundleOptions.ForceRebuildAssetBundle) == 0;
BundleBuildResult result;
errorCode = BundleBuildPipeline.BuildAssetBundles(buildInput, bundleSettings, compression, outputPath, out result, useCache);
if (errorCode < BuildPipelineCodes.Success)
{
return(null);
}
// TODO: Unity 5 Manifest
return(null);
}
public void WhenCompressionSetForGroups_GetCompressionForIdentifier_ReturnsExpectedCompression()
{
var bundleToAssetGroup = new Dictionary <string, string>();
var expectedValues = new BuildCompression[] { BuildCompression.Uncompressed, BuildCompression.LZ4, BuildCompression.LZMA, BuildCompression.UncompressedRuntime, BuildCompression.LZ4Runtime };
var bundleNames = new List <string>();
foreach (var en in GetValues(typeof(BundledAssetGroupSchema.BundleCompressionMode)))
{
var g = Settings.CreateGroup(en.ToString(), true, false, false, null, typeof(BundledAssetGroupSchema));
g.GetSchema <BundledAssetGroupSchema>().Compression = (BundledAssetGroupSchema.BundleCompressionMode)en;
var bName = "bundle_" + en;
bundleToAssetGroup.Add(bName, g.Guid);
bundleNames.Add(bName);
}
var testParams = new AddressableAssetsBundleBuildParameters(Settings, bundleToAssetGroup, BuildTarget.StandaloneWindows64, BuildTargetGroup.Standalone, "Unused");
for (int i = 0; i < bundleNames.Count; i++)
{
var comp = testParams.GetCompressionForIdentifier(bundleNames[i]);
Assert.AreEqual(expectedValues[i].blockSize, comp.blockSize);
Assert.AreEqual(expectedValues[i].compression, comp.compression);
Assert.AreEqual(expectedValues[i].level, comp.level);
}
}
static CacheEntry GetCacheEntry(string bundleName, IEnumerable <ResourceFile> resources, BuildCompression compression)
{
var entry = new CacheEntry();
entry.Type = CacheEntry.EntryType.Data;
entry.Guid = HashingMethods.Calculate("ArchiveAndCompressBundles", bundleName).ToGUID();
entry.Hash = HashingMethods.Calculate(kVersion, resources, compression).ToHash128();
entry.Version = kVersion;
return(entry);
}
static CacheEntry GetCacheEntry(IBuildCache cache, string bundleName, IEnumerable <ResourceFile> resources, BuildCompression compression)
{
var entry = new CacheEntry();
entry.Type = CacheEntry.EntryType.Data;
entry.Guid = HashingMethods.Calculate("ArchiveAndCompressBundles", bundleName).ToGUID();
List <object> toHash = new List <object> {
kVersion, compression
};
foreach (var resource in resources)
{
toHash.Add(resource.serializedFile);
toHash.Add(resource.fileAlias);
toHash.Add(cache.GetCacheEntry(resource.fileName).Hash);
}
entry.Hash = HashingMethods.Calculate(toHash).ToHash128();
entry.Version = kVersion;
return(entry);
}
public override BuildPipelineCodes Convert(List <BuildOutput.Result> writenData, SceneResourceMap sceneResources, BuildCompression compression, string outputFolder, out BundleCRCMap output)
{
StartProgressBar("Archiving Resource Files", writenData.Count);
output = new BundleCRCMap();
foreach (var bundle in writenData)
{
if (!UpdateProgressBar(string.Format("Bundle: {0}", bundle.assetBundleName)))
{
EndProgressBar();
return(BuildPipelineCodes.Canceled);
}
var resourceFiles = new List <ResourceFile>(bundle.resourceFiles);
foreach (var asset in bundle.assetBundleAssets)
{
ResourceFile[] sceneFiles;
if (!sceneResources.TryGetValue(asset, out sceneFiles))
{
continue;
}
resourceFiles.AddRange(sceneFiles);
}
var filePath = string.Format("{0}/{1}", outputFolder, bundle.assetBundleName);
uint crc;
Hash128 hash = CalculateInputHash(resourceFiles, compression);
if (UseCache && TryLoadFromCache(hash, outputFolder, out crc))
{
output[filePath] = crc;
continue;
}
crc = BundleBuildInterface.ArchiveAndCompress(resourceFiles.ToArray(), filePath, compression);
output[filePath] = crc;
if (UseCache && !TrySaveToCache(hash, bundle.assetBundleName, crc, outputFolder))
{
BuildLogger.LogWarning("Unable to cache ResourceFileArchiver result for bundle {0}.", bundle.assetBundleName);
}
}
if (!EndProgressBar())
{
return(BuildPipelineCodes.Canceled);
}
return(BuildPipelineCodes.Success);
}
public static BuildPipelineCodes BuildAssetBundles(BuildInput input, BuildSettings settings, BuildCompression compression, string outputFolder, out BuildResultInfo result, object callbackUserData = null, bool useCache = true)
{
var buildTimer = new Stopwatch();
buildTimer.Start();
if (ProjectValidator.HasDirtyScenes())
{
result = new BuildResultInfo();
buildTimer.Stop();
BuildLogger.LogError("Build Asset Bundles failed in: {0:c}. Error: {1}.", buildTimer.Elapsed, BuildPipelineCodes.UnsavedChanges);
return(BuildPipelineCodes.UnsavedChanges);
}
var exitCode = BuildPipelineCodes.Success;
result = new BuildResultInfo();
AssetDatabase.SaveAssets();
// TODO: Until new AssetDatabaseV2 is online, we need to switch platforms
EditorUserBuildSettings.SwitchActiveBuildTarget(settings.group, settings.target);
var stepCount = BundleDependencyStep.StepCount + BundlePackingStep.StepCount + BundleWritingStep.StepCount;
using (var progressTracker = new BuildProgressTracker(stepCount))
{
using (var buildCleanup = new BuildStateCleanup(true, kTempBundleBuildPath))
{
BuildDependencyInfo buildInfo;
exitCode = BundleDependencyStep.Build(input, settings, out buildInfo, useCache, progressTracker);
if (exitCode < BuildPipelineCodes.Success)
{
return(exitCode);
}
if (PostBuildDependency != null)
{
exitCode = PostBuildDependency.Invoke(buildInfo, callbackUserData);
if (exitCode < BuildPipelineCodes.Success)
{
return(exitCode);
}
}
BuildWriteInfo writeInfo;
exitCode = BundlePackingStep.Build(buildInfo, out writeInfo, useCache, progressTracker);
if (exitCode < BuildPipelineCodes.Success)
{
return(exitCode);
}
if (PostBuildPacking != null)
{
exitCode = PostBuildPacking.Invoke(buildInfo, writeInfo, callbackUserData);
if (exitCode < BuildPipelineCodes.Success)
{
return(exitCode);
}
}
exitCode = BundleWritingStep.Build(settings, compression, outputFolder, buildInfo, writeInfo, out result, useCache, progressTracker);
if (exitCode < BuildPipelineCodes.Success)
{
return(exitCode);
}
if (PostBuildWriting != null)
{
exitCode = PostBuildWriting.Invoke(buildInfo, writeInfo, result, callbackUserData);
if (exitCode < BuildPipelineCodes.Success)
{
return(exitCode);
}
}
}
}
buildTimer.Stop();
if (exitCode >= BuildPipelineCodes.Success)
{
BuildLogger.Log("Build Asset Bundles successful in: {0:c}", buildTimer.Elapsed);
}
else if (exitCode == BuildPipelineCodes.Canceled)
{
BuildLogger.LogWarning("Build Asset Bundles canceled in: {0:c}", buildTimer.Elapsed);
}
else
{
BuildLogger.LogError("Build Asset Bundles failed in: {0:c}. Error: {1}.", buildTimer.Elapsed, exitCode);
}
return(exitCode);
}
public ReturnCode Run()
{
Dictionary <string, ulong> fileOffsets = new Dictionary <string, ulong>();
List <KeyValuePair <string, List <ResourceFile> > > bundleResources;
{
Dictionary <string, List <ResourceFile> > bundleToResources = new Dictionary <string, List <ResourceFile> >();
foreach (var pair in m_Results.WriteResults)
{
string bundle = m_WriteData.FileToBundle[pair.Key];
List <ResourceFile> resourceFiles;
bundleToResources.GetOrAdd(bundle, out resourceFiles);
resourceFiles.AddRange(pair.Value.resourceFiles);
foreach (ResourceFile serializedFile in pair.Value.resourceFiles)
{
if (!serializedFile.serializedFile)
{
continue;
}
ObjectSerializedInfo firstObject = pair.Value.serializedObjects.First(x => x.header.fileName == serializedFile.fileAlias);
fileOffsets[serializedFile.fileName] = firstObject.header.offset;
}
}
bundleResources = bundleToResources.ToList();
}
Dictionary <string, HashSet <string> > bundleDependencies = new Dictionary <string, HashSet <string> >();
foreach (var files in m_WriteData.AssetToFiles.Values)
{
if (files.IsNullOrEmpty())
{
continue;
}
string bundle = m_WriteData.FileToBundle[files.First()];
HashSet <string> dependencies;
bundleDependencies.GetOrAdd(bundle, out dependencies);
dependencies.UnionWith(files.Select(x => m_WriteData.FileToBundle[x]));
dependencies.Remove(bundle);
}
IList <CacheEntry> entries = bundleResources.Select(x => GetCacheEntry(x.Key, x.Value, m_Parameters.GetCompressionForIdentifier(x.Key))).ToList();
IList <CachedInfo> cachedInfo = null;
IList <CachedInfo> uncachedInfo = null;
if (m_Parameters.UseCache && m_Cache != null)
{
m_Cache.LoadCachedData(entries, out cachedInfo);
uncachedInfo = new List <CachedInfo>();
}
for (int i = 0; i < bundleResources.Count; i++)
{
string bundleName = bundleResources[i].Key;
ResourceFile[] resourceFiles = bundleResources[i].Value.ToArray();
BuildCompression compression = m_Parameters.GetCompressionForIdentifier(bundleName);
string writePath;
BundleDetails details;
if (cachedInfo != null && cachedInfo[i] != null)
{
if (!m_Tracker.UpdateInfoUnchecked(string.Format("{0} (Cached)", bundleName)))
{
return(ReturnCode.Canceled);
}
details = (BundleDetails)cachedInfo[i].Data[0];
details.FileName = m_Parameters.GetOutputFilePathForIdentifier(bundleName);
HashSet <string> dependencies;
if (bundleDependencies.TryGetValue(bundleName, out dependencies))
{
details.Dependencies = dependencies.ToArray();
}
else
{
details.Dependencies = new string[0];
}
writePath = string.Format("{0}/{1}", m_Cache.GetCachedArtifactsDirectory(entries[i]), bundleName);
}
else
{
if (!m_Tracker.UpdateInfoUnchecked(bundleName))
{
return(ReturnCode.Canceled);
}
details = new BundleDetails();
writePath = string.Format("{0}/{1}", m_Parameters.TempOutputFolder, bundleName);
if (m_Parameters.UseCache && m_Cache != null)
{
writePath = string.Format("{0}/{1}", m_Cache.GetCachedArtifactsDirectory(entries[i]), bundleName);
}
Directory.CreateDirectory(Path.GetDirectoryName(writePath));
details.FileName = m_Parameters.GetOutputFilePathForIdentifier(bundleName);
details.Crc = ContentBuildInterface.ArchiveAndCompress(resourceFiles, writePath, compression);
details.Hash = CalculateHashVersion(fileOffsets, resourceFiles);
HashSet <string> dependencies;
if (bundleDependencies.TryGetValue(bundleName, out dependencies))
{
details.Dependencies = dependencies.ToArray();
}
else
{
details.Dependencies = new string[0];
}
if (uncachedInfo != null)
{
uncachedInfo.Add(GetCachedInfo(m_Cache, entries[i], resourceFiles, details));
}
}
SetOutputInformation(writePath, details.FileName, bundleName, details);
}
if (m_Parameters.UseCache && m_Cache != null)
{
m_Cache.SaveCachedData(uncachedInfo);
}
return(ReturnCode.Success);
}
