Merge remote-tracking branch 'HTK-master/RS2_WindowsMixedReality' into HTK-BuildPatch

Cherry pick for build files.

Author: StephenHodgson

Assets/HoloToolkit/Build/Editor/BuildDeployTools.cs

@@ -20,14 +20,15 @@ namespace HoloToolkit.Unity
     public class BuildDeployTools
     {
         // Consts
-        public static readonly string DefaultMSBuildVersion = "14.0";
+        public static readonly string DefaultMSBuildVersion = "15.0";
 
         // Functions
         public static bool BuildSLN(string buildDirectory, bool showConfDlg = true)
         {
             // Use BuildSLNUtilities to create the SLN
             bool buildSuccess = false;
-            BuildSLNUtilities.PerformBuild(new BuildSLNUtilities.BuildInfo()
+
+            var buildInfo = new BuildSLNUtilities.BuildInfo()
             {
                 // These properties should all match what the Standalone.proj file specifies
                 OutputDirectory = buildDirectory,
@@ -37,7 +38,7 @@ public static bool BuildSLN(string buildDirectory, bool showConfDlg = true)
                 WSAUWPBuildType = WSAUWPBuildType.D3D,
 
                 // Configure a post build action that will compile the generated solution
-                PostBuildAction = (buildInfo, buildError) =>
+                PostBuildAction = (innerBuildInfo, buildError) =>
                 {
                     if (!string.IsNullOrEmpty(buildError))
                     {
@@ -52,13 +53,19 @@ public static bool BuildSLN(string buildDirectory, bool showConfDlg = true)
                         buildSuccess = true;
                     }
                 }
-            });
+            };
+
+            BuildSLNUtilities.RaiseOverrideBuildDefaults(ref buildInfo);
+
+            BuildSLNUtilities.PerformBuild(buildInfo);
 
             return buildSuccess;
         }
 
         public static string CalcMSBuildPath(string msBuildVersion)
         {
+            // TODO: robertes: If this is going to support msbuild 15 and beyond, it needs to be updated to use the COM or powershell interfaces to find msbuild.
+            //                 See: https://github.com/Microsoft/vssetup.powershell/wiki
             using (Microsoft.Win32.RegistryKey key = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(string.Format(@"Software\Microsoft\MSBuild\ToolsVersions\{0}", msBuildVersion)))
             {
                 if (key == null)

Assets/HoloToolkit/Build/Editor/BuildSLNUtilities.cs

@@ -8,6 +8,7 @@
 using System.Globalization;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Xml;
 using UnityEditor;
 using UnityEngine;
@@ -51,6 +52,8 @@ public class BuildInfo
 
             public WSASDK? WSASdk { get; set; }
 
+            public string WsaUwpSdk { get; set; }
+
             public WSAUWPBuildType? WSAUWPBuildType { get; set; }
 
             public Boolean? WSAGenerateReferenceProjects { get; set; }
@@ -66,53 +69,80 @@ public BuildInfo()
 
             public void AppendSymbols(params string[] symbol)
             {
-                AppendSymbols((IEnumerable<string>)symbol);
+                this.AppendSymbols((IEnumerable<string>)symbol);
             }
 
             public void AppendSymbols(IEnumerable<string> symbols)
             {
-                string[] toAdd = symbols.Except(BuildSymbols.Split(';'))
+                string[] toAdd = symbols.Except(this.BuildSymbols.Split(';'))
                     .Where(sym => !string.IsNullOrEmpty(sym)).ToArray();
 
                 if (!toAdd.Any())
                 {
                     return;
                 }
 
-                if (!String.IsNullOrEmpty(BuildSymbols))
+                if (!String.IsNullOrEmpty(this.BuildSymbols))
                 {
-                    BuildSymbols += ";";
+                    this.BuildSymbols += ";";
                 }
 
-                BuildSymbols += String.Join(";", toAdd);
+                this.BuildSymbols += String.Join(";", toAdd);
             }
 
             public bool HasAnySymbols(params string[] symbols)
             {
-                return BuildSymbols.Split(';').Intersect(symbols).Any();
+                return this.BuildSymbols.Split(';').Intersect(symbols).Any();
             }
 
             public bool HasConfigurationSymbol()
             {
                 return HasAnySymbols(
-                    BuildSymbolDebug,
-                    BuildSymbolRelease,
-                    BuildSymbolMaster);
+                    BuildSLNUtilities.BuildSymbolDebug,
+                    BuildSLNUtilities.BuildSymbolRelease,
+                    BuildSLNUtilities.BuildSymbolMaster);
             }
 
             public static IEnumerable<string> RemoveConfigurationSymbols(string symbolstring)
             {
                 return symbolstring.Split(';').Except(new[]
                 {
-                    BuildSymbolDebug,
-                    BuildSymbolRelease,
-                    BuildSymbolMaster
+                    BuildSLNUtilities.BuildSymbolDebug,
+                    BuildSLNUtilities.BuildSymbolRelease,
+                    BuildSLNUtilities.BuildSymbolMaster
                 });
             }
 
             public bool HasAnySymbols(IEnumerable<string> symbols)
             {
-                return BuildSymbols.Split(';').Intersect(symbols).Any();
+                return this.BuildSymbols.Split(';').Intersect(symbols).Any();
+            }
+        }
+
+        /// <summary>
+        /// A method capable of configuring <see cref="BuildInfo"/> settings.
+        /// </summary>
+        /// <param name="toConfigure">The settings to configure.</param>
+        public delegate void BuildInfoConfigurationMethod(ref BuildInfo toConfigure);
+
+        /// <summary>
+        /// Add a handler to this event to override <see cref="BuildInfo"/> defaults before a build.
+        /// </summary>
+        /// <seealso cref="RaiseOverrideBuildDefaults"/>
+        public static event BuildInfoConfigurationMethod OverrideBuildDefaults;
+
+        /// <summary>
+        /// Call this method to give other code an opportunity to override <see cref="BuildInfo"/> defaults.
+        /// </summary>
+        /// <param name="toConfigure">>The settings to configure.</param>
+        /// <seealso cref="OverrideBuildDefaults"/>
+        public static void RaiseOverrideBuildDefaults(ref BuildInfo toConfigure)
+        {
+            var handlers = OverrideBuildDefaults;
+
+            if (handlers != null)
+            {
+                handlers(ref toConfigure);
             }
         }
 
