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