static public string GetExtensionForBuildTarget(BuildTargetGroup targetGroup, BuildTarget target, BuildOptions options) => GetExtensionForBuildTarget(targetGroup, target, EditorUserBuildSettings.GetActiveSubtargetFor(target), options);
void ShowBuildTargetSettings()
{
EditorGUIUtility.labelWidth = Mathf.Min(180, (position.width - 265) * 0.47f);
BuildTarget buildTarget = EditorUserBuildSettingsUtils.CalculateSelectedBuildTarget();
BuildTargetGroup buildTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
BuildPlatform platform = BuildPlatforms.instance.BuildPlatformFromTargetGroup(buildTargetGroup);
bool licensed = BuildPipeline.LicenseCheck(buildTarget);
// Draw the group name
GUILayout.Space(18);
// Draw icon and text of title separately so we can control the space between them
Rect r = GUILayoutUtility.GetRect(50, 36);
r.x += 1;
GUI.Label(new Rect(r.x + 3, r.y + 3, 32, 32), platform.title.image, GUIStyle.none);
GUI.Toggle(r, false, platform.title.text, styles.platformSelector);
GUILayout.Space(10);
if (platform.targetGroup == BuildTargetGroup.WebGL && !BuildPipeline.IsBuildTargetSupported(platform.targetGroup, buildTarget))
{
if (IntPtr.Size == 4)
{
GUILayout.Label("Building for WebGL requires a 64-bit Unity editor.");
GUIBuildButtons(false, false, false, platform);
return;
}
}
string moduleName = Modules.ModuleManager.GetTargetStringFrom(buildTargetGroup, buildTarget);
if (IsModuleNotInstalled(buildTargetGroup, buildTarget))
{
GUILayout.Label(EditorGUIUtility.TextContent(string.Format(styles.noModuleLoaded, BuildPlatforms.instance.GetModuleDisplayName(buildTargetGroup, buildTarget))));
if (GUILayout.Button(styles.openDownloadPage, EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
{
string url = GetPlaybackEngineDownloadURL(moduleName);
Help.BrowseURL(url);
}
GUIBuildButtons(false, false, false, platform);
return;
}
else if (Application.HasProLicense() && !InternalEditorUtility.HasAdvancedLicenseOnBuildTarget(buildTarget))
{
// Show copy for using personal edition build targets with pro edition editor
string infoText = string.Format(styles.infoText,
BuildPlatforms.instance.GetBuildTargetDisplayName(buildTargetGroup, buildTarget));
GUILayout.BeginVertical(EditorStyles.helpBox);
GUILayout.Label(infoText, EditorStyles.wordWrappedMiniLabel);
GUILayout.BeginHorizontal();
if (GUILayout.Button(styles.eula, EditorStyles.miniButton))
{
Application.OpenURL("http://unity3d.com/legal/eula");
}
if (GUILayout.Button(string.Format(styles.addToYourPro, BuildPlatforms.instance.GetBuildTargetDisplayName(buildTargetGroup, buildTarget)), EditorStyles.miniButton))
{
Application.OpenURL("http://unity3d.com/get-unity");
}
GUILayout.EndHorizontal();
GUILayout.EndVertical();
}
GUIContent error = styles.GetDownloadErrorForTarget(buildTarget);
if (error != null)
{
GUILayout.Label(error, EditorStyles.wordWrappedLabel);
GUIBuildButtons(false, false, false, platform);
return;
}
// Draw not licensed buy now UI
if (!licensed)
{
string niceName = BuildPipeline.GetBuildTargetGroupDisplayName(buildTargetGroup);
string licenseMsg = "Your license does not cover {0} Publishing.";
string buttonMsg = "Go to Our Online Store";
if (BuildTargetDiscovery.PlatformHasFlag(buildTarget, TargetAttributes.IsConsole))
{
licenseMsg += "Please see the {0} section of the Platform Module Installation documentation for more details.";
buttonMsg = "Platform Module Installation";
}
else if (BuildTargetDiscovery.PlatformHasFlag(buildTarget, TargetAttributes.IsStandalonePlatform))
{
buttonMsg = "";
}
GUIContent[] notLicensedMessage =
{
EditorGUIUtility.TextContent(string.Format(L10n.Tr(licenseMsg), niceName)),
EditorGUIUtility.TextContent(L10n.Tr(buttonMsg)),
new GUIContent(styles.shopURL)
};
GUILayout.Label(notLicensedMessage[0], EditorStyles.wordWrappedLabel);
GUILayout.Space(5);
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (notLicensedMessage[1].text.Length != 0)
{
if (GUILayout.Button(notLicensedMessage[1]))
{
Application.OpenURL(notLicensedMessage[2].text);
}
}
GUILayout.EndHorizontal();
GUIBuildButtons(false, false, false, platform);
return;
}
// FIXME: WHY IS THIS ALL IN ONE FUNCTION?!
// Draw the side bar to the right. Different options like specific Standalone player to build, profiling and debugging options, etc.
string module = ModuleManager.GetTargetStringFrom(platform.targetGroup, buildTarget);
IBuildWindowExtension buildWindowExtension = ModuleManager.GetBuildWindowExtension(module);
if (buildWindowExtension != null)
{
buildWindowExtension.ShowPlatformBuildOptions();
}
GUI.changed = false;
GUI.enabled = true;
bool enableBuildButton = buildWindowExtension != null?buildWindowExtension.EnabledBuildButton() : true;
bool enableBuildAndRunButton = false;
bool shouldDrawDebuggingToggle = buildWindowExtension != null?buildWindowExtension.ShouldDrawScriptDebuggingCheckbox() : true;
bool shouldDrawExplicitNullChecksToggle = buildWindowExtension != null?buildWindowExtension.ShouldDrawExplicitNullCheckbox() : false;
bool shouldDrawDivideByZeroChecksToggle = buildWindowExtension != null?buildWindowExtension.ShouldDrawExplicitDivideByZeroCheckbox() : false;
bool shouldDrawArrayBoundsChecksToggle = buildWindowExtension != null?buildWindowExtension.ShouldDrawExplicitArrayBoundsCheckbox() : false;
bool shouldDrawDevelopmentPlayerToggle = buildWindowExtension != null?buildWindowExtension.ShouldDrawDevelopmentPlayerCheckbox() : true;
IBuildPostprocessor postprocessor = ModuleManager.GetBuildPostProcessor(buildTargetGroup, buildTarget);
bool enableBuildScriptsOnly = (postprocessor != null ? postprocessor.SupportsScriptsOnlyBuild() : false);
bool canInstallInBuildFolder = false;
if (BuildPipeline.IsBuildTargetSupported(buildTargetGroup, buildTarget))
{
bool shouldDrawConnectProfilerToggle = buildWindowExtension != null?buildWindowExtension.ShouldDrawProfilerCheckbox() : true;
GUI.enabled = shouldDrawDevelopmentPlayerToggle;
if (shouldDrawDevelopmentPlayerToggle)
{
EditorUserBuildSettings.development = EditorGUILayout.Toggle(styles.debugBuild, EditorUserBuildSettings.development);
}
bool developmentBuild = EditorUserBuildSettings.development;
GUI.enabled = developmentBuild;
if (shouldDrawConnectProfilerToggle)
{
if (!GUI.enabled)
{
if (!developmentBuild)
{
styles.profileBuild.tooltip = "Profiling only enabled in Development Player";
}
}
else
{
styles.profileBuild.tooltip = "";
}
EditorUserBuildSettings.connectProfiler = EditorGUILayout.Toggle(styles.profileBuild, EditorUserBuildSettings.connectProfiler);
}
GUI.enabled = developmentBuild;
if (shouldDrawDebuggingToggle)
{
using (new EditorGUI.DisabledScope(buildWindowExtension != null ? buildWindowExtension.ShouldDisableManagedDebuggerCheckboxes() : false))
{
EditorUserBuildSettings.allowDebugging = EditorGUILayout.Toggle(styles.allowDebugging, EditorUserBuildSettings.allowDebugging);
// Not all platforms have native dialog implemented in Runtime\Misc\GiveDebuggerChanceToAttachIfRequired.cpp
// Display this option only for developer builds
bool shouldDrawWaitForManagedDebugger = buildWindowExtension != null?buildWindowExtension.ShouldDrawWaitForManagedDebugger() : false;
if (EditorUserBuildSettings.allowDebugging && shouldDrawWaitForManagedDebugger)
{
var buildTargetName = BuildPipeline.GetBuildTargetName(buildTarget);
bool value = EditorGUILayout.Toggle(styles.waitForManagedDebugger, EditorUserBuildSettings.GetPlatformSettings(buildTargetName, kSettingDebuggingWaitForManagedDebugger) == "true");
EditorUserBuildSettings.SetPlatformSettings(buildTargetName, kSettingDebuggingWaitForManagedDebugger, value.ToString().ToLower());
}
}
if (EditorUserBuildSettings.allowDebugging && PlayerSettings.GetScriptingBackend(buildTargetGroup) == ScriptingImplementation.IL2CPP)
{
var apiCompatibilityLevel = PlayerSettings.GetApiCompatibilityLevel(buildTargetGroup);
bool isDebuggerUsable = apiCompatibilityLevel == ApiCompatibilityLevel.NET_4_6 || apiCompatibilityLevel == ApiCompatibilityLevel.NET_Standard_2_0;
if (!isDebuggerUsable)
{
EditorGUILayout.HelpBox("Script debugging is only supported with IL2CPP on .NET 4.x and .NET Standard 2.0 API Compatibility Levels.", MessageType.Warning);
}
}
}
if (shouldDrawExplicitNullChecksToggle)
{
// Force 'ExplicitNullChecks' to true if it's a development build.
GUI.enabled = !developmentBuild;
if (GUI.enabled == false)
{
EditorUserBuildSettings.explicitNullChecks = true;
}
EditorUserBuildSettings.explicitNullChecks = EditorGUILayout.Toggle(styles.explicitNullChecks, EditorUserBuildSettings.explicitNullChecks);
// Undo force from above
GUI.enabled = developmentBuild;
}
if (shouldDrawDivideByZeroChecksToggle)
{
// Force 'explicitDivideByZeroChecks' to true if it's a development build.
GUI.enabled = !developmentBuild;
if (GUI.enabled == false)
{
EditorUserBuildSettings.explicitDivideByZeroChecks = true;
}
EditorUserBuildSettings.explicitDivideByZeroChecks = EditorGUILayout.Toggle(styles.explicitDivideByZeroChecks, EditorUserBuildSettings.explicitDivideByZeroChecks);
// Undo force from above
GUI.enabled = developmentBuild;
}
if (shouldDrawArrayBoundsChecksToggle)
{
// Force 'explicitArrayBoundsChecks' to true if it's a development build.
GUI.enabled = !developmentBuild;
if (GUI.enabled == false)
{
EditorUserBuildSettings.explicitArrayBoundsChecks = true;
}
EditorUserBuildSettings.explicitArrayBoundsChecks = EditorGUILayout.Toggle(styles.explicitArrayBoundsChecks, EditorUserBuildSettings.explicitArrayBoundsChecks);
// Undo force from above
GUI.enabled = developmentBuild;
}
if (buildWindowExtension != null && enableBuildScriptsOnly)
{
buildWindowExtension.DoScriptsOnlyGUI();
}
GUI.enabled = true;
GUILayout.FlexibleSpace();
if (postprocessor != null && postprocessor.SupportsLz4Compression())
{
var cmpIdx = Array.IndexOf(styles.compressionTypes, EditorUserBuildSettings.GetCompressionType(buildTargetGroup));
if (cmpIdx == -1)
{
cmpIdx = 1; // Lz4 by default.
}
cmpIdx = EditorGUILayout.Popup(styles.compressionMethod, cmpIdx, styles.compressionStrings);
EditorUserBuildSettings.SetCompressionType(buildTargetGroup, styles.compressionTypes[cmpIdx]);
}
canInstallInBuildFolder = Unsupported.IsSourceBuild() && PostprocessBuildPlayer.SupportsInstallInBuildFolder(buildTargetGroup, buildTarget);
if (enableBuildButton)
{
enableBuildAndRunButton = buildWindowExtension != null?buildWindowExtension.EnabledBuildAndRunButton() &&
!(EditorUserBuildSettings.installInBuildFolder) : !(EditorUserBuildSettings.installInBuildFolder);
}
}
else
{
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.BeginVertical(GUILayout.ExpandWidth(true));
GUILayout.Label(string.Format(L10n.Tr("{0} is not supported in this build.\nDownload a build that supports it."), BuildPipeline.GetBuildTargetGroupDisplayName(buildTargetGroup)));
GUILayout.EndVertical();
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
if (buildTarget == BuildTarget.Android)
{
AndroidPublishGUI();
}
GUIBuildButtons(buildWindowExtension, enableBuildButton, enableBuildAndRunButton,
canInstallInBuildFolder, platform);
}
private static void GUIBuildButtons(IBuildWindowExtension buildWindowExtension,
bool enableBuildButton,
bool enableBuildAndRunButton,
bool canInstallInBuildFolder,
BuildPlatform platform)
{
GUILayout.FlexibleSpace();
if (canInstallInBuildFolder)
{
GUILayout.BeginHorizontal();
EditorUserBuildSettings.installInBuildFolder = GUILayout.Toggle(EditorUserBuildSettings.installInBuildFolder, "Install in Builds folder\n(for debugging with source code)", GUILayout.ExpandWidth(false));
var content = new GUIContent(EditorGUI.GUIContents.helpIcon);
content.tooltip = "Open documentation for debugging source code";
if (GUILayout.Button(content, EditorStyles.iconButton))
{
var path = Path.Combine(Directory.GetParent(EditorApplication.applicationPath).FullName, "../../Documentation/BuildDocs/view_build_docs");
if (Application.platform == RuntimePlatform.WindowsEditor)
{
System.Diagnostics.Process.Start(path + ".cmd");
}
else
{
System.Diagnostics.Process.Start("/bin/bash", path);
}
}
GUILayout.EndHorizontal();
}
else
{
EditorUserBuildSettings.installInBuildFolder = false;
}
if ((buildWindowExtension != null) && Unsupported.IsSourceBuild())
{
buildWindowExtension.ShowInternalPlatformBuildOptions();
}
if (buildWindowExtension != null)
{
buildWindowExtension.ShowPlatformBuildWarnings();
}
// Disable the 'Build' and 'Build And Run' buttons when the project setup doesn't satisfy the platform requirements
if (!IsColorSpaceValid(platform) && enableBuildButton && enableBuildAndRunButton)
{
enableBuildAndRunButton = false;
enableBuildButton = false;
EditorGUILayout.HelpBox(styles.invalidColorSpaceMessage);
}
else if (!IsLightmapEncodingValid(platform) && enableBuildButton && enableBuildAndRunButton)
{
enableBuildAndRunButton = false;
enableBuildButton = false;
EditorGUILayout.HelpBox(styles.invalidLightmapEncodingMessage);
}
if (EditorApplication.isCompiling || EditorApplication.isUpdating)
{
enableBuildAndRunButton = false;
enableBuildButton = false;
EditorGUILayout.HelpBox(styles.compilingMessage);
}
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (EditorGUILayout.LinkLabel(styles.learnAboutUnityCloudBuild))
{
Application.OpenURL(string.Format("{0}/from/editor/buildsettings?upid={1}&pid={2}¤tplatform={3}&selectedplatform={4}&unityversion={5}",
UnityEditorInternal.WebURLs.cloudBuildPage, CloudProjectSettings.projectId, PlayerSettings.productGUID, EditorUserBuildSettings.activeBuildTarget, EditorUserBuildSettingsUtils.CalculateSelectedBuildTarget(), Application.unityVersion));
}
GUILayout.EndHorizontal();
// Space 6 for alignment with platform column and to reduce missclicks with Build And Run button
GUILayout.Space(6);
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUIContent buildButton = null;
GUIContent buildAndRunButton = null;
bool askForBuildLocation = true;
if (buildWindowExtension != null)
{
buildWindowExtension.GetBuildButtonTitles(out buildButton, out buildAndRunButton);
askForBuildLocation = buildWindowExtension.AskForBuildLocation();
}
buildButton = buildButton ?? styles.build;
buildAndRunButton = buildAndRunButton ?? styles.buildAndRun;
// Switching build target in the editor
BuildTarget selectedTarget = EditorUserBuildSettingsUtils.CalculateSelectedBuildTarget();
BuildTargetGroup selectedTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
bool selectedTargetIsActive = EditorUserBuildSettings.activeBuildTarget == selectedTarget &&
EditorUserBuildSettings.activeBuildTargetGroup == selectedTargetGroup;
if (selectedTargetIsActive)
{
// Build Button
GUI.enabled = enableBuildButton;
if (GUILayout.Button(buildButton, GUILayout.Width(Styles.kButtonWidth)))
{
CallBuildMethods(askForBuildLocation, BuildOptions.ShowBuiltPlayer);
GUIUtility.ExitGUI();
}
}
else
{
GUI.enabled = BuildPipeline.IsBuildTargetSupported(selectedTargetGroup, selectedTarget) && EditorUserBuildSettings.activeBuildTargetGroup != selectedTargetGroup;
if (GUILayout.Button(styles.switchPlatform, GUILayout.Width(Styles.kButtonWidth)))
{
EditorUserBuildSettings.SwitchActiveBuildTargetAsync(selectedTargetGroup, selectedTarget);
GUIUtility.ExitGUI();
}
}
// Build and Run button
GUI.enabled = enableBuildAndRunButton && selectedTargetIsActive;
if (GUILayout.Button(buildAndRunButton, GUILayout.Width(Styles.kButtonWidth)))
{
BuildPlayerAndRun(askForBuildLocation);
GUIUtility.ExitGUI();
}
GUILayout.EndHorizontal();
}
internal static BuildPlayerOptions GetBuildPlayerOptionsInternal(bool askForBuildLocation, BuildPlayerOptions defaultBuildPlayerOptions)
{
var options = defaultBuildPlayerOptions;
bool updateExistingBuild = false;
BuildTarget buildTarget = EditorUserBuildSettingsUtils.CalculateSelectedBuildTarget();
BuildTargetGroup buildTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
// Pick location for the build
string newLocation = "";
//Check if Lz4 is supported for the current buildtargetgroup and enable it if need be
if (PostprocessBuildPlayer.SupportsLz4Compression(buildTargetGroup, buildTarget))
{
var compression = EditorUserBuildSettings.GetCompressionType(buildTargetGroup);
if (compression < 0)
{
compression = PostprocessBuildPlayer.GetDefaultCompression(buildTargetGroup, buildTarget);
}
if (compression == Compression.Lz4)
{
options.options |= BuildOptions.CompressWithLz4;
}
else if (compression == Compression.Lz4HC)
{
options.options |= BuildOptions.CompressWithLz4HC;
}
}
bool developmentBuild = EditorUserBuildSettings.development;
if (developmentBuild)
{
options.options |= BuildOptions.Development;
}
if (EditorUserBuildSettings.allowDebugging && developmentBuild)
{
options.options |= BuildOptions.AllowDebugging;
}
if (EditorUserBuildSettings.symlinkLibraries)
{
options.options |= BuildOptions.SymlinkLibraries;
}
if (EditorUserBuildSettings.enableHeadlessMode)
{
options.options |= BuildOptions.EnableHeadlessMode;
}
if (EditorUserBuildSettings.connectProfiler && (developmentBuild || buildTarget == BuildTarget.WSAPlayer))
{
options.options |= BuildOptions.ConnectWithProfiler;
}
if (EditorUserBuildSettings.buildWithDeepProfilingSupport && developmentBuild)
{
options.options |= BuildOptions.EnableDeepProfilingSupport;
}
if (EditorUserBuildSettings.buildScriptsOnly)
{
options.options |= BuildOptions.BuildScriptsOnly;
}
if (IsInstallInBuildFolderOption())
{
options.options |= BuildOptions.InstallInBuildFolder;
}
else
{
if (askForBuildLocation && !PickBuildLocation(buildTargetGroup, buildTarget, options.options, out updateExistingBuild))
{
throw new BuildMethodException();
}
newLocation = EditorUserBuildSettings.GetBuildLocation(buildTarget);
if (newLocation.Length == 0)
{
throw new BuildMethodException("Build location for buildTarget " + buildTarget + "is not valid.");
}
if (!askForBuildLocation)
{
switch (UnityEditorInternal.InternalEditorUtility.BuildCanBeAppended(buildTarget, newLocation))
{
case CanAppendBuild.Unsupported:
break;
case CanAppendBuild.Yes:
updateExistingBuild = true;
break;
case CanAppendBuild.No:
if (!PickBuildLocation(buildTargetGroup, buildTarget, options.options, out updateExistingBuild))
{
throw new BuildMethodException();
}
newLocation = EditorUserBuildSettings.GetBuildLocation(buildTarget);
if (!BuildLocationIsValid(newLocation))
{
throw new BuildMethodException("Build location for buildTarget " + buildTarget + "is not valid.");
}
break;
}
}
}
if (updateExistingBuild)
{
options.options |= BuildOptions.AcceptExternalModificationsToPlayer;
}
options.target = buildTarget;
options.targetGroup = buildTargetGroup;
options.locationPathName = EditorUserBuildSettings.GetBuildLocation(buildTarget);
options.assetBundleManifestPath = null;
// Build a list of scenes that are enabled
ArrayList scenesList = new ArrayList();
EditorBuildSettingsScene[] editorScenes = EditorBuildSettings.scenes;
foreach (EditorBuildSettingsScene scene in editorScenes)
{
if (scene.enabled)
{
scenesList.Add(scene.path);
}
}
options.scenes = scenesList.ToArray(typeof(string)) as string[];
return(options);
}
private static bool PickBuildLocation(BuildTargetGroup targetGroup, BuildTarget target, BuildOptions options, out bool updateExistingBuild)
{
updateExistingBuild = false;
var previousPath = EditorUserBuildSettings.GetBuildLocation(target);
string defaultFolder;
string defaultName;
if (previousPath == String.Empty)
{
defaultFolder = FileUtil.DeleteLastPathNameComponent(Application.dataPath);
defaultName = "";
}
else
{
defaultFolder = FileUtil.DeleteLastPathNameComponent(previousPath);
defaultName = FileUtil.GetLastPathNameComponent(previousPath);
}
string extension = PostprocessBuildPlayer.GetExtensionForBuildTarget(targetGroup, target, options);
// Invalidate default name, if extension mismatches the default file (for ex., when switching between folder type export to file type export, see Android)
if (extension != Path.GetExtension(defaultName).Replace(".", ""))
{
defaultName = string.Empty;
}
// Hack: For Windows Standalone, we want the BuildPanel to choose a folder,
// but we don't want BuildPlayer to take a folder path because historically it took an .exe path
// and we would be breaking tons of projects!
bool isWindowsStandalone = target == BuildTarget.StandaloneWindows || target == BuildTarget.StandaloneWindows64;
string realExtension = extension;
if (isWindowsStandalone)
{
extension = string.Empty;
// Remove the filename.exe part from the path
if (!string.IsNullOrEmpty(defaultName))
{
defaultName = Path.GetDirectoryName(defaultName);
}
}
string title = "Build " + BuildPlatforms.instance.GetBuildTargetDisplayName(targetGroup, target);
string path = EditorUtility.SaveBuildPanel(target, title, defaultFolder, defaultName, extension, out updateExistingBuild);
if (path == string.Empty)
{
return(false);
}
if (isWindowsStandalone)
{
extension = realExtension;
path = Path.Combine(path, Paths.MakeValidFileName(PlayerSettings.productName) + '.' + extension);
}
if (!IsBuildPathValid(path))
{
return(false);
}
// Enforce extension if needed
if (extension != string.Empty && FileUtil.GetPathExtension(path).ToLower() != extension)
{
path += '.' + extension;
}
// A path may not be empty initially, but it could contain, e.g., a drive letter (as in Windows),
// so even appending an extension will work fine, but in reality the name will be, for example,
// G:/
//Debug.Log(path);
string currentlyChosenName = FileUtil.GetLastPathNameComponent(path);
if (currentlyChosenName == string.Empty)
{
return(false); // No nameless projects, please
}
// We don't want to re-create a directory that already exists, this may
// result in access-denials that will make users unhappy.
string check_dir = extension != string.Empty ? FileUtil.DeleteLastPathNameComponent(path) : path;
if (!Directory.Exists(check_dir))
{
Directory.CreateDirectory(check_dir);
}
// On OSX we've got replace/update dialog, for other platforms warn about deleting
// files in target folder.
if ((target == BuildTarget.iOS) && (Application.platform != RuntimePlatform.OSXEditor))
{
if (!FolderIsEmpty(path) && !UserWantsToDeleteFiles(path))
{
return(false);
}
}
EditorUserBuildSettings.SetBuildLocation(target, path);
return(true);
}
public static AssetBundleManifest BuildAssetBundles(string outputPath, BuildAssetBundleOptions assetBundleOptions, BuildTarget targetPlatform)
{
BuildTargetGroup targetPlatformGroup = BuildPipeline.GetBuildTargetGroup(targetPlatform);
return(BuildAssetBundles(outputPath, assetBundleOptions, targetPlatformGroup, targetPlatform, EditorUserBuildSettings.GetActiveSubtargetFor(targetPlatform)));
}
/// <summary>
/// Default implementation of the build player method.
/// </summary>
/// <param name="options"></param>
public static void BuildPlayer(BuildPlayerOptions options)
{
if (!UnityConnect.instance.canBuildWithUPID)
{
if (!EditorUtility.DisplayDialog("Missing Project ID", "Because you are not a member of this project this build will not access Unity services.\nDo you want to continue?", "Yes", "No"))
{
throw new BuildMethodException();
}
}
if (!BuildPipeline.IsBuildTargetSupported(options.targetGroup, options.target))
{
throw new BuildMethodException("Build target is not supported.");
}
string module = ModuleManager.GetTargetStringFrom(EditorUserBuildSettings.selectedBuildTargetGroup, options.target);
IBuildWindowExtension buildWindowExtension = ModuleManager.GetBuildWindowExtension(module);
if (buildWindowExtension != null && (options.options & BuildOptions.AutoRunPlayer) != 0 && !buildWindowExtension.EnabledBuildAndRunButton())
{
throw new BuildMethodException();
}
if (Unsupported.IsBleedingEdgeBuild())
{
var sb = new System.Text.StringBuilder();
sb.AppendLine("This version of Unity is a BleedingEdge build that has not seen any manual testing.");
sb.AppendLine("You should consider this build unstable.");
sb.AppendLine("We strongly recommend that you use a normal version of Unity instead.");
if (EditorUtility.DisplayDialog("BleedingEdge Build", sb.ToString(), "Cancel", "OK"))
{
throw new BuildMethodException();
}
}
// See if we need to switch platforms and delay the build. We do this whenever
// we're trying to build for a target different from the active one so as to ensure
// that the compiled script code we have loaded is built for the same platform we
// are building for. As we can't reload while our editor stuff is still executing,
// we need to defer to after the next script reload then.
bool delayToAfterScriptReload = false;
if (EditorUserBuildSettings.activeBuildTarget != options.target ||
EditorUserBuildSettings.activeBuildTargetGroup != options.targetGroup)
{
if (!EditorUserBuildSettings.SwitchActiveBuildTargetAsync(options.targetGroup, options.target))
{
// Switching the build target failed. No point in trying to continue
// with a build.
var errStr = string.Format("Could not switch to build target '{0}', '{1}'.",
BuildPipeline.GetBuildTargetGroupDisplayName(options.targetGroup),
BuildPlatforms.instance.GetBuildTargetDisplayName(options.targetGroup, options.target));
throw new BuildMethodException(errStr);
}
if (EditorApplication.isCompiling)
{
delayToAfterScriptReload = true;
}
}
bool locationPathExistedBeforeBuild = System.IO.Directory.Exists(options.locationPathName);
// Trigger build.
// Note: report will be null, if delayToAfterScriptReload = true
var report = BuildPipeline.BuildPlayerInternalNoCheck(options.scenes, options.locationPathName, null, options.targetGroup, options.target, options.options, options.extraScriptingDefines, delayToAfterScriptReload);
if (report != null)
{
var resultStr = String.Format("Build completed with a result of '{0}' in {1} seconds ({2} ms)",
report.summary.result.ToString("g"),
Convert.ToInt32(report.summary.totalTime.TotalSeconds),
Convert.ToInt32(report.summary.totalTime.TotalMilliseconds));
switch (report.summary.result)
{
case Build.Reporting.BuildResult.Unknown:
Debug.LogWarning(resultStr);
break;
case Build.Reporting.BuildResult.Failed:
// On some platforms the user creates the build folder, therefore they own the folder and
// it should not be automatically deleted by the Unity Editor, even if it is empty (case 1073851)
if (options.target != BuildTarget.XboxOne && !locationPathExistedBeforeBuild)
{
DeleteBuildFolderIfEmpty(report.summary.outputPath);
}
Debug.LogError(resultStr);
throw new BuildMethodException(report.SummarizeErrors());
default:
Debug.Log(resultStr);
break;
}
buildCompletionHandler?.Invoke(report);
}
}
public static string BuildStreamedSceneAssetBundle(string[] levels, string locationPath, BuildTarget target, out uint crc, BuildOptions options)
{
BuildTargetGroup buildTargetGroup = BuildPipeline.GetBuildTargetGroup(target);
return(BuildStreamedSceneAssetBundle(levels, locationPath, buildTargetGroup, target, EditorUserBuildSettings.GetActiveSubtargetFor(target), out crc, options));
}
public static bool BuildAssetBundleExplicitAssetNames(UnityEngine.Object[] assets, string[] assetNames, string pathName, out uint crc, BuildAssetBundleOptions assetBundleOptions, BuildTarget targetPlatform)
{
BuildTargetGroup targetPlatformGroup = BuildPipeline.GetBuildTargetGroup(targetPlatform);
return(BuildAssetBundleExplicitAssetNames(assets, assetNames, pathName, out crc, assetBundleOptions, targetPlatformGroup, targetPlatform, EditorUserBuildSettings.GetActiveSubtargetFor(targetPlatform)));
}
public static bool SwitchActiveBuildTarget(BuildTarget target)
{
return(EditorUserBuildSettings.SwitchActiveBuildTarget(BuildPipeline.GetBuildTargetGroup(target), target));
}
public static string GetPlatformSettings(string platformName, string name)
{
string buildTargetGroupName = BuildPipeline.GetBuildTargetGroupName(BuildPipeline.GetBuildTargetByName(platformName));
return(EditorUserBuildSettings.GetPlatformSettings(buildTargetGroupName, platformName, name));
}
public static void SetPlatformSettings(string platformName, string name, string value)
{
string buildTargetGroupName = BuildPipeline.GetBuildTargetGroupName(BuildPipeline.GetBuildTargetByName(platformName));
EditorUserBuildSettings.SetPlatformSettings(buildTargetGroupName, platformName, name, value);
}
internal static void SetCompressionType(BuildTargetGroup targetGroup, Compression type)
{
EditorUserBuildSettings.SetCompressionTypeInternal(targetGroup, (int)type);
}
internal static Compression GetCompressionType(BuildTargetGroup targetGroup)
{
return((Compression)EditorUserBuildSettings.GetCompressionTypeInternal(targetGroup));
}