[email protected]

## [0.0.9-preview] - 2018-04-04
- Added documentation for IWriteOperation implementations
- Added documentation for ReturnCodes, LegacyBuildPipeline, and ContentPipeline
- Ran Unity code analysis & cleaned up warnings (boxing, performance issues, name consistency)
- Breaking api change: Changed build tasks' public static run method to private.
- Added null checks and ArgumentNullExceptions

CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [0.0.9-preview] - 2018-04-04
+- Added documentation for IWriteOperation implementations
+- Added documentation for ReturnCodes, LegacyBuildPipeline, and ContentPipeline
+- Ran Unity code analysis & cleaned up warnings (boxing, performance issues, name consistency)
+- Breaking api change: Changed build tasks' public static run method to private.
+- Added null checks and ArgumentNullExceptions
+
 ## [0.0.8-preview] - 2018-03-27
 - Test rename & meta file cleanup
 - Added documentation for shared classes / structs

Editor/ContentPipeline.cs

@@ -1,36 +1,77 @@
-using System.Diagnostics;
+using System;
+using System.IO;
 using UnityEditor.Build.Pipeline.Interfaces;
 using UnityEditor.Build.Pipeline.Utilities;
 
-namespace UnityEditor.Build.Pipeline.Content
+namespace UnityEditor.Build.Pipeline
 {
+    /// <summary>
+    /// Static class containing the main content building entry points into the Scriptable Build Pipeline.
+    /// </summary>
     public static class ContentPipeline
     {
+        /// <summary>
+        /// Default temporary path used for building content data.
+        /// </summary>
         public const string kTempBuildPath = "Temp/ContentBuildData";
 
+        /// <summary>
+        /// Default callback implementation.
+        /// </summary>
         public static BuildCallbacks BuildCallbacks = new BuildCallbacks();
 
-        public static ReturnCodes BuildAssetBundles(IBuildParameters buildParameters, IBundleBuildContent buildContent, out IBundleBuildResults result)
+        /// <summary>
+        /// Default implementation of generating Asset Bundles using the Scriptable Build Pipeline.
+        /// </summary>
+        /// <param name="buildParameters">Set of parameters used for building asset bundles.</param>
+        /// <param name="buildContent">Set of content and explicit asset bundle layout to build.</param>
+        /// <param name="result">Results from building the content and explicit asset bundle layout.</param>
+        /// <returns>Return code with status information about success or failure causes.</returns>
+        public static ReturnCode BuildAssetBundles(IBuildParameters buildParameters, IBundleBuildContent buildContent, out IBundleBuildResults result)
         {
-            ReturnCodes exitCode;
+            // Avoid throwing exceptions in here as we don't want them bubbling up to calling user code
+            if (buildParameters == null)
+            {
+                result = null;
+                BuildLogger.LogException(new ArgumentNullException("buildParameters"));
+                return ReturnCode.Exception;
+            }
+
+            ReturnCode exitCode;
             result = new BundleBuildResults();
 
             using (var progressTracker = new ProgressTracker())
             {
-                using (var buildCleanup = new BuildStateCleanup(buildParameters.TempOutputFolder))
+                Directory.CreateDirectory(buildParameters.TempOutputFolder);
+
+                var buildContext = new BuildContext();
+                try
                 {
-                    var buildContext = new BuildContext(buildParameters, buildContent, result, progressTracker);
+                    buildContext.SetContextObject(buildParameters);
+                    buildContext.SetContextObject(buildContent);
+                    buildContext.SetContextObject(result);
+                    buildContext.SetContextObject(progressTracker);
                     buildContext.SetContextObject(new BuildCache());
                     buildContext.SetContextObject(new Unity5PackedIdentifiers());
                     buildContext.SetContextObject(new BuildDependencyData());
                     buildContext.SetContextObject(new BundleWriteData());
                     buildContext.SetContextObject(BuildCallbacks);
-
-                    var pipeline = DefaultBuildTasks.Create(DefaultBuildTasks.Presets.AssetBundleCompatible, buildParameters.ScriptInfo == null);
-                    exitCode = BuildTasksRunner.Validate(pipeline, buildContext);
-                    if (exitCode >= ReturnCodes.Success)
-                        exitCode = BuildTasksRunner.Run(pipeline, buildContext);
                 }
+                catch (Exception e)
+                {
+                    // Avoid throwing exceptions in here as we don't want them bubbling up to calling user code
+                    result = null;
+                    BuildLogger.LogException(e);
+                    return ReturnCode.Exception;
+                }
+
+                var pipeline = DefaultBuildTasks.Create(DefaultBuildTasks.Preset.AssetBundleCompatible, buildParameters.ScriptInfo == null);
+                exitCode = BuildTasksRunner.Validate(pipeline, buildContext);
+                if (exitCode >= ReturnCode.Success)
+                    exitCode = BuildTasksRunner.Run(pipeline, buildContext);
+
+                if (Directory.Exists(buildParameters.TempOutputFolder))
+                    Directory.Delete(buildParameters.TempOutputFolder, true);
             }
             return exitCode;
         }

Editor/Interfaces/IBuildContext.cs

@@ -18,7 +18,7 @@ public interface IScriptsCallback : IContextObject
         /// <param name="buildParameters">Parameters passed into the build pipeline.</param>
         /// <param name="buildResults">Results from the script building step.</param>
         /// <returns>Return code from processing the callbacks.</returns>
-        ReturnCodes PostScripts(IBuildParameters buildParameters, IBuildResults buildResults);
+        ReturnCode PostScripts(IBuildParameters buildParameters, IBuildResults buildResults);
     }
 
     /// <summary>
@@ -32,7 +32,7 @@ public interface IDependencyCallback : IContextObject
         /// <param name="buildParameters">Parameters passed into the build pipeline.</param>
         /// <param name="dependencyData">Results from the dependency calculation step.</param>
         /// <returns>Return code from processing the callbacks.</returns>
-        ReturnCodes PostDependency(IBuildParameters buildParameters, IDependencyData dependencyData);
+        ReturnCode PostDependency(IBuildParameters buildParameters, IDependencyData dependencyData);
     }
 
     /// <summary>