@@ -151,37 +181,39 @@ public static void PerformBuild(BuildInfo buildInfo)
             {
                 if (!buildInfo.HasConfigurationSymbol())
                 {
-                    buildInfo.AppendSymbols(BuildSymbolDebug);
+                    buildInfo.AppendSymbols(BuildSLNUtilities.BuildSymbolDebug);
                 }
             }
 
-            if (buildInfo.HasAnySymbols(BuildSymbolDebug))
+            if (buildInfo.HasAnySymbols(BuildSLNUtilities.BuildSymbolDebug))
             {
                 buildInfo.BuildOptions |= BuildOptions.Development | BuildOptions.AllowDebugging;
             }
 
-            if (buildInfo.HasAnySymbols(BuildSymbolRelease))
+            if (buildInfo.HasAnySymbols(BuildSLNUtilities.BuildSymbolRelease))
             {
                 //Unity automatically adds the DEBUG symbol if the BuildOptions.Development flag is
                 //specified. In order to have debug symbols and the RELEASE symbole we have to
                 //inject the symbol Unity relies on to enable the /debug+ flag of csc.exe which is "DEVELOPMENT_BUILD"
                 buildInfo.AppendSymbols("DEVELOPMENT_BUILD");
             }
 
-            BuildTarget oldBuildTarget = EditorUserBuildSettings.activeBuildTarget;
-            BuildTargetGroup oldBuildTargetGroup = GetGroup(oldBuildTarget);
-
-            EditorUserBuildSettings.SwitchActiveBuildTarget(buildTargetGroup, buildInfo.BuildTarget);
+            var oldBuildTarget = EditorUserBuildSettings.activeBuildTarget;
+            EditorUserBuildSettings.SwitchActiveBuildTarget(buildInfo.BuildTarget);
 
             var oldWSASDK = EditorUserBuildSettings.wsaSDK;
             if (buildInfo.WSASdk.HasValue)
             {
                 EditorUserBuildSettings.wsaSDK = buildInfo.WSASdk.Value;
             }
 
