public void RunBuild(BuildReport buildReport) { buildReport.BuildDefinitionName = Name; buildReport.StartedAt = DateTime.UtcNow; foreach (var step in Steps) { var stepReport = new StepReport(); try { step.Execute(stepReport); if(string.IsNullOrWhiteSpace(step.Summary) == false) stepReport.Summary = this.CreateReport(step.Summary, stepReport.Report); } catch (Exception exception) { stepReport.Error = exception; } stepReport.FinishedAt = DateTime.UtcNow; buildReport.AddStepReport(stepReport); } buildReport.FinishedAt = DateTime.UtcNow; }
public void Save(BuildReport buildReport) { using(var session = store.OpenSession()) { session.Store(buildReport); session.SaveChanges(); } }
public void StartBuildSequence() { var buildReport = new BuildReport(orderedAt, TriggerName); try { buildDefinition.RunBuild(buildReport); } catch (Exception exception) { buildReport.UnhandledException = exception; } buildReport.FinishedAt = DateTime.UtcNow; this.OnBuildFinished(new BuildFinishedEventArgs(buildReport)); }
public void OnPreprocessBuild(BuildReport report)
public void OnPreprocessBuild(BuildReport report) { GetAllValidHDRPAssets(); }
public void OnPostprocessBuild(BuildReport report) { Profiler.enabled = false; }
//BUILD /// <summary>Builds an application using the passed in parameters.</summary> /// <param name="targetPlatform">BuildTarget.StandaloneWindows64, StandaloneLinux64, StandaloneOSX</param> /// <param name="buildType">NetworkType.Server - Client - HostAndPlay</param> /// <param name="headless">Build in headless mode? (console application)</param> public static void Build(BuildTarget targetPlatform, NetworkType buildType, bool headless = false) { ChangeBuildMenu.SetBuildType(buildType, headless); //ACTIVATE CHANGE BUILD MENU FileExtension buildFileExtension = FileExtension.exe; switch (targetPlatform) { //STANDALONE case BuildTarget.StandaloneWindows64: buildFileExtension = FileExtension.exe; break; case BuildTarget.StandaloneWindows: buildFileExtension = FileExtension.exe; break; case BuildTarget.StandaloneLinux64: buildFileExtension = FileExtension.x86_64; break; case BuildTarget.StandaloneOSX: buildFileExtension = FileExtension.app; break; /*TODO*/ //MOBILE //case BuildTarget.iOS: break; //case BuildTarget.Android: break; //CONSOLE //case BuildTarget.PS4: break; //case BuildTarget.XboxOne: break; //case BuildTarget.Switch: break; //WEB //case BuildTarget.WebGL: buildFileExtension = FileExtension.exe; break; /* //OTHER * case BuildTarget.WSAPlayer: break; * case BuildTarget.tvOS: break; * case BuildTarget.Lumin: break; * case BuildTarget.Stadia: break; * case BuildTarget.NoTarget: break; */ } //SETUP BUILD OPTIONS BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions(); buildPlayerOptions.scenes = GetScenesFromBuild(); buildPlayerOptions.locationPathName = "_BUILD" + "/" + buildType.ToString().ToUpper() + "/" + targetPlatform + "/" + buildType.ToString().ToLower() + "." + buildFileExtension; buildPlayerOptions.target = targetPlatform; buildPlayerOptions.options = (headless) ? (BuildOptions.EnableHeadlessMode) : (BuildOptions.None); #region BUILD REPORT - header #if !SKIP_BUILD_REPORT buildLog.AppendLine("<b>[BUILD] " + targetPlatform + " - " + ((headless) ? "(headless) " : "") + buildType + "</b>" + "\n" + buildPlayerOptions.locationPathName); foreach (string scenePath in buildPlayerOptions.scenes) { buildLog.AppendLine(scenePath); } #endif #endregion //BUILD REPORTING BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = report.summary; //SUCCESS if (summary.result == BuildResult.Succeeded) { #region BUILD REPORT - success #if !SKIP_BUILD_REPORT float sizeInMegabytes = (summary.totalSize / 1024f / 1024f); sizeInMegabytes -= sizeInMegabytes % 0.0001f; float durationInSeconds = (float)((summary.buildEndedAt - summary.buildStartedAt).TotalSeconds); durationInSeconds -= durationInSeconds % 0.01f; buildLog.AppendLine("<color=green><b>" + targetPlatform + " " + buildType + " build succeeded..." + "</b></color>" + ((summary.totalSize > 0) ? ("\nBuild size: " + sizeInMegabytes + " MB") : ("")) + "\nBuild duration: " + durationInSeconds + "s"); #endif #endregion } //FAILURE if (summary.result == BuildResult.Failed) { #region BUILD REPORT - failure #if !SKIP_BUILD_REPORT buildLog.AppendLine("<color=red><b>" + targetPlatform + " " + buildType + " build failed...</b></color>" + "\n" + report.ToString()); #endif #endregion } }
public void OnPreprocessBuild(BuildReport report) { BuildTargetChanged(); }
public void OnPostprocessBuild(BuildReport report) { this.OnPostprocessBuild(report.summary.platform, report.summary.outputPath); }
public static void RunManagedProgram(string exe, string args, CompilerOutputParserBase parser, BuildReport report) { RunManagedProgram(exe, args, Application.dataPath + "/..", parser, report); }
private void OnPostBuildPlayerScriptDLLsImpl(BuildReport report) { var aotSettingsForTarget = BurstPlatformAotSettings.GetOrCreateSettings(report.summary.platform); // Early exit if burst is not activated or the platform is not supported if (aotSettingsForTarget.DisableBurstCompilation || !IsSupportedPlatform(report.summary.platform)) { return; } var commonOptions = new List <string>(); var stagingFolder = Path.GetFullPath(TempStagingManaged); var playerAssemblies = GetPlayerAssemblies(report); // grab the location of the root of the player folder - for handling nda platforms that require keys var keyFolder = BuildPipeline.GetPlaybackEngineDirectory(report.summary.platform, BuildOptions.None); commonOptions.Add(GetOption(OptionAotKeyFolder, keyFolder)); // Extract the TargetPlatform and Cpu from the current build settings TargetCpu targetCpu; var targetPlatform = GetTargetPlatformAndDefaultCpu(report.summary.platform, out targetCpu); commonOptions.Add(GetOption(OptionPlatform, targetPlatform)); // -------------------------------------------------------------------------------------------------------- // 1) Calculate AssemblyFolders // These are the folders to look for assembly resolution // -------------------------------------------------------------------------------------------------------- var assemblyFolders = new List <string> { stagingFolder }; if (report.summary.platform == BuildTarget.WSAPlayer) { // On UWP, not all assemblies are copied to StagingArea, so we want to // find all directories that we can reference assemblies from // If we don't do this, we will crash with AssemblyResolutionException // when following type references. foreach (var assembly in playerAssemblies) { foreach (var assemblyRef in assembly.compiledAssemblyReferences) { // Exclude folders with assemblies already compiled in the `folder` var assemblyName = Path.GetFileName(assemblyRef); if (assemblyName != null && File.Exists(Path.Combine(stagingFolder, assemblyName))) { continue; } var directory = Path.GetDirectoryName(assemblyRef); if (directory != null) { var fullPath = Path.GetFullPath(directory); if (IsMonoReferenceAssemblyDirectory(fullPath) || IsDotNetStandardAssemblyDirectory(fullPath)) { // Don't pass reference assemblies to burst because they contain methods without implementation // If burst accidentally resolves them, it will emit calls to burst_abort. fullPath = Path.Combine(EditorApplication.applicationContentsPath, "MonoBleedingEdge/lib/mono/unityaot"); fullPath = Path.GetFullPath(fullPath); // GetFullPath will normalize path separators to OS native format if (!assemblyFolders.Contains(fullPath)) { assemblyFolders.Add(fullPath); } fullPath = Path.Combine(fullPath, "Facades"); if (!assemblyFolders.Contains(fullPath)) { assemblyFolders.Add(fullPath); } } else if (!assemblyFolders.Contains(fullPath)) { assemblyFolders.Add(fullPath); } } } } } // Copy assembly used during staging to have a trace if (BurstLoader.IsDebugging) { try { var copyAssemblyFolder = Path.Combine(Environment.CurrentDirectory, "Logs", "StagingAssemblies"); try { if (Directory.Exists(copyAssemblyFolder)) { Directory.Delete(copyAssemblyFolder); } } catch { } if (!Directory.Exists(copyAssemblyFolder)) { Directory.CreateDirectory(copyAssemblyFolder); } foreach (var file in Directory.EnumerateFiles(stagingFolder)) { File.Copy(file, Path.Combine(copyAssemblyFolder, Path.GetFileName(file))); } } catch { } } // -------------------------------------------------------------------------------------------------------- // 2) Calculate root assemblies // These are the assemblies that the compiler will look for methods to compile // This list doesn't typically include .NET runtime assemblies but only assemblies compiled as part // of the current Unity project // -------------------------------------------------------------------------------------------------------- var rootAssemblies = new List <string>(); foreach (var playerAssembly in playerAssemblies) { // the file at path `playerAssembly.outputPath` is actually not on the disk // while it is in the staging folder because OnPostBuildPlayerScriptDLLs is being called once the files are already // transferred to the staging folder, so we are going to work from it but we are reusing the file names that we got earlier var playerAssemblyPathToStaging = Path.Combine(stagingFolder, Path.GetFileName(playerAssembly.outputPath)); if (!File.Exists(playerAssemblyPathToStaging)) { Debug.LogWarning($"Unable to find player assembly: {playerAssemblyPathToStaging}"); } else { rootAssemblies.Add(playerAssemblyPathToStaging); } } commonOptions.AddRange(assemblyFolders.Select(folder => GetOption(OptionAotAssemblyFolder, folder))); // -------------------------------------------------------------------------------------------------------- // 3) Calculate the different target CPU combinations for the specified OS // // Typically, on some platforms like iOS we can be asked to compile a ARM32 and ARM64 CPU version // -------------------------------------------------------------------------------------------------------- var combinations = CollectCombinations(targetPlatform, targetCpu, report); // -------------------------------------------------------------------------------------------------------- // 4) Compile each combination // // Here bcl.exe is called for each target CPU combination // -------------------------------------------------------------------------------------------------------- string debugLogFile = null; if (BurstLoader.IsDebugging) { // Reset log files try { var logDir = Path.Combine(Environment.CurrentDirectory, "Logs"); debugLogFile = Path.Combine(logDir, "burst_bcl_editor.log"); if (!Directory.Exists(logDir)) { Directory.CreateDirectory(logDir); } File.WriteAllText(debugLogFile, string.Empty); } catch { debugLogFile = null; } } // Log the targets generated by BurstReflection.FindExecuteMethods foreach (var combination in combinations) { // Gets the output folder var stagingOutputFolder = Path.GetFullPath(Path.Combine(TempStaging, combination.OutputPath)); var outputFilePrefix = Path.Combine(stagingOutputFolder, combination.LibraryName); var options = new List <string>(commonOptions) { GetOption(OptionAotOutputPath, outputFilePrefix), GetOption(OptionTarget, combination.TargetCpu) }; if (targetPlatform == TargetPlatform.iOS) { options.Add(GetOption(OptionStaticLinkage)); } // finally add method group options options.AddRange(rootAssemblies.Select(path => GetOption(OptionRootAssembly, path))); // Log the targets generated by BurstReflection.FindExecuteMethods if (BurstLoader.IsDebugging && debugLogFile != null) { try { var writer = new StringWriter(); writer.WriteLine("-----------------------------------------------------------"); writer.WriteLine("Combination: " + combination); writer.WriteLine("-----------------------------------------------------------"); foreach (var option in options) { writer.WriteLine(option); } writer.WriteLine("Assemblies in AssemblyFolders:"); foreach (var assemblyFolder in assemblyFolders) { writer.WriteLine("|- Folder: " + assemblyFolder); foreach (var assemblyOrDll in Directory.EnumerateFiles(assemblyFolder, "*.dll")) { var fileInfo = new FileInfo(assemblyOrDll); writer.WriteLine(" |- " + assemblyOrDll + " Size: " + fileInfo.Length + " Date: " + fileInfo.LastWriteTime); } } File.AppendAllText(debugLogFile, writer.ToString()); } catch { // ignored } } // Write current options to the response file var responseFile = Path.GetTempFileName(); File.WriteAllLines(responseFile, options); if (BurstLoader.IsDebugging) { Debug.Log($"bcl @{responseFile}\n\nResponse File:\n" + string.Join("\n", options)); } try { string generatedDebugInformationInOutput = ""; if ((report.summary.options & BuildOptions.Development) != 0) { // Workaround for clang >6 development issue (due to latest being 7.0.0) - IOS & newer PS4 SDKS are affected because its a source level IR compatability issue if ((targetPlatform != TargetPlatform.iOS) && (targetPlatform != TargetPlatform.PS4)) { generatedDebugInformationInOutput = GetOption(OptionDebug); } } BclRunner.RunManagedProgram(Path.Combine(BurstLoader.RuntimePath, BurstAotCompilerExecutable), $"{generatedDebugInformationInOutput} @{responseFile}", new BclOutputErrorParser(), report); } catch (BuildFailedException) { throw; } catch (Exception e) { throw new BuildFailedException(e); } } }
/// <summary> /// Collect CPU combinations for the specified TargetPlatform and TargetCPU /// </summary> /// <param name="targetPlatform">The target platform (e.g Windows)</param> /// <param name="targetCpu">The target CPU (e.g X64_SSE4)</param> /// <param name="report">Error reporting</param> /// <returns>The list of CPU combinations</returns> private static List <BurstOutputCombination> CollectCombinations(TargetPlatform targetPlatform, TargetCpu targetCpu, BuildReport report) { var combinations = new List <BurstOutputCombination>(); if (targetPlatform == TargetPlatform.macOS) { // NOTE: OSX has a special folder for the plugin // Declared in GetStagingAreaPluginsFolder // PlatformDependent\OSXPlayer\Extensions\Managed\OSXDesktopStandalonePostProcessor.cs #if UNITY_2019_3_OR_NEWER combinations.Add(new BurstOutputCombination(Path.Combine(Path.GetFileName(report.summary.outputPath), "Contents", "Plugins"), targetCpu)); #else combinations.Add(new BurstOutputCombination("UnityPlayer.app/Contents/Plugins", targetCpu)); #endif } else if (targetPlatform == TargetPlatform.iOS) { if (Application.platform != RuntimePlatform.OSXEditor) { Debug.LogWarning("Burst Cross Compilation to iOS for standalone player, is only supported on OSX Editor at this time, burst is disabled for this build."); } else { var targetArchitecture = (IOSArchitecture)UnityEditor.PlayerSettings.GetArchitecture(report.summary.platformGroup); if (targetArchitecture == IOSArchitecture.ARMv7 || targetArchitecture == IOSArchitecture.Universal) { // PlatformDependent\iPhonePlayer\Extensions\Common\BuildPostProcessor.cs combinations.Add(new BurstOutputCombination("StaticLibraries", TargetCpu.ARMV7A_NEON32, DefaultLibraryName + "32")); } if (targetArchitecture == IOSArchitecture.ARM64 || targetArchitecture == IOSArchitecture.Universal) { // PlatformDependent\iPhonePlayer\Extensions\Common\BuildPostProcessor.cs combinations.Add(new BurstOutputCombination("StaticLibraries", TargetCpu.ARMV8A_AARCH64, DefaultLibraryName + "64")); } } } else if (targetPlatform == TargetPlatform.Android) { //TODO: would be better to query AndroidNdkRoot (but thats not exposed from unity) string ndkRoot = null; // 2019.1 now has an embedded ndk #if UNITY_2019_1_OR_NEWER if (EditorPrefs.HasKey("NdkUseEmbedded")) { if (EditorPrefs.GetBool("NdkUseEmbedded")) { ndkRoot = Path.Combine(BuildPipeline.GetPlaybackEngineDirectory(BuildTarget.Android, BuildOptions.None), "NDK"); } else { ndkRoot = EditorPrefs.GetString("AndroidNdkRootR16b"); } } #endif // If we still don't have a valid root, try the old key if (string.IsNullOrEmpty(ndkRoot)) { ndkRoot = EditorPrefs.GetString("AndroidNdkRoot"); } // Verify the directory at least exists, if not we fall back to ANDROID_NDK_ROOT current setting if (!string.IsNullOrEmpty(ndkRoot) && !Directory.Exists(ndkRoot)) { ndkRoot = null; } // Always set the ANDROID_NDK_ROOT (if we got a valid result from above), so BCL knows where to find the Android toolchain and its the one the user expects if (!string.IsNullOrEmpty(ndkRoot)) { Environment.SetEnvironmentVariable("ANDROID_NDK_ROOT", ndkRoot); } var androidTargetArch = UnityEditor.PlayerSettings.Android.targetArchitectures; if ((androidTargetArch & AndroidArchitecture.ARMv7) != 0) { combinations.Add(new BurstOutputCombination("libs/armeabi-v7a", TargetCpu.ARMV7A_NEON32)); } if ((androidTargetArch & AndroidArchitecture.ARM64) != 0) { combinations.Add(new BurstOutputCombination("libs/arm64-v8a", TargetCpu.ARMV8A_AARCH64)); } #if !UNITY_2019_2_OR_NEWER if ((androidTargetArch & AndroidArchitecture.X86) != 0) { combinations.Add(new BurstOutputCombination("libs/x86", TargetCpu.X86_SSE2)); } #endif } else if (targetPlatform == TargetPlatform.UWP) { // TODO: Make it configurable for x86 (sse2, sse4) combinations.Add(new BurstOutputCombination("Plugins/x64", TargetCpu.X64_SSE4)); combinations.Add(new BurstOutputCombination("Plugins/x86", TargetCpu.X86_SSE2)); combinations.Add(new BurstOutputCombination("Plugins/ARM", TargetCpu.THUMB2_NEON32)); combinations.Add(new BurstOutputCombination("Plugins/ARM64", TargetCpu.ARMV8A_AARCH64)); } else if (targetPlatform == TargetPlatform.Lumin) { // Set the LUMINSDK_UNITY so bcl.exe will be able to find the SDK if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("LUMINSDK_UNITY"))) { var sdkRoot = EditorPrefs.GetString("LuminSDKRoot"); if (!string.IsNullOrEmpty(sdkRoot)) { Environment.SetEnvironmentVariable("LUMINSDK_UNITY", sdkRoot); } } combinations.Add(new BurstOutputCombination("Data/Plugins/", targetCpu)); } else { combinations.Add(new BurstOutputCombination("Data/Plugins/", targetCpu)); } return(combinations); }
public void OnPreprocessBuild(BuildReport report) { EditorPrefs.DeleteKey("Models checked"); CheckModels(); }
public static void BuildUwpPlayer(BuildInfo buildInfo) { BuildTargetGroup buildTargetGroup = GetGroup(buildInfo.BuildTarget); string oldBuildSymbols = PlayerSettings.GetScriptingDefineSymbolsForGroup(buildTargetGroup); if (!string.IsNullOrEmpty(oldBuildSymbols)) { if (buildInfo.HasConfigurationSymbol()) { buildInfo.AppendSymbols(BuildInfo.RemoveConfigurationSymbols(oldBuildSymbols)); } else { buildInfo.AppendSymbols(oldBuildSymbols.Split(';')); } } if ((buildInfo.BuildOptions & BuildOptions.Development) == BuildOptions.Development) { if (!buildInfo.HasConfigurationSymbol()) { buildInfo.AppendSymbols(BuildSymbolDebug); } } if (buildInfo.HasAnySymbols(BuildSymbolDebug)) { buildInfo.BuildOptions |= BuildOptions.Development | BuildOptions.AllowDebugging; } if (buildInfo.HasAnySymbols(BuildSymbolRelease)) { // Unity automatically adds the DEBUG symbol if the BuildOptions.Development flag is // specified. In order to have debug symbols and the RELEASE symbols 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); WSAUWPBuildType?oldWSAUWPBuildType = EditorUserBuildSettings.wsaUWPBuildType; if (buildInfo.WSAUWPBuildType.HasValue) { EditorUserBuildSettings.wsaUWPBuildType = buildInfo.WSAUWPBuildType.Value; } var oldWSAGenerateReferenceProjects = EditorUserBuildSettings.wsaGenerateReferenceProjects; if (buildInfo.WSAGenerateReferenceProjects.HasValue) { EditorUserBuildSettings.wsaGenerateReferenceProjects = buildInfo.WSAGenerateReferenceProjects.Value; } var oldColorSpace = PlayerSettings.colorSpace; if (buildInfo.ColorSpace.HasValue) { PlayerSettings.colorSpace = buildInfo.ColorSpace.Value; } if (buildInfo.BuildSymbols != null) { PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, buildInfo.BuildSymbols); } // 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. if (buildInfo.BuildTarget == BuildTarget.WSAPlayer) { Directory.CreateDirectory(buildInfo.OutputDirectory); } OnPreProcessBuild(buildInfo); EditorUtility.DisplayProgressBar("Build Pipeline", "Gathering Build Data...", 0.25f); BuildReport buildReport = default(BuildReport); try { buildReport = BuildPipeline.BuildPlayer( buildInfo.Scenes.ToArray(), buildInfo.OutputDirectory, buildInfo.BuildTarget, buildInfo.BuildOptions); if (buildReport.summary.result != BuildResult.Succeeded) { throw new Exception($"Build Result: {buildReport.summary.result.ToString()}"); } } finally { OnPostProcessBuild(buildInfo, buildReport); if (buildInfo.BuildTarget == BuildTarget.WSAPlayer && EditorUserBuildSettings.wsaGenerateReferenceProjects) { UwpProjectPostProcess.Execute(buildInfo.OutputDirectory); } PlayerSettings.colorSpace = oldColorSpace; PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, oldBuildSymbols); EditorUserBuildSettings.wsaUWPBuildType = oldWSAUWPBuildType.Value; EditorUserBuildSettings.wsaGenerateReferenceProjects = oldWSAGenerateReferenceProjects; EditorUserBuildSettings.SwitchActiveBuildTarget(oldBuildTargetGroup, oldBuildTarget); } }
private static async void OnPostProcessBuild(BuildInfo buildInfo, BuildReport buildReport) { if (buildReport.summary.result == BuildResult.Succeeded)
public void Execute(BuildTargetGroup buildTargetGroup, BuildTarget buildTarget) { Config(buildTargetGroup, buildTarget); if (configButDontBuild) { return; } if (bundleBuilder != null) { bundleBuilder.Execute(buildTarget); } BuildPlayerOptions options = new BuildPlayerOptions(); string[] scenePaths = new string[scenes.Length]; for (int i = 0; i < scenePaths.Length; i++) { scenePaths[i] = AssetDatabase.GetAssetPath(scenes[i]); } options.scenes = scenePaths; if (string.IsNullOrEmpty(locationPathName)) { locationPathName = EditorUtility.SaveFolderPanel("Choose Output Folder", "", ""); if (string.IsNullOrEmpty(locationPathName)) { return; } } string path = locationPathName .Replace(Wildcard_BuildTarget, buildTarget.ToString()) .Replace(Wildcard_BuildNumber, buildNumber.ToString()) .Replace(Wildcard_BundleIdentifier, bundleIdentifier) .Replace(Wildcard_BundleVersion, bundleVersion) .Replace(Wildcard_CompanyName, companyName) .Replace(Wildcard_Date, DateTime.Now.ToString("yyyyMMdd")) .Replace(Wildcard_ProductName, productName) .Replace(Wildcard_Time, DateTime.Now.ToString("HHmmss")); switch (buildTarget) { case BuildTarget.StandaloneWindows: options.locationPathName = string.Format("{0}/{1}.exe", path, PlayerSettings.productName); break; case BuildTarget.StandaloneWindows64: options.locationPathName = string.Format("{0}/{1}.exe", path, PlayerSettings.productName); break; case BuildTarget.Android: options.locationPathName = string.Format("{0}.apk", path); break; default: options.locationPathName = path; break; } options.target = buildTarget; options.options = BuildOptions.ShowBuiltPlayer; #if UNITY_2018_1_OR_NEWER BuildReport report = BuildPipeline.BuildPlayer(options); var summary = report.summary; switch (summary.result) { case BuildResult.Failed: Debug.LogError("Build Failed"); break; case BuildResult.Succeeded: Debug.Log("Build Succeeded"); copyList.CopyFiles(path); break; } #else Debug.Log(BuildPipeline.BuildPlayer(options)); copyList.CopyFiles(path); #endif }
void IPreprocessBuildWithReport.OnPreprocessBuild(BuildReport report) { ConfigureImportSettings(); }
private static void RunProgram( Program p, string exe, string args, string workingDirectory, CompilerOutputParserBase parser, BuildReport report) { Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); using (p) { p.GetProcessStartInfo().WorkingDirectory = workingDirectory; p.Start(); p.WaitForExit(); stopwatch.Stop(); Console.WriteLine("{0} exited after {1} ms.", (object)exe, (object)stopwatch.ElapsedMilliseconds); IEnumerable <UnityEditor.Scripting.Compilers.CompilerMessage> compilerMessages = null; string[] errorOutput = p.GetErrorOutput(); string[] standardOutput = p.GetStandardOutput(); if (parser != null) { compilerMessages = parser.Parse(errorOutput, standardOutput, true, "n/a (burst)"); } var errorMessageBuilder = new StringBuilder(); if (p.ExitCode != 0) { if (compilerMessages != null) { foreach (UnityEditor.Scripting.Compilers.CompilerMessage compilerMessage in compilerMessages) { Debug.LogPlayerBuildError(compilerMessage.message, compilerMessage.file, compilerMessage.line, compilerMessage.column); } } // We try to output the version in the heading error if we can var matchVersion = MatchVersion.Match(exe); errorMessageBuilder.Append(matchVersion.Success ? "Burst compiler (" + matchVersion.Groups[1].Value + ") failed running" : "Burst compiler failed running"); errorMessageBuilder.AppendLine(); errorMessageBuilder.AppendLine(); // Don't output the path if we are not burst-debugging or the exe exist if (BurstLoader.IsDebugging || !File.Exists(exe)) { errorMessageBuilder.Append(exe).Append(" ").Append(args); errorMessageBuilder.AppendLine(); errorMessageBuilder.AppendLine(); } errorMessageBuilder.AppendLine("stdout:"); foreach (string str in standardOutput) { errorMessageBuilder.AppendLine(str); } errorMessageBuilder.AppendLine("stderr:"); foreach (string str in errorOutput) { errorMessageBuilder.AppendLine(str); } throw new BuildFailedException(errorMessageBuilder.ToString()); } Console.WriteLine(p.GetAllOutput()); } }
public void OnPreprocessBuild(BuildReport report) { AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate); byte[] bytes = AssetManifest.Export(); File.WriteAllBytes($"{report.summary.outputPath}/AssetManifest", bytes); }
public void OnPreprocessBuild(BuildReport report) { string manifestPath = Path.Combine( Application.dataPath, "Plugins/Android/AndroidManifest.xml"); XDocument manifest = null; try { manifest = XDocument.Load(manifestPath); } #pragma warning disable 0168 catch (IOException e) #pragma warning restore 0168 { Debug.LogError("AndroidManifest.xml is missing. Try re-importing the plugin."); } XElement elemManifest = manifest.Element("manifest"); if (elemManifest == null) { Debug.LogError("AndroidManifest.xml is not valid. Try re-importing the plugin."); } XElement elemApplication = elemManifest.Element("application"); if (elemApplication == null) { Debug.LogError("AndroidManifest.xml is not valid. Try re-importing the plugin."); } IEnumerable <XElement> metas = elemApplication.Descendants() .Where(elem => elem.Name.LocalName.Equals("meta-data")); if (FrameworkGlobalConfig.Instance != null && FrameworkGlobalConfig.Instance.AdsConfig != null) { XElement elemAdMobEnabled = GetMetaElement(metas, META_APPLICATION_ID); if (!string.IsNullOrEmpty(FrameworkGlobalConfig.Instance.AdsConfig.Platform.AppId)) { string appId = FrameworkGlobalConfig.Instance.AdsConfig.Platform.AppId; if (appId.Length == 0) { Debug.LogError( "Android AdMob app ID is empty. Please enter a valid app ID to run ads properly."); } if (elemAdMobEnabled == null) { elemApplication.Add(CreateMetaElement(META_APPLICATION_ID, appId)); } else { elemAdMobEnabled.SetAttributeValue(ns + "value", appId); } } else { if (elemAdMobEnabled != null) { elemAdMobEnabled.Remove(); } } #if USE_ADMOB XElement elemApplovinEnabled = GetMetaElement(metas, META_APPLOVIN_KEY); if (!string.IsNullOrEmpty(FrameworkGlobalConfig.Instance.AdsConfig.Platform.ApplovingSDKKey)) { string applovinSDKKey = FrameworkGlobalConfig.Instance.AdsConfig.Platform.ApplovingSDKKey; if (applovinSDKKey.Length == 0) { Debug.LogError( "Android Applovin SDK Key is empty. Please enter a valid SDK Key to run ads properly."); } if (elemApplovinEnabled == null) { elemApplication.Add(CreateMetaElement(META_APPLOVIN_KEY, applovinSDKKey)); } else { elemApplovinEnabled.SetAttributeValue(ns + "value", applovinSDKKey); } } else { if (elemApplovinEnabled != null) { elemApplovinEnabled.Remove(); } } #endif } elemManifest.Save(manifestPath); }
public void OnPostprocessBuild(BuildReport report) { OnPostprocessBuildiOS(report); }
static void BuildChannelApk(BuildConfig buildConfig) { // 公司名 PlayerSettings.companyName = buildConfig.companyName; // 产品名 PlayerSettings.productName = buildConfig.productName; // 包名 PlayerSettings.applicationIdentifier = buildConfig.bundleIdentifier; PlayerSettings.bundleVersion = buildConfig.bundleVersion; PlayerSettings.Android.bundleVersionCode = int.Parse(buildConfig.bundleVersionCode); PlayerSettings.strippingLevel = StrippingLevel.StripByteCode; PlayerSettings.SetApiCompatibilityLevel(BuildTargetGroup.Android, ApiCompatibilityLevel.NET_2_0_Subset); // keystore 路径, G:\keystore\one.keystore PlayerSettings.Android.keystoreName = buildConfig.keystorePath; // one.keystore 密码 PlayerSettings.Android.keystorePass = buildConfig.keystorePass; // one.keystore 别名 PlayerSettings.Android.keyaliasName = buildConfig.keyaliasName; // 别名密码 PlayerSettings.Android.keyaliasPass = buildConfig.keyaliasPass; BuildTargetGroup buildTargetGroup = BuildTargetGroup.Android; // 设置宏定义 PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, "ASYNC_MODE"); // 宏定义 List <string> levels = new List <string>(); foreach (EditorBuildSettingsScene scene in EditorBuildSettings.scenes) { if (!scene.enabled) { continue; } // 获取有效的 Scene levels.Add(scene.path); } // 切换到 Android 平台 EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.Android, BuildTarget.Android); // 打包出 APK 名 string apkName = string.Format("APK/{0}.apk", buildConfig.apkName); // 执行打包 BuildReport report = BuildPipeline.BuildPlayer(levels.ToArray(), apkName, BuildTarget.Android, BuildOptions.None); BuildSummary summary = report.summary; if (summary.result == BuildResult.Succeeded) { Debug.Log("Build succeeded" + apkName); } if (summary.result == BuildResult.Failed) { Debug.Log("构建失败"); } AssetDatabase.Refresh(); }
public void OnPreprocessBuild(BuildReport report) { Preprocess(report.summary.platform); }
public abstract void Execute(IUniBuilderConfiguration configuration, BuildReport buildReport = null);
public void OnPostprocessBuild(BuildReport report) { // Always remember to cleanup preloaded assets after build to make sure we don't // dirty later builds with assets that may not be needed or are out of date. CleanOldSettings(); }
private bool IsCurrentBuildTargetVaild(BuildReport report) { return(report.summary.platformGroup == BuildTargetGroup.WSA || (report.summary.platformGroup == BuildTargetGroup.Standalone && s_ValidBuildTargets.Contains(report.summary.platform))); }
public static void Build() { if (UnityEditor.BuildPipeline.isBuildingPlayer) { return; } settings = BuildPipelineWebGLSettings.Instance; string path; if (string.IsNullOrEmpty(settings.buildPath)) { path = OpenBuildSavePanel(settings.buildPath); } else { path = settings.buildPath; } var scenes = new List <EditorBuildSettingsScene>(EditorBuildSettings.scenes); for (int i = 0; i < scenes.Count; i++) { if (!scenes[i].enabled) { scenes.RemoveAt(i--); } } if (!(scenes.Count > 0)) { return; } string buildPath; if (settings.createNewFolder) { buildPath = Path.Combine(path, settings.GetFolderName()); } else { buildPath = path; } PlayerSettings.WebGL.linkerTarget = settings.linkerTarget; PlayerSettings.WebGL.memorySize = settings.memorySize; PlayerSettings.WebGL.compressionFormat = settings.compressionFormat; PlayerSettings.WebGL.wasmStreaming = settings.wasmStreaming; BuildReport report = UnityEditor.BuildPipeline.BuildPlayer(scenes.ToArray(), buildPath, BuildTarget.WebGL, settings.buildOptions); BuildSummary summary = report.summary; if (summary.result == BuildResult.Succeeded) { Debug.Log($"Build succeeded at '{buildPath}' using {summary.totalTime.TotalSeconds.ToString("N2")} seconds with size of {summary.totalSize} bytes."); #if UNITY_EDITOR_OSX Application.OpenURL("file:/" + buildPath); #else Application.OpenURL(buildPath); #endif } if (summary.result == BuildResult.Failed) { Debug.LogError($"Build failed..."); } }
/// <summary>OnPreprocessBuild override to provide XR Plugin specific build actions.</summary> /// <param name="report">The build report.</param> public override void OnPreprocessBuild(BuildReport report) { if (IsCurrentBuildTargetVaild(report) && HasLoaderEnabledForTarget(report.summary.platformGroup)) { base.OnPreprocessBuild(report); BootConfig bootConfig = new BootConfig(report); bootConfig.ReadBootConfg(); bootConfig.SetValueForKey(k_VrEnabled, "1", true); bootConfig.SetValueForKey(k_WmrLibrary, k_WmrLibraryName, true); if (report.summary.platformGroup == BuildTargetGroup.WSA) { bootConfig.SetValueForKey(k_EarlyBootHolographic, "1", true); bool usePrimaryWindow = true; WindowsMRBuildSettings buildSettings = BuildSettingsForBuildTargetGroup(report.summary.platformGroup); if (buildSettings != null) { usePrimaryWindow = buildSettings.UsePrimaryWindowForDisplay; } bootConfig.SetValueForKey(k_ForcePrimaryWindowHolographic, usePrimaryWindow ? "1" : "0", true); } bootConfig.WriteBootConfig(); } var allPlugins = PluginImporter.GetAllImporters(); foreach (var plugin in allPlugins) { if (plugin.isNativePlugin) { foreach (var pluginName in remotingPluginNames) { if (plugin.assetPath.Contains(pluginName)) { plugin.SetIncludeInBuildDelegate((path) => { return(ShouldIncludeRemotingPluginsInBuild(path, report.summary.platformGroup)); }); break; } } foreach (var pluginName in runtimePluginNames) { if (plugin.assetPath.Contains(pluginName)) { plugin.SetIncludeInBuildDelegate((path) => { return(ShouldIncludeRuntimePluginsInBuild(path, report.summary.platformGroup)); }); break; } } if (plugin.assetPath.Contains(spatializerPluginName)) { plugin.SetIncludeInBuildDelegate(ShouldIncludeSpatializerPluginsInBuild); } } } }
public void OnProcessScene(SceneManagement.Scene scene, BuildReport report)
public BootConfig(BuildReport report) { buildReport = report; }
/// <summary> /// Starts the build process /// </summary> /// <param name="buildInfo"></param> /// <returns>The <see cref="BuildReport"/> from Unity's <see cref="BuildPipeline"/></returns> public static BuildReport BuildUnityPlayer(IBuildInfo buildInfo) { EditorUtility.DisplayProgressBar("Build Pipeline", "Gathering Build Data...", 0.25f); // Call the pre-build action, if any buildInfo.PreBuildAction?.Invoke(buildInfo); var buildTargetGroup = buildInfo.BuildTarget.GetGroup(); var playerBuildSymbols = PlayerSettings.GetScriptingDefineSymbolsForGroup(buildTargetGroup); if (!string.IsNullOrEmpty(playerBuildSymbols)) { if (buildInfo.HasConfigurationSymbol()) { buildInfo.AppendWithoutConfigurationSymbols(playerBuildSymbols); } else { buildInfo.AppendSymbols(playerBuildSymbols.Split(';')); } } if (!string.IsNullOrEmpty(buildInfo.BuildSymbols)) { PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, buildInfo.BuildSymbols); } if ((buildInfo.BuildOptions & BuildOptions.Development) == BuildOptions.Development && !buildInfo.HasConfigurationSymbol()) { buildInfo.AppendSymbols(BuildSymbolDebug); } if (buildInfo.HasAnySymbols(BuildSymbolDebug)) { buildInfo.BuildOptions |= BuildOptions.Development | BuildOptions.AllowDebugging; } if (buildInfo.HasAnySymbols(BuildSymbolRelease)) { // Unity automatically adds the DEBUG symbol if the BuildOptions.Development flag is // specified. In order to have debug symbols and the RELEASE symbols 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"); } var oldColorSpace = PlayerSettings.colorSpace; if (buildInfo.ColorSpace.HasValue) { PlayerSettings.colorSpace = buildInfo.ColorSpace.Value; } var oldBuildTarget = EditorUserBuildSettings.activeBuildTarget; var oldBuildTargetGroup = oldBuildTarget.GetGroup(); if (EditorUserBuildSettings.activeBuildTarget != buildInfo.BuildTarget) { EditorUserBuildSettings.SwitchActiveBuildTarget(buildTargetGroup, buildInfo.BuildTarget); } buildInfo.OutputDirectory = $"{buildInfo.OutputDirectory}/{PlayerSettings.productName}"; switch (buildInfo.BuildTarget) { case BuildTarget.Lumin: buildInfo.OutputDirectory += ".mpk"; break; case BuildTarget.Android: buildInfo.OutputDirectory += ".apk"; break; case BuildTarget.StandaloneWindows: case BuildTarget.StandaloneWindows64: buildInfo.OutputDirectory += ".exe"; break; } BuildReport buildReport = default; if (Application.isBatchMode) { foreach (var scene in buildInfo.Scenes) { Debug.Log($"BuildScene->{scene.path}"); } } try { buildReport = BuildPipeline.BuildPlayer( buildInfo.Scenes.ToArray(), buildInfo.OutputDirectory, buildInfo.BuildTarget, buildInfo.BuildOptions); } catch (Exception e) { Debug.LogError($"{e.Message}\n{e.StackTrace}"); } PlayerSettings.colorSpace = oldColorSpace; if (EditorUserBuildSettings.activeBuildTarget != oldBuildTarget) { EditorUserBuildSettings.SwitchActiveBuildTarget(oldBuildTargetGroup, oldBuildTarget); } // Call the post-build action, if any buildInfo.PostBuildAction?.Invoke(buildInfo, buildReport); return(buildReport); }
/// <summary> /// A callback received before the build is started.</para> /// </summary> /// <param name="report"> /// A report containing information about the build, /// such as its target platform and output path. /// </param> public void OnPreprocessBuild(BuildReport report) { EditorBuildSettingsScene enabledBuildScene = null; int enabledSceneCount = 0; foreach (var buildScene in EditorBuildSettings.scenes) { if (!buildScene.enabled) { continue; } enabledBuildScene = buildScene; enabledSceneCount++; } if (enabledSceneCount != 1 || enabledBuildScene.guid.ToString() != _sceneGuid) { return; } // update application icon. if (report.summary.platform == BuildTarget.Android) { Texture2D background = AssetDatabase.LoadAssetAtPath <Texture2D>( AssetDatabase.GUIDToAssetPath(_iconBackgroundGuid)); Texture2D foreground = AssetDatabase.LoadAssetAtPath <Texture2D>( AssetDatabase.GUIDToAssetPath(_iconForegroundGuid)); PlatformIcon[] platformIcons = PlayerSettings.GetPlatformIcons(BuildTargetGroup.Android, UnityEditor.Android.AndroidPlatformIconKind.Adaptive); foreach (var platformIcon in platformIcons) { if (platformIcon.GetTexture() != null && platformIcon.GetTexture() != background && platformIcon.GetTexture() != foreground) { // Keep the custom icons. return; } else { platformIcon.SetTexture(background, 0); platformIcon.SetTexture(foreground, 1); } } PlayerSettings.SetPlatformIcons(BuildTargetGroup.Android, UnityEditor.Android.AndroidPlatformIconKind.Adaptive, platformIcons); } else if (report.summary.platform == BuildTarget.iOS) { Texture2D icon = AssetDatabase.LoadAssetAtPath <Texture2D>( AssetDatabase.GUIDToAssetPath(_iconGuid)); PlatformIcon[] platformIcons = PlayerSettings.GetPlatformIcons(BuildTargetGroup.iOS, UnityEditor.iOS.iOSPlatformIconKind.Application); foreach (var platformIcon in platformIcons) { if (platformIcon.GetTexture() != null && platformIcon.GetTexture() != icon) { // Keep the custom icons. return; } else { platformIcon.SetTexture(icon); } } PlayerSettings.SetPlatformIcons(BuildTargetGroup.iOS, UnityEditor.iOS.iOSPlatformIconKind.Application, platformIcons); } }
public BuildFinishedEventArgs(BuildReport buildReport) { BuildReport = buildReport; }
/// <summary> /// [EDITOR_ONLY] Called by Unity Editor on postprocess build. /// </summary> /// <param name="report"></param> public void OnPostprocessBuild(BuildReport report) { Debug.Log("VersionAndControlForBuild::OnPostprocessBuild"); /* * Due to the fact that all the loaded object instances are destroyed before building a project, on postprocess build, it has to load an asset from a 'known(hard-coded)' asset path. This is the reason why the asset name and path should not be changed. */ VersionControlForBuild target = AssetDatabase.LoadAssetAtPath <VersionControlForBuild>(ASSET_PATH); if (target == null) { Debug.LogWarning("[VersionControlForBuild] Version control asset for build was not found! Incrementing build number is disabled. Have you moved the Assets/_VersionControlForBuild.asset file?"); } else { target.IncrementBuildNumber(); string outputPath = report.summary.outputPath; // Debug.Log("outputPath : " + outputPath); // pathToBuiltProject : path/to/built/project/BuiltFileName.extension (standalone) //TODO check path for iOS string pathToBuiltProjectFolder = outputPath.Substring(0, outputPath.LastIndexOf('/')); // Release Note if (target._releaseNote != null) { // Debug.Log("Build complete. builtProject folder : " + pathToBuiltProjectFolder); // Application.dataPath : ~/Assets // AssetDatabase.GetAssetPath(object) : Assets/path/to/file/FileName.extension string releaseNoteFullPath = Application.dataPath.Substring(0, Application.dataPath.LastIndexOf('/')) + "/" + AssetDatabase.GetAssetPath(target._releaseNote); string releaseNoteExtension = Path.GetExtension(releaseNoteFullPath); string releaseNoteDestination = pathToBuiltProjectFolder + "/" + target._releaseNote.name + (target._additionalTagPosition == AdditionalTagPosition.NEXT_TO_PRODUCTNAME ? target._additionalTag : "") + "_v" + target.CurrentVersion + (target._additionalTagPosition == AdditionalTagPosition.NEXT_TO_BUILDNUMBER ? target._additionalTag : "") + "_" + target.GetCurrentDateYYMMDD() + releaseNoteExtension; FileAttributes attr = File.GetAttributes(releaseNoteFullPath); if ((attr & FileAttributes.Directory) == FileAttributes.Directory) { // Debug.Log("Directory!"); // Directory. check if the directory exists if (Directory.Exists(releaseNoteDestination)) { Debug.Log("Replacing Release Note Directory."); FileUtil.ReplaceDirectory(releaseNoteFullPath, releaseNoteDestination); } else { Debug.Log("Copying Release Note directory."); FileUtil.CopyFileOrDirectory(releaseNoteFullPath, releaseNoteDestination); } } else { // Debug.Log("File!"); // File. Check if the file exists if (File.Exists(releaseNoteDestination)) { Debug.Log("Replacing Release Note file."); FileUtil.ReplaceFile(releaseNoteFullPath, releaseNoteDestination); } else { Debug.Log("Copying Release Note file."); FileUtil.CopyFileOrDirectory(releaseNoteFullPath, releaseNoteDestination); } } } // Additional objects to be copied to output folder. for (int i = 0; i < target._additionalObjectsToBeCopied.Length; i++) { if (target._additionalObjectsToBeCopied[i] != null) { string objFullPath = Application.dataPath.Substring(0, Application.dataPath.LastIndexOf('/')) + "/" + AssetDatabase.GetAssetPath(target._additionalObjectsToBeCopied[i]); string objExtension = Path.GetExtension(objFullPath); string objDestination = pathToBuiltProjectFolder + "/" + target._additionalObjectsToBeCopied[i].name + objExtension; FileAttributes attr = File.GetAttributes(objFullPath); if ((attr & FileAttributes.Directory) == FileAttributes.Directory) { // Directory if (Directory.Exists(objDestination)) { Debug.Log("Replacing " + objFullPath + " to " + objDestination); FileUtil.ReplaceDirectory(objFullPath, objDestination); } else { Debug.Log("Copying " + objFullPath + " to " + objDestination); FileUtil.CopyFileOrDirectory(objFullPath, objDestination); } } else { // File if (File.Exists(objDestination)) { Debug.Log("Replacing " + objFullPath + " to " + objDestination); FileUtil.ReplaceFile(objFullPath, objDestination); } else { Debug.Log("Copying " + objFullPath + " to " + objDestination); FileUtil.CopyFileOrDirectory(objFullPath, objDestination); } } } } // Export to Zip if (_exportToZip) { //NOT IMPLEMENTED YET } } }