@@ -47,7 +47,7 @@ public interface IPackingCallback : IContextObject
         /// <param name="dependencyData">Results from the dependency calculation step.</param>
         /// <param name="writeData">Results from the packing step.</param>
         /// <returns>Return code from processing the callbacks.</returns>
-        ReturnCodes PostPacking(IBuildParameters buildParameters, IDependencyData dependencyData, IWriteData writeData);
+        ReturnCode PostPacking(IBuildParameters buildParameters, IDependencyData dependencyData, IWriteData writeData);
     }
 
     /// <summary>
@@ -63,7 +63,7 @@ public interface IWritingCallback : IContextObject
         /// <param name="writeData">Results from the packing step.</param>
         /// <param name="buildResults">Results from the writing step.</param>
         /// <returns>Return code from processing the callbacks.</returns>
-        ReturnCodes PostWriting(IBuildParameters buildParameters, IDependencyData dependencyData, IWriteData writeData, IBuildResults buildResults);
+        ReturnCode PostWriting(IBuildParameters buildParameters, IDependencyData dependencyData, IWriteData writeData, IBuildResults buildResults);
     }
 
     /// <summary>

Editor/Interfaces/IBuildTasks.cs

@@ -24,6 +24,6 @@ public interface IBuildTask
         /// </summary>
         /// <param name="context"><seealso cref="IBuildContent"/> that contains the required data types to run.</param>
         /// <returns>Return code with status information about success or failure causes.</returns>
-        ReturnCodes Run(IBuildContext context);
+        ReturnCode Run(IBuildContext context);
     }
 }

Editor/Interfaces/IWriteData.cs

