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); }