private static BuildOptions ConfigurePlatform(BuildTarget target, BuildOptions options)
{
var headlessSupported = BuildSupportChecker.CanBuildHeadless(target);
if (EditorGUILayout.Toggle("Development", options.HasFlag(BuildOptions.Development)))
{
options |= BuildOptions.Development;
}
else
{
// When the `Development flag` is disabled, we also disable the 'Allow Debug' flag to
// ensure consistency between UI and BuildOptions flags
options &= ~(BuildOptions.Development | BuildOptions.AllowDebugging);
}
options = ConfigureDebug(options);
if (headlessSupported &&
EditorGUILayout.Toggle("Server build", options.HasFlag(BuildOptions.EnableHeadlessMode)))
{
options |= BuildOptions.EnableHeadlessMode;
}
else
{
options &= ~BuildOptions.EnableHeadlessMode;
}
return(options);
}
public static List <BuildContext> GetBuildContexts(IEnumerable <string> wantedWorkerTypes,
BuildEnvironment buildEnvironment, ScriptingImplementation?scriptImplementation = null,
ICollection <BuildTarget> buildTargetFilter = null, iOSSdkVersion?iosSdkVersion = null)
{
var spatialOsBuildConfiguration = BuildConfig.GetInstance();
var result = new List <BuildContext>();
foreach (var workerType in wantedWorkerTypes)
{
var environmentConfig =
spatialOsBuildConfiguration.GetEnvironmentConfigForWorker(workerType, buildEnvironment);
// Filter targets for CI
var targetConfigs = environmentConfig.BuildTargets
.Where(t => t.Enabled && (buildTargetFilter?.Contains(t.Target) ?? true))
.ToList();
// Filter out any deprecated targets
var supportedTargets = targetConfigs
.Where(c => !c.Deprecated)
.ToList();
// Which build targets are not supported by current install?
var missingTargets = supportedTargets
.Where(c => !BuildSupportChecker.CanBuildTarget(c.Target))
.ToList();
// Error on missing required build support
if (missingTargets.Any(c => c.Required))
{
var targetNames = string.Join(", ", missingTargets
.Where(c => c.Required)
.Select(c => c.Target.ToString()));
throw new BuildFailedException(
$"Build failed for {workerType}. Cannot build for required ({targetNames}) because build support is not installed in the Unity Editor.");
}
// Log builds we're skipping
if (missingTargets.Count > 0)
{
var targetNames = string.Join(", ", missingTargets.Select(c => c.Target.ToString()));
Debug.LogWarning(
$"Skipping ({targetNames}) because build support is not installed in the Unity Editor and the build target is not marked as 'Required'.");
supportedTargets.RemoveAll(t => missingTargets.Contains(t));
}
result.AddRange(supportedTargets.Select(targetConfig => new BuildContext
{
WorkerType = workerType,
BuildEnvironment = buildEnvironment,
ScriptingImplementation = scriptImplementation ?? targetConfig.ScriptingImplementation,
BuildTargetConfig = targetConfig,
IOSSdkVersion = (targetConfig.Target == BuildTarget.iOS) ? iosSdkVersion : null
}));
}
return(result);
}
/// <summary>
/// Build method that is invoked by commandline
/// </summary>
// ReSharper disable once UnusedMember.Global
public static void Build()
{
try
{
var commandLine = Environment.GetCommandLineArgs();
var buildTargetArg = CommandLineUtility.GetCommandLineValue(commandLine, "buildTarget", "local");
BuildEnvironment buildEnvironment;
switch (buildTargetArg.ToLower())
{
case "cloud":
buildEnvironment = BuildEnvironment.Cloud;
break;
case "local":
buildEnvironment = BuildEnvironment.Local;
break;
default:
throw new BuildFailedException("Unknown build target value: " + buildTargetArg);
}
var workerTypesArg =
CommandLineUtility.GetCommandLineValue(commandLine, BuildWorkerTypes,
"UnityClient,UnityGameLogic");
var wantedWorkerTypes = workerTypesArg.Split(',');
foreach (var wantedWorkerType in wantedWorkerTypes)
{
var buildTargetsForWorker = GetBuildTargetsForWorkerForEnvironment(wantedWorkerType, buildEnvironment);
var buildTargetsMissingBuildSupport = BuildSupportChecker.GetBuildTargetsMissingBuildSupport(buildTargetsForWorker);
if (buildTargetsMissingBuildSupport.Length > 0)
{
throw new BuildFailedException(BuildSupportChecker.ConstructMissingSupportMessage(wantedWorkerType, buildEnvironment, buildTargetsMissingBuildSupport));
}
}
LocalLaunch.BuildConfig();
foreach (var wantedWorkerType in wantedWorkerTypes)
{
BuildWorkerForEnvironment(wantedWorkerType, buildEnvironment);
}
}
catch (Exception e)
{
Debug.LogException(e);
if (e is BuildFailedException)
{
throw;
}
throw new BuildFailedException(e);
}
}
private void ConfigureBuildPlatforms(BuildEnvironmentConfig environmentConfiguration)
{
using (IndentLevelScope(1))
{
EditorGUI.BeginChangeCheck();
var buildPlatformsString = SelectedPlatformsToString(environmentConfiguration.BuildPlatforms);
var newBuildPlatforms = environmentConfiguration.BuildPlatforms;
var showBuildPlatforms = EditorGUILayout.Foldout(environmentConfiguration.ShowBuildPlatforms,
"Build Platforms: " + buildPlatformsString);
if (showBuildPlatforms)
{
newBuildPlatforms = EnumFlagsToggleField(environmentConfiguration.BuildPlatforms);
}
var currentAdjustedPlatforms = newBuildPlatforms;
if ((currentAdjustedPlatforms & SpatialBuildPlatforms.Current) != 0)
{
currentAdjustedPlatforms |= WorkerBuilder.GetCurrentBuildPlatform();
}
if ((currentAdjustedPlatforms & SpatialBuildPlatforms.Windows32) != 0 &&
(currentAdjustedPlatforms & SpatialBuildPlatforms.Windows64) != 0)
{
EditorGUILayout.HelpBox(WorkerBuilder.IncompatibleWindowsPlatformsErrorMessage,
MessageType.Error);
}
var buildTargetsMissingBuildSupport = BuildSupportChecker.GetBuildTargetsMissingBuildSupport(WorkerBuilder.GetUnityBuildTargets(newBuildPlatforms));
if (buildTargetsMissingBuildSupport.Length > 0)
{
EditorGUILayout.HelpBox($"Missing build support for {string.Join(", ", buildTargetsMissingBuildSupport)}", MessageType.Error);
}
if (EditorGUI.EndChangeCheck())
{
EditorUtility.SetDirty(target);
Undo.RecordObject(target, "Configure build platforms for worker");
environmentConfiguration.ShowBuildPlatforms = showBuildPlatforms;
environmentConfiguration.BuildPlatforms = newBuildPlatforms;
}
}
}
public IEnumerable <BuildTargetConfig> GetSupportedTargets(BuildContextSettings contextSettings)
{
// Filter targets for CI
var targetConfigs = BuildTargets
.Where(t => t.Enabled && contextSettings.Matches(t.Target))
.ToList();
// Filter out any deprecated targets
var supportedTargets = targetConfigs
.Where(c => !c.Deprecated)
.ToList();
// Which build targets are not supported by current install?
var missingTargets = supportedTargets
.Where(c => !BuildSupportChecker.CanBuildTarget(c.Target))
.ToList();
// Error on missing required build support
if (missingTargets.Any(c => c.Required))
{
var targetNames = string.Join(", ", missingTargets
.Where(c => c.Required)
.Select(c => c.Target.ToString()));
throw new BuildFailedException($"Cannot build for required ({targetNames}) because build support is not installed in the Unity Editor.");
}
// Log builds we're skipping
if (missingTargets.Count > 0)
{
var targetNames = string.Join(", ", missingTargets.Select(c => c.Target.ToString()));
Debug.LogWarning(
$"Skipping ({targetNames}) because build support is not installed in the Unity Editor and the build target is not marked as 'Required'.");
supportedTargets.RemoveAll(t => missingTargets.Contains(t));
}
return(supportedTargets);
}
/// <summary>
/// Create a new instance of BuildEnvironmentConfig.
/// </summary>
/// <param name="availableTargets">All of the targets that can be built in this environment.</param>
/// <param name="targets">
/// A list of configured targets. If a target is present in <paramref name="availableTargets" /> but
/// is not in <paramref name="targets" />, then it will have the default settings the final list of build targets.
/// </param>
public BuildEnvironmentConfig(IEnumerable <BuildTarget> availableTargets, params BuildTargetConfig[] targets)
{
BuildTargets = new List <BuildTargetConfig>();
foreach (var available in availableTargets)
{
var overridden = targets.FirstOrDefault(t => t.Target == available);
if (overridden.Target == available)
{
BuildTargets.Add(overridden);
}
else
{
BuildTargets.Add(new BuildTargetConfig(available)
{
Options = WorkerBuildData.BuildTargetDefaultOptions[available],
Enabled = false,
Required = false,
Deprecated = BuildSupportChecker.IsDeprecatedTarget(available)
});
}
}
}
private static bool IsBuildTargetError(BuildTargetConfig t)
{
return(!BuildSupportChecker.CanBuildTarget(t.Target) && t.Required);
}
private static bool IsBuildTargetWarning(BuildTargetConfig t)
{
return(!BuildSupportChecker.CanBuildTarget(t.Target) && t.Enabled);
}
private void DrawBuildTargets(BuildEnvironmentConfig env, int hash)
{
// Init cached UI state.
var selectedBuildTarget = stateManager.GetStateObjectOrDefault <BuildTargetState>(hash ^ typeof(BuildTargetState).GetHashCode());
if (selectedBuildTarget.Choices == null || invalidateCachedContent > 0)
{
selectedBuildTarget.Choices = env.BuildTargets.Select(GetBuildTargetGuiContents).ToArray();
}
// Draw available build targets.
using (new EditorGUIUtility.IconSizeScope(SmallIconSize))
{
selectedBuildTarget.Index =
GUILayout.Toolbar(selectedBuildTarget.Index, selectedBuildTarget.Choices);
}
// Draw selected build target.
var buildTarget = env.BuildTargets[selectedBuildTarget.Index];
var canBuildTarget = BuildSupportChecker.CanBuildTarget(buildTarget.Target);
var options = buildTarget.Options;
var enabled = buildTarget.Enabled;
var required = buildTarget.Required;
using (var check = new EditorGUI.ChangeCheckScope())
using (new EditorGUILayout.VerticalScope(GUILayout.ExpandWidth(true)))
{
BuildConfigEditorStyle.DrawHorizontalLine();
EditorGUILayout.Space();
enabled = EditorGUILayout.Toggle("Build", enabled);
if (!enabled)
{
required = false;
}
using (new EditorGUI.DisabledScope(!buildTarget.Enabled))
{
required = EditorGUILayout.Toggle("Required", required);
switch (buildTarget.Target)
{
case BuildTarget.StandaloneOSX:
options = ConfigureOSX(buildTarget);
break;
case BuildTarget.StandaloneWindows:
options = ConfigureWindows(buildTarget);
break;
case BuildTarget.iOS:
options = ConfigureIOS(buildTarget);
break;
case BuildTarget.Android:
options = ConfigureAndroid(buildTarget);
break;
case BuildTarget.StandaloneWindows64:
options = ConfigureWindows(buildTarget);
break;
case BuildTarget.StandaloneLinux64:
options = ConfigureLinux(buildTarget);
break;
}
options = ConfigureCompression(options);
}
if (!canBuildTarget)
{
EditorGUILayout.HelpBox(
$"Your Unity Editor is missing build support for {buildTarget.Target.ToString()}.\n" +
"Please add the missing build support options to your Unity Editor",
buildTarget.Required ? MessageType.Error : MessageType.Warning);
}
if (check.changed)
{
RecordUndo("Worker build options");
env.BuildTargets[selectedBuildTarget.Index] =
new BuildTargetConfig(buildTarget.Target, options, enabled, required);
selectedBuildTarget.Choices = null;
}
}
}
/// <summary>
/// Build method that is invoked by commandline
/// </summary>
// ReSharper disable once UnusedMember.Global
public static void Build()
{
try
{
var commandLine = Environment.GetCommandLineArgs();
var buildTargetArg = CommandLineUtility.GetCommandLineValue(commandLine, "buildTarget", "local");
BuildEnvironment buildEnvironment;
switch (buildTargetArg.ToLower())
{
case "cloud":
buildEnvironment = BuildEnvironment.Cloud;
break;
case "local":
buildEnvironment = BuildEnvironment.Local;
break;
default:
throw new BuildFailedException("Unknown build target value: " + buildTargetArg);
}
var workerTypesArg =
CommandLineUtility.GetCommandLineValue(commandLine, BuildWorkerTypes,
"UnityClient,UnityGameLogic");
var desiredWorkerTypes = workerTypesArg.Split(',');
var filteredWorkerTypes = BuildSupportChecker.FilterWorkerTypes(buildEnvironment, desiredWorkerTypes);
if (desiredWorkerTypes.Length != filteredWorkerTypes.Length)
{
throw new BuildFailedException(
"Unable to complete build. Missing build support. Check logs for specific errors.");
}
ScriptingImplementation scriptingBackend;
var wantedScriptingBackend =
CommandLineUtility.GetCommandLineValue(commandLine, "scriptingBackend", "mono");
switch (wantedScriptingBackend)
{
case "mono":
scriptingBackend = ScriptingImplementation.Mono2x;
break;
case "il2cpp":
scriptingBackend = ScriptingImplementation.IL2CPP;
break;
default:
throw new BuildFailedException("Unknown scripting backend value: " + wantedScriptingBackend);
}
LocalLaunch.BuildConfig();
foreach (var wantedWorkerType in filteredWorkerTypes)
{
BuildWorkerForEnvironment(wantedWorkerType, buildEnvironment, scriptingBackend);
}
}
catch (Exception e)
{
Debug.LogException(e);
if (e is BuildFailedException)
{
throw;
}
throw new BuildFailedException(e);
}
}
private void DrawBuildTargets(BuildEnvironmentConfig env, int hash)
{
// Build a mapping from the 'build target' position in the toolbar to it's position in the 'BuildTargets' array.
// We do this since sometimes there are different number of targets in the BuildTargets array and those
// in the toolbar as some targets are deprecated
if (toolbarMapping.Count == 0)
{
var toolbarIndex = 0;
for (var buildTargetIndex = 0; buildTargetIndex < env.BuildTargets.Count; buildTargetIndex++)
{
if (!env.BuildTargets[buildTargetIndex].Deprecated)
{
toolbarMapping.Add(toolbarIndex++, buildTargetIndex);
}
}
}
// Init cached UI state.
var selectedBuildTarget = stateManager.GetStateObjectOrDefault <BuildTargetState>(hash ^ typeof(BuildTargetState).GetHashCode());
if (selectedBuildTarget.Choices == null || invalidateCachedContent > 0)
{
selectedBuildTarget.Choices = env.BuildTargets
.Where(c => !c.Deprecated)
.Select(GetBuildTargetGuiContents)
.ToArray();
}
// Draw available build targets.
using (new EditorGUIUtility.IconSizeScope(SmallIconSize))
{
selectedBuildTarget.Index =
GUILayout.Toolbar(selectedBuildTarget.Index, selectedBuildTarget.Choices);
}
// Convert the index from the position selected in the toolbar to the position in the BuildTargets array
var selectedTargetIndex = toolbarMapping[selectedBuildTarget.Index];
// Draw selected build target.
var buildTarget = env.BuildTargets[selectedTargetIndex];
var canBuildTarget = BuildSupportChecker.CanBuildTarget(buildTarget.Target);
var options = buildTarget.Options;
var enabled = buildTarget.Enabled;
var required = buildTarget.Required;
// Pick the current backend based on the current build target
var scriptingImplementation = buildTarget.ScriptingImplementation;
using (var check = new EditorGUI.ChangeCheckScope())
using (new EditorGUILayout.VerticalScope(GUILayout.ExpandWidth(true)))
{
BuildConfigEditorStyle.DrawHorizontalLine();
EditorGUILayout.Space();
enabled = EditorGUILayout.Toggle("Build", enabled);
if (!enabled)
{
required = false;
}
using (new EditorGUI.DisabledScope(!buildTarget.Enabled))
{
required = EditorGUILayout.Toggle("Required", required);
options = ConfigurePlatform(buildTarget.Target, options);
options = ConfigureCompression(options);
scriptingImplementation = ConfigureScriptingImplementation(scriptingImplementation, buildTarget.Target);
}
if (!canBuildTarget)
{
EditorGUILayout.HelpBox(
$"Your Unity Editor is missing build support for {buildTarget.Target.ToString()}.\n" +
"Please add the missing build support options to your Unity Editor",
buildTarget.Required ? MessageType.Error : MessageType.Warning);
}
if (check.changed)
{
RecordUndo("Worker build options");
env.BuildTargets[selectedTargetIndex] =
new BuildTargetConfig(buildTarget.Target, options, enabled, required, deprecated: false, scriptingImplementation);
selectedBuildTarget.Choices = null;
}
}
}