@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using UnityEditor.Build.Content;
-using UnityEditor.Build.Pipeline.WriteTypes;
 
 namespace UnityEditor.Build.Pipeline.Interfaces
 {

Editor/Interfaces/IWriteOperation.cs

@@ -24,7 +24,6 @@ public interface IWriteOperation
         /// The specific reference data for objects in the write command.
         /// <seealso cref="BuildReferenceMap"/>
         /// </summary>
-
         BuildReferenceMap ReferenceMap { get; set; }
 
         /// <summary>

Editor/LegacyBuildPipeline.cs

@@ -1,26 +1,56 @@
 using UnityEditor.Build.Content;
-using UnityEditor.Build.Pipeline.Content;
 using UnityEditor.Build.Pipeline.Interfaces;
 using UnityEngine;
 
 namespace UnityEditor.Build.Pipeline
 {
+    /// <summary>
+    /// Static class implementing API wrappers to match BuildPipeline APIs but use the Scriptable Build Pipeline.
+    /// <seealso cref="BuildPipeline.BuildAssetBundles"/>
+    /// </summary>
     public static class LegacyBuildPipeline
     {
+        /// <summary>
+        /// Wrapper API to match BuildPipeline API but use the Scriptable Build Pipeline to build Asset Bundles.
+        /// <seealso cref="BuildPipeline.BuildAssetBundles(string, BuildAssetBundleOptions, BuildTarget)"/>
+        /// </summary>
+        /// <remarks>
+        /// Not all BuildAssetBundleOptions are supported in the Scriptable Build Pipeline initial release. 
+        /// Supported options are: ChunkBasedCompression, UncompressedAssetBundle, DisableWriteTypeTree, and DisableWriteTypeTree.
+        /// In addition, existing BuildPipeline callbacks are not yet supported. Est: 2018.3 release for support.
+        /// </remarks>
+        /// <param name="outputPath">Output path for the AssetBundles.</param>
+        /// <param name="assetBundleOptions">AssetBundle building options.</param>
+        /// <param name="targetPlatform">Chosen target build platform.</param>
+        /// <returns>null - Generating and returning an AssetBundleManifest is not yet supported by the Scriptable Build Pipeline. Est: 2018.3 support.</returns>
         public static AssetBundleManifest BuildAssetBundles(string outputPath, BuildAssetBundleOptions assetBundleOptions, BuildTarget targetPlatform)
         {
             var buildInput = ContentBuildInterface.GenerateAssetBundleBuilds();
             return BuildAssetBundles_Internal(outputPath, new BundleBuildContent(buildInput), assetBundleOptions, targetPlatform);
         }
 
+        /// <summary>
+        /// Wrapper API to match BuildPipeline API but use the Scriptable Build Pipeline to build Asset Bundles.
+        /// <seealso cref="BuildPipeline.BuildAssetBundles(string, AssetBundleBuild[], BuildAssetBundleOptions, BuildTarget)"/>
+        /// </summary>
+        /// <remarks>
+        /// Not all BuildAssetBundleOptions are supported in the Scriptable Build Pipeline initial release. 
+        /// Supported options are: ChunkBasedCompression, UncompressedAssetBundle, DisableWriteTypeTree, and DisableWriteTypeTree.
+        /// In addition, existing BuildPipeline callbacks are not yet supported. Est: 2018.3 release for support.
+        /// </remarks>
+        /// <param name="outputPath">Output path for the AssetBundles.</param>
+        /// <param name="builds">AssetBundle building map.</param>
+        /// <param name="assetBundleOptions">AssetBundle building options.</param>
+        /// <param name="targetPlatform">Chosen target build platform.</param>
+        /// <returns>null - Generating and returning an AssetBundleManifest is not yet supported by the Scriptable Build Pipeline. Est: 2018.3 release for support.</returns>
         public static AssetBundleManifest BuildAssetBundles(string outputPath, AssetBundleBuild[] builds, BuildAssetBundleOptions assetBundleOptions, BuildTarget targetPlatform)
         {
             return BuildAssetBundles_Internal(outputPath, new BundleBuildContent(builds), assetBundleOptions, targetPlatform);
         }
 
         internal static AssetBundleManifest BuildAssetBundles_Internal(string outputPath, IBundleBuildContent buildContent, BuildAssetBundleOptions assetBundleOptions, BuildTarget targetPlatform)
         {
-            var group = UnityEditor.BuildPipeline.GetBuildTargetGroup(targetPlatform);
+            var group = BuildPipeline.GetBuildTargetGroup(targetPlatform);
             var buildParams = new BuildParameters(targetPlatform, group, outputPath);
 
             if ((assetBundleOptions & BuildAssetBundleOptions.ChunkBasedCompression) != 0)
@@ -30,12 +60,15 @@ internal static AssetBundleManifest BuildAssetBundles_Internal(string outputPath
             else
                 buildParams.BundleCompression = BuildCompression.DefaultLZMA;
 
+            if ((assetBundleOptions & BuildAssetBundleOptions.DisableWriteTypeTree) != 0)
+                buildParams.ContentBuildFlags |= ContentBuildFlags.DisableWriteTypeTree;
+
             IBundleBuildResults results;
-            ReturnCodes exitCode = ContentPipeline.BuildAssetBundles(buildParams, buildContent, out results);
-            if (exitCode < ReturnCodes.Success)
+            ReturnCode exitCode = ContentPipeline.BuildAssetBundles(buildParams, buildContent, out results);
+            if (exitCode < ReturnCode.Success)
                 return null;
 
-            // TODO: Return Unity 5 Manifest
+            // TODO: Return Unity 5 AssetBundleManifest
             return null;
         }
     }

Editor/ReturnCodes.cs → Editor/ReturnCode.cs

@@ -1,6 +1,9 @@
 namespace UnityEditor.Build.Pipeline
 {
-    public enum ReturnCodes
+    /// <summary>
+    /// Return codes for the scriptable build pipeline. Int values of these return codes are standardized to 0 or greater for Success and -1 or less for Error.
+    /// </summary>
+    public enum ReturnCode
     {
         // Success Codes are Positive!
         Success = 0,

Editor/Shared/BuildCallbacks.cs

@@ -13,53 +13,53 @@ public class BuildCallbacks : IDependencyCallback, IPackingCallback, IWritingCal
         /// <summary>
         /// Func delegate for the callback after scripts have been compiled.
         /// </summary>
-        public Func<IBuildParameters, IBuildResults, ReturnCodes> PostScriptsCallbacks { get; set; }
+        public Func<IBuildParameters, IBuildResults, ReturnCode> PostScriptsCallbacks { get; set; }
 
         /// <summary>
         /// Func delegate for the callback after dependency calculation has occurred.
         /// </summary>
-        public Func<IBuildParameters, IDependencyData, ReturnCodes> PostDependencyCallback { get; set; }
+        public Func<IBuildParameters, IDependencyData, ReturnCode> PostDependencyCallback { get; set; }
 
         /// <summary>
         /// Func delegate for the callback after packing has occurred.
         /// </summary>
-        public Func<IBuildParameters, IDependencyData, IWriteData, ReturnCodes> PostPackingCallback { get; set; }
+        public Func<IBuildParameters, IDependencyData, IWriteData, ReturnCode> PostPackingCallback { get; set; }
 
         /// <summary>
         /// Func delegate for the callback after writing content has occurred.
         /// </summary>
-        public Func<IBuildParameters, IDependencyData, IWriteData, IBuildResults, ReturnCodes> PostWritingCallback { get; set; }
+        public Func<IBuildParameters, IDependencyData, IWriteData, IBuildResults, ReturnCode> PostWritingCallback { get; set; }
 
         /// <inheritdoc />
-        public ReturnCodes PostScripts(IBuildParameters buildParameters, IBuildResults buildResults)
+        public ReturnCode PostScripts(IBuildParameters buildParameters, IBuildResults buildResults)
         {
             if (PostScriptsCallbacks != null)
                 return PostScriptsCallbacks(buildParameters, buildResults);
-            return ReturnCodes.Success;
+            return ReturnCode.Success;
         }
 
         /// <inheritdoc />
-        public ReturnCodes PostDependency(IBuildParameters buildParameters, IDependencyData dependencyData)
+        public ReturnCode PostDependency(IBuildParameters buildParameters, IDependencyData dependencyData)
         {
             if (PostDependencyCallback != null)
                 return PostDependencyCallback(buildParameters, dependencyData);
-            return ReturnCodes.Success;
+            return ReturnCode.Success;
         }
 
         /// <inheritdoc />
-        public ReturnCodes PostPacking(IBuildParameters buildParameters, IDependencyData dependencyData, IWriteData writeData)
+        public ReturnCode PostPacking(IBuildParameters buildParameters, IDependencyData dependencyData, IWriteData writeData)
         {
             if (PostPackingCallback != null)
                 return PostPackingCallback(buildParameters, dependencyData, writeData);
-            return ReturnCodes.Success;
+            return ReturnCode.Success;
         }
 
         /// <inheritdoc />
-        public ReturnCodes PostWriting(IBuildParameters buildParameters, IDependencyData dependencyData, IWriteData writeData, IBuildResults buildResults)
+        public ReturnCode PostWriting(IBuildParameters buildParameters, IDependencyData dependencyData, IWriteData writeData, IBuildResults buildResults)
         {
             if (PostWritingCallback != null)
                 return PostWritingCallback(buildParameters, dependencyData, writeData, buildResults);
-            return ReturnCodes.Success;
+            return ReturnCode.Success;
         }
     }
 }

Editor/Shared/BuildContent.cs

@@ -24,6 +24,9 @@ public class BuildContent : IBuildContent
         /// <param name="assets">The set of Assets identified by GUID to ensure are packaged with the build</param>
         public BuildContent(IEnumerable<GUID> assets)
         {
+            if (assets == null)
+                throw new ArgumentNullException("assets");
+
             Assets = new List<GUID>();
             Scenes = new List<GUID>();
 
@@ -34,7 +37,7 @@ public BuildContent(IEnumerable<GUID> assets)
                 else if (ValidationMethods.ValidScene(asset))
                     Scenes.Add(asset);
                 else
-                    throw new ArgumentException(string.Format("Asset '{0}' is not a valid Asset or Scene.", asset));
+                    throw new ArgumentException(string.Format("Asset '{0}' is not a valid Asset or Scene.", asset.ToString()));
             }
         }
     }
@@ -64,6 +67,9 @@ public class BundleBuildContent : IBundleBuildContent
         /// <param name="bundleBuilds">The set of AssetbundleBuild to be built.</param>
         public BundleBuildContent(IEnumerable<AssetBundleBuild> bundleBuilds)
         {
+            if (bundleBuilds == null)
+                throw new ArgumentNullException("bundleBuilds");
+
             Assets = new List<GUID>();
             Scenes = new List<GUID>();
             Addresses = new Dictionary<GUID, string>();