+            string oldWsaUwpSdk = null;
             WSAUWPBuildType? oldWSAUWPBuildType = null;
             if (EditorUserBuildSettings.wsaSDK == WSASDK.UWP)
             {
+                oldWsaUwpSdk = EditorUserBuildSettings.wsaUWPSDK;
+                EditorUserBuildSettings.wsaUWPSDK = buildInfo.WsaUwpSdk;
+
                 oldWSAUWPBuildType = EditorUserBuildSettings.wsaUWPBuildType;
                 if (buildInfo.WSAUWPBuildType.HasValue)
                 {
@@ -209,6 +241,11 @@ public static void PerformBuild(BuildInfo buildInfo)
             string buildError = "Error";
             try
             {
+                if (EditorUserBuildSettings.wsaSDK == WSASDK.UWP)
+                {
+                    VerifyWsaUwpSdkIsInstalled(EditorUserBuildSettings.wsaUWPSDK);
+                }
+
                 // For the WSA player, Unity builds into a target directory.
                 // For other players, the OutputPath parameter indicates the
                 // path to the target executable to build.
@@ -233,25 +270,84 @@ public static void PerformBuild(BuildInfo buildInfo)
             {
                 OnPostProcessBuild(buildInfo, buildError);
 
+                if (buildInfo.BuildTarget == BuildTarget.WSAPlayer && EditorUserBuildSettings.wsaGenerateReferenceProjects)
+                {
+                    UwpProjectPostProcess.Execute(buildInfo.OutputDirectory);
+                }
+
                 PlayerSettings.colorSpace = oldColorSpace;
                 PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, oldBuildSymbols);
 
-                EditorUserBuildSettings.wsaSDK = oldWSASDK;
-
-                if (oldWSAUWPBuildType.HasValue)
+                if (EditorUserBuildSettings.wsaSDK == WSASDK.UWP)
                 {
+                    EditorUserBuildSettings.wsaUWPSDK = oldWsaUwpSdk;
                     EditorUserBuildSettings.wsaUWPBuildType = oldWSAUWPBuildType.Value;
                 }
+                EditorUserBuildSettings.wsaSDK = oldWSASDK;
 
                 EditorUserBuildSettings.wsaGenerateReferenceProjects = oldWSAGenerateReferenceProjects;
 
-                EditorUserBuildSettings.SwitchActiveBuildTarget(oldBuildTargetGroup, oldBuildTarget);
+                EditorUserBuildSettings.SwitchActiveBuildTarget(oldBuildTarget);
+            }
+        }
+
+        private static void VerifyWsaUwpSdkIsInstalled(string wsaUwpSdk)
+        {
+            if (string.IsNullOrEmpty(wsaUwpSdk))
+            {
+                // Unity uses a null or empty string to mean "use the latest sdk that's installed", so we don't need to
+                // verify any particular version.
+                return;
+            }
+
+
+            IEnumerable<Version> uwpSdksAvailable;
+            try
+            {
+                // In order to get the same list of SDKs that the Unity build settings "UWP SDK" box has, we call into an
+                // internal Unity function.  If Unity changes how its internals work, we'll need to update this code.
+
+                Type uwpReferencesType = typeof(UnityEditor.Editor).Assembly
+                    .GetType("UnityEditor.Scripting.Compilers.UWPReferences", throwOnError: false);
+
+                MethodInfo uwpReferencesMethod = (uwpReferencesType == null)
+                    ? null
+                    : uwpReferencesType.GetMethod("GetInstalledSDKVersions");
+
+                uwpSdksAvailable = (uwpReferencesMethod == null)
+                    ? null
+                    : (uwpReferencesMethod.Invoke(obj: null, parameters: null) as IEnumerable<Version>);
+            }
+            catch
+            {
+                uwpSdksAvailable = null;
+            }
+
+
+            if (uwpSdksAvailable == null)
+            {
+                Debug.LogWarningFormat("Couldn't verify that UWP SDK \"{0}\" is installed. You better make sure it's installed"
+                        + " and available in your Unity Build settings menu, or you may get unexpected build breaks or runtime"
+                        + " behavior.",
+                    wsaUwpSdk
+                    );
+            }
+            else if (!uwpSdksAvailable.Select(version => version.ToString()).Contains(wsaUwpSdk))
+            {
+                throw new Exception(string.Format("UWP SDK \"{0}\" is not installed. Please install it and try building again. If"
+                        + " you really want to build without that SDK, build directly from Unity's Build settings menu instead.",
+                    wsaUwpSdk
+                    ));
+            }
+            else
+            {
+                // The SDK is verified installed. All is right with the world!
             }
         }
 
         public static void ParseBuildCommandLine(ref BuildInfo buildInfo)
         {
-            string[] arguments = Environment.GetCommandLineArgs();
+            string[] arguments = System.Environment.GetCommandLineArgs();
 
             buildInfo.IsCommandLine = true;
 
@@ -268,6 +364,10 @@ public static void ParseBuildCommandLine(ref BuildInfo buildInfo)
 
                     buildInfo.WSASdk = (WSASDK)Enum.Parse(typeof(WSASDK), wsaSdkArg);
                 }
+                else if (string.Equals(arguments[i], "-wsaUwpSdk", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    buildInfo.WsaUwpSdk = arguments[++i];
+                }
                 else if (string.Equals(arguments[i], "-wsaUWPBuildType", StringComparison.InvariantCultureIgnoreCase))
                 {
 
@@ -295,12 +395,12 @@ public static void ParseBuildCommandLine(ref BuildInfo buildInfo)
 
         public static void PerformBuild_CommandLine()
         {
-            BuildInfo buildInfo = new BuildInfo
+            BuildInfo buildInfo = new BuildInfo()
             {
-                // Use scenes from the editor build settings.
-                Scenes = EditorBuildSettings.scenes.Where(scene => scene.enabled).Select(scene => scene.path)
+                Scenes = EditorBuildSettings.scenes.Where(scene => scene.enabled).Select(scene => scene.path), // Use scenes from the editor build settings.
             };
 
+            RaiseOverrideBuildDefaults(ref buildInfo);
             ParseBuildCommandLine(ref buildInfo);
 
             PerformBuild(buildInfo);
@@ -405,7 +505,7 @@ private static IEnumerable<CopyDirectoryInfo> ReadCopyList(XmlTextReader reader)
                                 }
                                 else if (string.Equals(reader.Name, "Recursive", StringComparison.InvariantCultureIgnoreCase))
                                 {
-                                    recursive = Convert.ToBoolean(reader.Value);
+                                    recursive = System.Convert.ToBoolean(reader.Value);
                                 }
                                 else if (string.Equals(reader.Name, "Filter", StringComparison.InvariantCultureIgnoreCase))
                                 {
@@ -511,7 +611,7 @@ private static void OnPostProcessBuild(BuildInfo buildInfo, string buildError)
             }
         }
 
-        private static string GetProjectPath()
+        public static string GetProjectPath()
         {
             return Path.GetDirectoryName(Path.GetFullPath(Application.dataPath));
         }