private static void BuildClient() { string buildFolder = Path.Combine("Builds", "BasicAuthorization", "Client"); BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions { scenes = new[] { "Assets/MasterServerToolkit/Demos/BasicAuthorization/Scenes/Client/Client.unity" }, locationPathName = Path.Combine(buildFolder, "Client.exe"), target = BuildTarget.StandaloneWindows64, options = BuildOptions.ShowBuiltPlayer | BuildOptions.Development }; BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = report.summary; if (summary.result == BuildResult.Succeeded) { MstProperties properties = new MstProperties(); properties.Add(Mst.Args.Names.StartClientConnection, true); properties.Add(Mst.Args.Names.MasterIp, Mst.Args.MasterIp); properties.Add(Mst.Args.Names.MasterPort, Mst.Args.MasterPort); File.WriteAllText(Path.Combine(buildFolder, "application.cfg"), properties.ToReadableString("\n", "=")); Debug.Log("Client build succeeded: " + (summary.totalSize / 1024) + " kb"); } if (summary.result == BuildResult.Failed) { Debug.Log("Client build failed"); } }
public static void Build( BuildTarget buildTarget, BuildOptions options = BuildOptions.None, string targetDirName = null) { string[] scenes = { "Assets/Scenes/Game.unity" }; const string basePath = "Build"; string locationPathName = Path.Combine( basePath, targetDirName ?? buildTarget.ToString(), buildTarget.HasFlag(BuildTarget.StandaloneWindows64) ? $"{PlayerName}.exe" : PlayerName); BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions { scenes = scenes, locationPathName = locationPathName, target = buildTarget, options = options | BuildOptions.Development, }; BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = report.summary; if (summary.result == BuildResult.Succeeded) { Debug.Log("Build succeeded: " + summary.totalSize + " bytes"); } if (summary.result == BuildResult.Failed) { Debug.LogError("Build failed"); } }
public static void BuildProject() { // Gather values from args var options = GetValidatedOptions(); var buildTarget = options["buildTarget"]; var buildPath = options["customBuildPath"]; // TODO: fix Unity Builder Action to use customBuildName // var buildName = options["customBuildName"]; // Gather values from project var scenes = EditorBuildSettings.scenes.Where(scene => scene.enabled).Select(s => s.path).ToArray(); // var locationPathName = $"{buildPath}/{buildName}{GetFileExtension(buildTarget)}"; var locationPathName = buildPath; var target = BuildTarget.StandaloneWindows64; // Define BuildPlayer Options var buildOptions = new BuildPlayerOptions { scenes = scenes, locationPathName = locationPathName, target = target, options = BuildOptions.CompressWithLz4HC }; // Try to parse the BuildTarget. If it isn't our custom "linuxserver" target, quit try { target = (BuildTarget)Enum.Parse(typeof(BuildTarget), buildTarget); } catch (ArgumentException) { if (buildTarget.ToLower().Equals("linuxserver")) { target = BuildTarget.StandaloneLinux64; buildOptions.options |= BuildOptions.Development; } else { Console.WriteLine("Invalid value for argument -buildTarget"); EditorApplication.Exit(121); } } buildOptions.target = target; ReportOptions(buildOptions); // Perform build BuildReport buildReport = BuildPipeline.BuildPlayer(buildOptions); // Summary BuildSummary summary = buildReport.summary; ReportSummary(summary); // Result BuildResult result = summary.result; ExitWithResult(result); }
void BuildAndroid(BuildQueueItem buildQueueItem) { BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions(); // Set target Android buildPlayerOptions.target = BuildTarget.Android; // Get all scenes paths that are added to build settings buildPlayerOptions.scenes = EditorBuildSettings.scenes.Select(scene => scene.path).ToArray(); // Set Graphics API switch ((int)(buildQueueItem.BuildOptions as AndroidBuildOptions).GraphicsAPI) { case (int)CustomAndroidGraphicsAPI.OpenGLES3: PlayerSettings.SetGraphicsAPIs(BuildTarget.Android, new[] { GraphicsDeviceType.OpenGLES3 }); break; case (int)CustomAndroidGraphicsAPI.Vulkan: PlayerSettings.SetGraphicsAPIs(BuildTarget.Android, new[] { GraphicsDeviceType.Vulkan }); break; default: throw new Exception("Unknown Graphics API selected"); } // Set Scripting backend switch ((int)(buildQueueItem.BuildOptions as AndroidBuildOptions).ScriptingBackend) { case (int)CustomAndroidScriptingBackend.Mono: PlayerSettings.SetScriptingBackend(BuildTargetGroup.Android, ScriptingImplementation.Mono2x); break; case (int)CustomAndroidScriptingBackend.IL2CPP: PlayerSettings.SetScriptingBackend(BuildTargetGroup.Android, ScriptingImplementation.IL2CPP); break; default: throw new Exception("Unknown scripting backend selected"); } // Set installation path buildPlayerOptions.locationPathName = "Builds/" + Application.productName + "_" + PlayerSettings.GetScriptingBackend(BuildTargetGroup.Android) + "_" + PlayerSettings.GetGraphicsAPIs(BuildTarget.Android)[0] + ".apk"; // Build player BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = report.summary; if (summary.result == BuildResult.Succeeded) { Debug.Log("Build succeeded: " + summary.totalSize + " bytes\nBuild location: " + buildPlayerOptions.locationPathName); } if (summary.result == BuildResult.Failed) { throw new Exception("Build failed"); } }
public static void Build() { if (UnityEditor.BuildPipeline.isBuildingPlayer) { return; } settings = AndroidBuildPipelineSettings.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; } if (settings.incrementBundle) { int bundleVersion = PlayerSettings.Android.bundleVersionCode; bundleVersion++; PlayerSettings.Android.bundleVersionCode = bundleVersion; } if (settings.useKeystore) { PlayerSettings.Android.keystoreName = settings.keystoreName; PlayerSettings.Android.keystorePass = settings.keystorePass; PlayerSettings.Android.keyaliasName = settings.keyaliasName; PlayerSettings.Android.keyaliasPass = settings.keyaliasPass; } string fileName = settings.GetFileName(); string buildPath = Path.Combine(path, fileName); BuildReport report = UnityEditor.BuildPipeline.BuildPlayer(scenes.ToArray(), buildPath, BuildTarget.Android, 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."); Application.OpenURL(path); } if (summary.result == BuildResult.Failed) { Debug.LogError($"Build failed..."); } }
public static void Build() { if (UnityEditor.BuildPipeline.isBuildingPlayer) { return; } settings = BuildPipelineIOSSettings.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; } 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..."); } }
bool CreateLinuxBuildAndZip(string buildName, out string zipPath) { string pathToZip; var pathToProjectBuild = Application.dataPath + "/../" + "Build/"; if (!Directory.Exists(pathToProjectBuild) || Directory.Exists(pathToProjectBuild) && !Directory.Exists(pathToProjectBuild + buildName) ) { Directory.CreateDirectory((pathToProjectBuild + buildName)); } pathToProjectBuild = pathToProjectBuild + buildName + "/"; // Create Linux build BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions(); buildPlayerOptions.scenes = new[] { "Assets/Scenes/MainScene.unity" }; buildPlayerOptions.locationPathName = Path.Combine(pathToProjectBuild, buildName + ".x86_64"); buildPlayerOptions.target = BuildTarget.StandaloneLinux64; BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = report.summary; if (summary.result == BuildResult.Succeeded) { Debug.Log("Build succeeded."); EditorUtility.DisplayProgressBar("Compress Project", "Compressing Project Build...", 0); ulong totalSize = summary.totalSize; // Zip the build pathToZip = Application.dataPath + "/../" + "Build/" + buildName; Zip.DirectoryContents(pathToZip, buildName); EditorUtility.ClearProgressBar(); // Return path to .zip file string[] st = Directory.GetFiles(pathToZip + "/../", buildName + ".zip"); if (st.Length != 0) { pathToZip = Path.GetFullPath(st[0]); } else { zipPath = null; return(false); } } else { zipPath = null; return(false); } zipPath = pathToZip; return(true); }
public void Build_Positive_PerformWindows64BuildTest() { EditorBuildSettingsScene[] scenes = { new EditorBuildSettingsScene("Assets/Editor/Build/Tests/Scenes/BuildScene.unity", true) }; EditorBuildSettings.scenes = scenes; BuildSummary summary = BuildSystem.Windows64Build(); Assert.AreEqual(summary.result, BuildResult.Succeeded, "Did not succeed in building for Windows 64"); }
private static bool ExportProject(BuildTarget buildTarget) { string exportPath = null; if (buildTarget == BuildTarget.iOS) { exportPath = BuildProjectSetting.instance.iOSExportPath; } else if (buildTarget == BuildTarget.Android) { exportPath = BuildProjectSetting.instance.androidExportPath; } if (string.IsNullOrEmpty(exportPath)) { Log.W(TAG, "Build error:export path is empty!"); return(false); } if (Directory.Exists(exportPath)) { Directory.Delete(exportPath, true); } if (buildTarget == BuildTarget.Android) { EditorUserBuildSettings.androidBuildSystem = AndroidBuildSystem.Gradle; // Export Android Project for use with Android Studio/Gradle. EditorUserBuildSettings.exportAsGoogleAndroidProject = true; PlayerSettings.Android.bundleVersionCode = BuildProjectSetting.instance.androidVersionCode; PlayerSettings.bundleVersion = BuildProjectSetting.instance.androidVersionName; } else if (buildTarget == BuildTarget.iOS) { PlayerSettings.iOS.buildNumber = BuildProjectSetting.instance.iOSBuildCode.ToString(); PlayerSettings.bundleVersion = BuildProjectSetting.instance.iOSVersionName; } string[] scenes = FindEnabledEditorScenes(); // BuildOptions.AcceptExternalModificationsToPlayer: Used when building Xcode (iOS) or Eclipse (Android) projects. BuildReport report = BuildPipeline.BuildPlayer(scenes, exportPath, buildTarget, BuildOptions.AcceptExternalModificationsToPlayer); BuildSummary summary = report.summary; if (summary.result == BuildResult.Succeeded) { Log.I(TAG, "Build project succeed, size:{0}, time:{1}, outpath:{2}", summary.totalSize, summary.totalTime, summary.outputPath); return(true); } Log.E(TAG, "Build failed, message:" + summary.result); return(false); }
private void Build(ScriptingImplementation backend, BuildTarget target, bool debug = false) { BuildTargetGroup targetGroup = BuildPipeline.GetBuildTargetGroup(target); PlayerSettings.SetScriptingBackend(targetGroup, backend); BuildOptions debugBuildOptions = DebugBuildOptions; if (_settings.autoconnectProfiler) { debugBuildOptions |= BuildOptions.ConnectWithProfiler; } if (_settings.deepProfilingSupport) { debugBuildOptions |= BuildOptions.EnableDeepProfilingSupport; } if (_settings.buildAndRun) { debugBuildOptions |= BuildOptions.AutoRunPlayer; } (string targetStr, string fileExtension) = TargetToStringAndFileExtension(target); BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions { locationPathName = $"Builds/{PlayerSettings.bundleVersion}/{(debug ? "Debug" : "Release")}/{targetStr}/{PlayerSettings.productName}.{fileExtension}", options = debug ? debugBuildOptions : ReleaseBuildOptions, scenes = _settings.GetSceneAssetsPathArray(), target = target, targetGroup = targetGroup }; BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = report.summary; switch (summary.result) { case BuildResult.Unknown: break; case BuildResult.Succeeded: Debug.Log($"Build Succeeded: {summary.totalSize} bytes"); break; case BuildResult.Failed: Debug.Log("Build Failed"); break; case BuildResult.Cancelled: Debug.Log("Build Cancelled"); break; default: throw new ArgumentOutOfRangeException(); } }
private GetBuildResponse ToGetBuildResponse(BuildSummary buildSummary) { return(new GetBuildResponse() { BuildId = buildSummary.BuildId, BuildName = buildSummary.BuildName, CreationTime = buildSummary.CreationTime, Metadata = buildSummary.Metadata }); }
public static void Draw() { _showBuildAndPublish = EditorGUILayout.BeginFoldoutHeaderGroup(_showBuildAndPublish, "Build And Publish", EditorStyles.foldoutHeader); if (_showBuildAndPublish) { _selectedEngine = (int)(StreamEngines)EditorGUILayout.EnumPopup( "Streaming engine", (StreamEngines)_selectedEngine ); _selectedPlatform = (int)(Platforms)EditorGUILayout.EnumPopup( "Platform", (Platforms)_selectedPlatform ); GUILayout.Space(5); GUI.enabled = FurioosInspector.selectedApplication != null && !FurioosInspector.lockUI; Rect buildAndPublishButtonRect = EditorGUILayout.BeginVertical(); buildAndPublishButtonRect.width /= 2; buildAndPublishButtonRect.x = buildAndPublishButtonRect.width / 2; if (GUI.Button(buildAndPublishButtonRect, "Build & Publish")) { string buildPath = EditorUtility.SaveFilePanel("Save build to folder", "", "", "exe"); string[] scenes = new string[EditorBuildSettings.scenes.Length]; Debug.Log(EditorBuildSettings.scenes); for (int i = 0; i < EditorBuildSettings.scenes.Length; i++) { if (!EditorBuildSettings.scenes[i].enabled) { continue; } scenes[i] = EditorBuildSettings.scenes[i].path; } BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions { scenes = scenes, locationPathName = buildPath, target = (_selectedPlatform == (int)Platforms.Windows) ? BuildTarget.StandaloneWindows64 : BuildTarget.StandaloneOSX, options = BuildOptions.None }; BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = report.summary; } GUILayout.Space(40); EditorGUILayout.EndVertical(); GUI.enabled = !FurioosInspector.lockUI; } EditorGUILayout.EndFoldoutHeaderGroup(); }
public static void BuildProject() { // Gather values from args var options = ArgumentsParser.GetValidatedOptions(); // Gather values from project var scenes = EditorBuildSettings.scenes.Where(scene => scene.enabled).Select(s => s.path).ToArray(); // Get all buildOptions from options BuildOptions buildOptions = BuildOptions.None; foreach (string buildOptionString in Enum.GetNames(typeof(BuildOptions))) { if (options.ContainsKey(buildOptionString)) { BuildOptions buildOptionEnum = (BuildOptions)Enum.Parse(typeof(BuildOptions), buildOptionString); buildOptions |= buildOptionEnum; } } // Define BuildPlayer Options var buildPlayerOptions = new BuildPlayerOptions { scenes = scenes, locationPathName = options["customBuildPath"], target = (BuildTarget)Enum.Parse(typeof(BuildTarget), options["buildTarget"]), options = buildOptions }; // Set version for this build VersionApplicator.SetVersion(options["buildVersion"]); VersionApplicator.SetAndroidVersionCode(options["androidVersionCode"]); // Apply Android settings if (buildPlayerOptions.target == BuildTarget.Android) { AndroidSettings.Apply(options); } // Execute default AddressableAsset content build, if the package is installed #if USE_ADDRESSABLES AddressableAssetSettings.CleanPlayerContent(); AddressableAssetSettings.BuildPlayerContent(); #endif // Perform build BuildReport buildReport = BuildPipeline.BuildPlayer(buildPlayerOptions); // Summary BuildSummary summary = buildReport.summary; StdOutReporter.ReportSummary(summary); // Result BuildResult result = summary.result; StdOutReporter.ExitWithResult(result); }
public static void Build() { //var args = new string[]{"-buildtarget","IOS","-buildpath","Builds/ios"}; var args = Environment.GetCommandLineArgs(); var cancel = false; var buildTarget = CommandlineParseUtils.GetArgumentData(args, "-buildtarget"); if (string.IsNullOrEmpty(buildTarget)) { Debug.LogWarning("no build platform set (use \"-buildtarget <buildtarget>\")"); cancel = true; } var buildPath = CommandlineParseUtils.GetArgumentData(args, "-buildpath"); if (string.IsNullOrEmpty(buildPath)) { Debug.LogWarning("no build path set (use \"-buildpath <platform>\")"); cancel = true; } if (cancel) { Debug.LogWarning("Build canceled (not enough information)"); return; } var buildTargetParsed = (BuildTarget)Enum.Parse(typeof(BuildTarget), buildTarget, true); BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions(); buildPlayerOptions.locationPathName = buildPath; buildPlayerOptions.target = buildTargetParsed; buildPlayerOptions.scenes = EditorBuildSettingsScene.GetActiveSceneList(EditorBuildSettings.scenes); buildPlayerOptions.options = BuildOptions.None; Debug.Log($"Starting build: buildTarget='{buildTargetParsed}' buildPath='{buildPath}'"); BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = report.summary; if (summary.result == BuildResult.Succeeded) { Debug.Log($"Build succeeded: {(summary.totalSize * 1e-6)} MB {summary.totalTime:hh\\:mm\\:ss}"); } if (summary.result == BuildResult.Failed) { throw new UnityException("Build failed"); //throw exception to make sure exit code is not 0 } }
static void GenericBuild(string[] scenes, string target_filename, BuildTarget build_target, BuildOptions build_options) { EditorUserBuildSettings.SwitchActiveBuildTarget(build_target); BuildReport report = BuildPipeline.BuildPlayer(scenes, target_filename, build_target, build_options); BuildSummary summary = report.summary; if (summary.result == BuildResult.Failed) { throw new Exception("BuildPlayer failure"); } }
protected static void ReportBuildData(BuildReport report) { BuildSummary summary = report.summary; Measure.Custom(FormatSampleGroupName(k_Size, k_Total).ToSampleGroup(SampleUnit.Byte), summary.totalSize); Measure.Custom(FormatSampleGroupName(k_Size, k_Shader).ToSampleGroup(SampleUnit.Byte), GetAssetSizeInBuild(report, typeof(Shader))); Measure.Custom(FormatSampleGroupName(k_Size, k_ComputeShader).ToSampleGroup(SampleUnit.Byte), GetAssetSizeInBuild(report, typeof(ComputeShader))); Measure.Custom(FormatSampleGroupName(k_Time, k_Total).ToSampleGroup(SampleUnit.Millisecond), summary.totalTime.TotalMilliseconds); Measure.Custom(FormatSampleGroupName(k_Build, k_Warnings).ToSampleGroup(), summary.totalWarnings); Measure.Custom(FormatSampleGroupName(k_Build, k_Success).ToSampleGroup(), summary.result == BuildResult.Succeeded ? 1 : 0); }
static void BaseBuild(BuildTargetGroup buildTargetGroup, BuildTarget buildTarget, BuildOptions buildOptions, bool needReturnBuildTarget, bool incrementPatch, string zipPath, string buildName) { string basePath = $"Builds/{PlayerSettings.productName}_{PlayerSettings.bundleVersion}.{LastBuildPatch}"; BuildTarget targetBeforeStart = EditorUserBuildSettings.activeBuildTarget; BuildTargetGroup targetGroupBeforeStart = BuildPipeline.GetBuildTargetGroup(targetBeforeStart); if (LastBundleVersion != PlayerSettings.bundleVersion) { LastBundleVersion = PlayerSettings.bundleVersion; LastBuildPatch = 0; } BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions { scenes = EditorBuildSettings.scenes.Where(s => s.enabled).Select(s => s.path).ToArray(), locationPathName = basePath + buildName, targetGroup = buildTargetGroup, target = buildTarget, options = buildOptions, }; BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = report.summary; //TODO: Зробити вивід гарнішим. Щоб виглядало по типу таблиці. //Зараз \t не вирівнює його, коли summary.platform дуже різних довжин, наприклад StandaloneWindows та StandaloneOSX if (summary.result == BuildResult.Succeeded) { Debug.Log($"{summary.platform} succeeded. \t Time: {string.Format("{0:mm\\:ss}", summary.totalTime)} \t Size: {summary.totalSize / 1048576f}"); if (zipPath != null && zipPath != "") { Compress(basePath + zipPath); } } else if (summary.result == BuildResult.Failed) { Debug.Log( $"{summary.platform} failed. \t Time: {string.Format("{0:mm\\:ss}", summary.totalTime)} \t Size: {summary.totalSize / 1048576f}" + "\n" + $"Warnings: {summary.totalWarnings}" + "\n" + $"Errors: {summary.totalErrors}" ); } if (incrementPatch) { ++LastBuildPatch; } if (needReturnBuildTarget) { EditorUserBuildSettings.SwitchActiveBuildTarget(targetGroupBeforeStart, targetBeforeStart); } }
public void Duration() { var buildSummary = new BuildSummary { StartTime = DateTime.Now }; buildSummary.FinishTime = buildSummary.StartTime.AddMinutes(1); Assert.AreEqual(TimeSpan.FromMinutes(1), buildSummary.Duration); }
public static bool Build(BuildTarget platform, string pathname, bool production = false) { BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions(); buildPlayerOptions.scenes = testScenes; buildPlayerOptions.target = platform; if (production) { PlayerSettings.SetScriptingBackend(BuildTargetGroup.Standalone, ScriptingImplementation.IL2CPP); buildPlayerOptions.locationPathName = "./builds/prod/" + platform.ToString() + "/" + pathname; buildPlayerOptions.options = BuildOptions.CompressWithLz4HC; // use HC for final release in compress } else { PlayerSettings.SetScriptingBackend(BuildTargetGroup.Standalone, ScriptingImplementation.Mono2x); buildPlayerOptions.locationPathName = "./builds/dev/" + platform.ToString() + "/" + pathname; buildPlayerOptions.options = BuildOptions.CompressWithLz4 | BuildOptions.Development; // use HC for final release in compress } // PlayerSettings.bundleVersion BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = report.summary; Debug.ClearDeveloperConsole(); if (summary.result == BuildResult.Succeeded) { Debug.LogFormat( "Build succeeded {0}: {1} mb and took {2} seconds with {3} error(s). Version: {4}. Location: {5}.", summary.platform.ToString(), (summary.totalSize / 1024 / 1024).ToString(), summary.totalTime.Seconds, summary.totalErrors, Application.version, summary.outputPath ); return(true); } else { Debug.LogFormat( "<color=#f00>Build {0}</color> {1}: {2} mb and took {3} seconds with {4} error(s).", summary.result.ToString(), summary.platform.ToString(), (summary.totalSize / 1024 / 1024).ToString(), summary.totalTime.Seconds, summary.totalErrors ); return(false); } }
public void Finish(bool succeeded, DateTime time) { if (Status != BuildStatus.Running) { throw new InvalidOperationException(); } BuildStatus newStatus = succeeded ? BuildStatus.Finished : BuildStatus.Failed; var elapsedTime = time - StartTime; BuildSummary = new BuildSummary(BuildSummary, newStatus, elapsedTime); }
public static bool BuildGameForPlatform(string[] levels, string path, string subfolder, string name, BuildTarget target) { string buildPath = path; string extention; switch (target) { case BuildTarget.Android: buildPath += "Android/"; extention = "apk"; break; case BuildTarget.StandaloneWindows64: buildPath += "Windows/" + subfolder; extention = "exe"; break; case BuildTarget.StandaloneLinux64: buildPath += "Linux/" + subfolder; extention = "x86_64"; break; case BuildTarget.StandaloneOSX: buildPath += "Mac/"; extention = "app"; break; default: Debug.LogWarning("Building for an unsupported plartform."); buildPath += target + "/"; extention = "run"; break; } BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions { scenes = levels, locationPathName = buildPath + name + "." + extention, target = target, options = BuildOptions.None }; // Build player. var result = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = result.summary; if (summary.result == BuildResult.Succeeded) { return(true); } return(false); }
private static bool ReportOnBuild(BuildReport report) { BuildSummary summary = report.summary; if (summary.result == BuildResult.Succeeded) { string message = string.Format("Success! File created at {0}", summary.outputPath); LogActionSuccess(message); return(true); } LogActionFailure("Something went wrong!"); return(false); }
void BuildPlayer(BuildTargetGroup buildTargetGroup, BuildTarget buildTarget, string buildOutputPath, BuildOptions buildOptions, out BuildReport buildReport, out BuildSummary buildSummary) { BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions(); buildPlayerOptions.locationPathName = buildOutputPath; buildPlayerOptions.target = buildTarget; buildPlayerOptions.options = buildOptions; buildPlayerOptions.targetGroup = buildTargetGroup; buildReport = BuildPipeline.BuildPlayer(buildPlayerOptions); buildSummary = buildReport.summary; }
private static void ZipAndDeploy(BuildSummary buildSummary) { var zipFilePath = buildSummary.outputPath.Replace(webGlBuildPrefix, "").Replace(desktopBuildPrefix, "").Replace("feature-", "") + ".zip"; if (File.Exists(zipFilePath)) { File.Delete(zipFilePath); } ZipFile.CreateFromDirectory(buildSummary.outputPath, zipFilePath); Debug.Log("Zipped build in: " + zipFilePath); DeployZipFile(zipFilePath); }
/// <summary> /// Logs a given build summary /// </summary> /// <param name="buildSummary"></param> private static void LogBuildSummary(BuildSummary buildSummary) { if (buildSummary.result == BuildResult.Succeeded) { Debug.Log("Build succeeded: " + SizeSuffix(buildSummary.totalSize) + " in " + buildSummary.totalTime + " time"); } if (buildSummary.result == BuildResult.Failed) { Debug.Log("Build failed"); } }
//https://docs.unity3d.com/ScriptReference/BuildPipeline.BuildPlayer.html static void GenericBuild(string[] scenes, string target_dir, BuildTargetGroup targetGroup, BuildTarget build_target, BuildOptions build_options) { if (Directory.Exists(target_dir)) { FileUtil.DeleteDir(target_dir); } else { Directory.CreateDirectory(target_dir); } EditorUserBuildSettings.SwitchActiveBuildTarget(targetGroup, build_target); // string res = BuildReport report = BuildPipeline.BuildPlayer(scenes, target_dir, build_target, build_options); BuildSummary summary = report.summary; if (summary.result == BuildResult.Succeeded) { Debug.Log("Build succeeded: " + summary.totalSize + " bytes build_target=" + build_target); if (build_target == BuildTarget.iOS) { // #if UNITY_IOS Debug.Log("BuildiOSPlayer start "); BuildiOSPlayer.EditProj(target_dir); Debug.Log("BuildiOSPlayer end "); // #endif } if (Application.platform == RuntimePlatform.WindowsEditor) { if (build_target == BuildTarget.iOS) { FileUtil.DeleteMetaFiles(dirRootProject + "/Frameworks/Plugins"); FileUtil.DeleteMetaFiles(dirRootProject + "/Libraries/Plugins"); //RunShell阿里云上异常 RunShell.RunProcessCommand("explorer.exe", dirRootProject); } } } if (summary.result == BuildResult.Failed) { Debug.Log("Build failed"); } // if (res.Length > 0) // { // throw new Exception("BuildPlayer failure: " + res); // } }
public static BuildSummary PerformBuild(BuildPlayerOptions p_buildOptions) { BuildSummary summary = new BuildSummary(); if (!IsSceneStringsCorrect(p_buildOptions.scenes)) { return(summary); } bool buildSuccess = false; Debug.Log("Buildplayer Options:"); Debug.Log(p_buildOptions.options); BuildReport report = BuildPipeline.BuildPlayer(p_buildOptions); summary = report.summary; buildSuccess = summary.result == BuildResult.Succeeded; if (buildSuccess) { Debug.Log("Build Succeeded: " + summary.totalSize + " bytes"); Debug.Log("Build Time: " + summary.totalTime); Debug.Log("Build Path: " + summary.outputPath); } else { Debug.LogError("Build result did not yield in success"); Debug.LogWarning("Result:" + summary.result); Debug.LogWarning("GUID:" + summary.guid); Debug.LogWarning("Options:" + summary.options); Debug.LogWarning("Outpath:" + summary.outputPath); Debug.LogWarning("Platform:" + summary.platform); Debug.LogWarning("Errors:" + summary.totalErrors); Debug.LogWarning("Warnings:" + summary.totalWarnings); Debug.LogWarning("Time:" + summary.totalTime); Debug.Log("Steps taking place during build:"); foreach (BuildStep step in report.steps) { Debug.Log(step.name); foreach (BuildStepMessage message in step.messages) { Debug.Log(string.Format("Type {0} - content:{1}", message.type, message.content)); } } } return(summary); }
public static void BuildMobile() { //Android Build BuildPlayerOptions androidPlayerOptions = new BuildPlayerOptions(); PlayerSettings.Android.keystoreName = "/Users/keenangray/Docs/AndroidKeystore/keystore.keystore"; PlayerSettings.Android.keystorePass = "******"; PlayerSettings.Android.keyaliasName = "hld"; PlayerSettings.Android.keyaliasPass = "******"; androidPlayerOptions.scenes = new[] { "Assets/Scenes/AppScene.unity" }; androidPlayerOptions.locationPathName = "Builds/AndroidBuild.apk"; androidPlayerOptions.target = BuildTarget.Android; androidPlayerOptions.options = BuildOptions.None; BuildReport androidReport = BuildPipeline.BuildPlayer(androidPlayerOptions); BuildSummary androidSummary = androidReport.summary; if (androidSummary.result == BuildResult.Succeeded) { Debug.Log("Android Build succeeded: " + androidSummary.totalSize + " bytes"); } if (androidSummary.result == BuildResult.Failed) { Debug.Log("Android Build failed"); return; } //IOS Build BuildPlayerOptions iosBuildPlayerOptions = new BuildPlayerOptions(); iosBuildPlayerOptions.scenes = new[] { "Assets/Scenes/AppScene.unity" }; iosBuildPlayerOptions.locationPathName = "Builds/iOSBuild"; iosBuildPlayerOptions.target = BuildTarget.iOS; iosBuildPlayerOptions.options = BuildOptions.AcceptExternalModificationsToPlayer; BuildReport iosReport = BuildPipeline.BuildPlayer(iosBuildPlayerOptions); BuildSummary iosSummary = iosReport.summary; if (iosSummary.result == BuildResult.Succeeded) { Debug.Log("IOS Build succeeded: " + iosSummary.totalSize + " bytes"); } if (iosSummary.result == BuildResult.Failed) { Debug.Log("IOS Build failed"); } }
public static void AndroidBuildAAB() { // First we check for any existing .aab file and delete it (you can run into problems with the build not overwriting // the older file). So if directory exists then we need to delete out the .aab var previousAABFileLocation = new DirectoryInfo(@"Build\Android\"); if (previousAABFileLocation.Exists) { var filePaths = previousAABFileLocation.GetFiles("*.aab"); foreach (var file in filePaths) { file.Delete(); } } // Build Options for AAB (Google Play) // Add as appBundle EditorUserBuildSettings.buildAppBundle = true; // Set Scripting to Mono PlayerSettings.SetScriptingBackend(BuildTargetGroup.Android, ScriptingImplementation.IL2CPP); // Set architecture to ARM64 or ARM7 for deployment to Google Play PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARM64 | AndroidArchitecture.ARMv7; BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions(); buildPlayerOptions.scenes = FindActiveScenesInBuildSettings(); buildPlayerOptions.locationPathName = @"Build\Android\" + Application.productName + ".aab"; buildPlayerOptions.target = BuildTarget.Android; buildPlayerOptions.options = BuildOptions.None; BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = report.summary; if (summary.result == BuildResult.Succeeded) { // We must use UnityEngine.Debug as we are using System.Diagnositics in order to run an external .exe file Debug.Log("Build succeeded!"); // Copy the file to the server (this is easier for the Android device to download from) File.Copy(@"Build\Android\" + Application.productName + ".aab", @"\\192.168.1.250\ServerDisk1\_Build\Android\" + Application.productName + ".aab", true); } if (summary.result == BuildResult.Failed) { Debug.Log("***ANDROID BUILD FAILED!***"); } }
private void ExecuteBuild() { foreach (BuildProfileTable profile in buildProfiles) { if (!profile.Enabled) { continue; } if (!PreBuildChecks.Check(profile)) { BuildFailed(); return; } // We want to shut down the process if its already running if (killOldProcesses) { CheckIfProcessRunning(profile); } if (eraseDirectory) { FileUtil.DeleteFileOrDirectory(profile.ScriptableObject.directory); } string buildFullLocation = profile.ScriptableObject.directory + profile.ScriptableObject.executableName + SetExecutableExtension.Get(profile.ScriptableObject.platform); BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions { locationPathName = buildFullLocation, //options = profile.ScriptableObject.buildOptions, scenes = profile.ScriptableObject.sceneDirectories, //target = ConvertToUnityBuildTarget.Convert(profile.ScriptableObject.platform) target = BuildTarget.StandaloneWindows64 }; BuildReport buildReport = BuildPipeline.BuildPlayer(buildPlayerOptions); BuildSummary summary = buildReport.summary; if (summary.result == BuildResult.Succeeded) { BuildSucceeded(summary, buildFullLocation, profile.ScriptableObject.args); AddCompletedBuild(profile); } } }
private static void ReportSummary(BuildSummary summary) { Console.WriteLine( $"{Eol}" + $"###########################{Eol}" + $"# Build results #{Eol}" + $"###########################{Eol}" + $"{Eol}" + $"Duration: {summary.totalTime.ToString()}{Eol}" + $"Warnings: {summary.totalWarnings.ToString()}{Eol}" + $"Errors: {summary.totalErrors.ToString()}{Eol}" + $"Size: {summary.totalSize.ToString()} bytes{Eol}" + $"{Eol}" ); }
public BuildSummary GetBuildSummary(BuildData buildData) { BuildSummary result = null; foreach (BuildSummary summary in _summaries) { if (summary.BuildUri == buildData.BuildUri) { result = summary; break; } } if (result == null) { result = new BuildSummary(); _summaries.Add(result); } result.BuildDate = buildData.StartTime; result.BuildNumber = buildData.BuildNumber; result.BuildStatus = buildData.BuildStatus; result.BuildUri = buildData.BuildUri; result.DropLocation = buildData.DropLocation; return result; }