internal static BuildTarget CalculateSelectedBuildTarget(NamedBuildTarget namedBuildTarget)
{
if (namedBuildTarget.ToBuildTargetGroup() == BuildTargetGroup.Standalone)
{
BuildTarget target = EditorUserBuildSettings.selectedStandaloneTarget;
if (target == BuildTarget.NoTarget)
{
target = EditorUserBuildSettings.activeBuildTarget;
}
return(DesktopStandaloneBuildWindowExtension.GetBestStandaloneTarget(target));
}
else
{
if (BuildPlatforms.instance == null)
{
throw new System.Exception("Build platforms are not initialized.");
}
BuildPlatform platform = BuildPlatforms.instance.BuildPlatformFromNamedBuildTarget(namedBuildTarget);
if (platform == null)
{
throw new System.Exception("Could not find build platform for target group " + namedBuildTarget.TargetName);
}
return(platform.defaultTarget);
}
}
public override string PrepareForBuild(BuildOptions options, BuildTarget target)
{
var namedBuildTarget = NamedBuildTarget.FromActiveSettings(target);
var isServer = namedBuildTarget == NamedBuildTarget.Server;
switch (PlayerSettings.GetScriptingBackend(namedBuildTarget))
{
case ScriptingImplementation.Mono2x:
if ((!isServer && !m_HasMonoPlayers) || (isServer && !m_HasServerMonoPlayers))
{
return("Currently selected scripting backend (Mono) is not installed.");
}
break;
case ScriptingImplementation.IL2CPP:
if ((!isServer && !m_HasIl2CppPlayers) || (isServer && !m_HasServerIl2CppPlayers))
{
return("Currently selected scripting backend (IL2CPP) is not installed.");
}
break;
#pragma warning disable 618
case ScriptingImplementation.CoreCLR:
if ((!isServer && !m_HasCoreCLRPlayers) || (isServer && !m_HasServerCoreCLRPlayers))
{
return("Currently selected scripting backend (CoreCLR) is not installed.");
}
break;
default:
return($"Unknown scripting backend: {PlayerSettings.GetScriptingBackend(namedBuildTarget)}");
}
return(base.PrepareForBuild(options, target));
}
public BaseIl2CppPlatformProvider(BuildTarget target, string libraryFolder, BuildReport buildReport,
string baselibLibraryDirectory)
{
this.target = target;
this.namedBuildTarget = NamedBuildTarget.FromActiveSettings(target);
this.libraryFolder = libraryFolder;
this.buildReport = buildReport;
_baselibLibraryDirectory = baselibLibraryDirectory;
}
public static bool IsSelected(this BuildPlatform buildPlatform)
{
// This is the special case for Editor target selected in the UI
if (EditorUserBuildSettings.selectedBuildTargetGroup == BuildTargetGroup.Unknown)
{
return(buildPlatform.namedBuildTarget == NamedBuildTarget.FromBuildTargetGroup(BuildTargetGroup.Unknown));
}
return(buildPlatform.namedBuildTarget == CalculateSelectedNamedBuildTarget());
}
internal static IScriptingImplementations GetScriptingImplementations(NamedBuildTarget namedBuildTarget)
{
// Standalone Windows, Linux and OS X share player settings between each other, so they share scripting implementations too
// However, since we can't pin BuildTargetGroup to any single platform support module, we have to explicitly check for this case
if (namedBuildTarget.ToBuildTargetGroup() == BuildTargetGroup.Standalone)
{
return(new DesktopStandalonePostProcessor.ScriptingImplementations());
}
return(GetScriptingImplementations(GetTargetStringFromBuildTargetGroup(namedBuildTarget.ToBuildTargetGroup())));
}
static void SetBuildNumber(BuildTargetGroup targetGroup, string buildNumber)
{
if (_setBuildNumber == null)
{
return;
}
#if UNITY_2021_2_OR_NEWER
var targetName = NamedBuildTarget.FromBuildTargetGroup(targetGroup).TargetName;
_setBuildNumber.Invoke(null, new object[] { targetName, buildNumber });
#else
_setBuildNumber.Invoke(null, new object[] { targetGroup, buildNumber });
#endif
}
static string GetBuildNumber(BuildTargetGroup targetGroup)
{
if (_getBuildNumber == null)
{
return(null);
}
#if UNITY_2021_2_OR_NEWER
var targetName = NamedBuildTarget.FromBuildTargetGroup(targetGroup).TargetName;
return((string)_getBuildNumber.Invoke(null, new object[] { targetName }));
#else
return((string)_getBuildNumber.Invoke(null, new object[] { targetGroup }));
#endif
}
public static List <string> GetStaticSearchPaths(BuildTarget buildTarget)
{
var unityAssembliesInternal =
EditorCompilationInterface.Instance.PrecompiledAssemblyProvider.GetUnityAssemblies(true, buildTarget);
var namedBuildTarget = NamedBuildTarget.FromActiveSettings(buildTarget);
var systemReferenceDirectories =
MonoLibraryHelpers.GetSystemReferenceDirectories(
PlayerSettings.GetApiCompatibilityLevel(namedBuildTarget));
var searchPaths = unityAssembliesInternal.Select(x => Path.GetDirectoryName(x.Path))
.Distinct().ToList();
searchPaths.AddRange(systemReferenceDirectories);
return(searchPaths);
}
internal PlatformIcon[] GetPlatformIcons(BuildTargetGroup platform, PlatformIconKind kind, ref BuildTargetIcons[] allIcons)
{
var namedBuildTarget = NamedBuildTarget.FromBuildTargetGroup(platform);
var serializedIcons = PlayerSettings.GetPlatformIconsFromTargetIcons(namedBuildTarget.TargetName, kind.kind, allIcons);
var provider = PlayerSettings.GetPlatformIconProvider(namedBuildTarget);
if (m_RequiredIcons == null)
{
m_RequiredIcons = new Dictionary <PlatformIconKind, PlatformIcon[]>();
}
if (!m_RequiredIcons.ContainsKey(kind))
{
var requiredIcons = provider.GetRequiredPlatformIcons();
foreach (var requiredIcon in requiredIcons)
{
if (!m_RequiredIcons.ContainsKey(requiredIcon.Key))
{
m_RequiredIcons.Add(requiredIcon.Key, requiredIcon.Value);
}
}
}
var icons = PlatformIcon.GetRequiredPlatformIconsByType(provider, kind, m_RequiredIcons);
if (serializedIcons.Length <= 0)
{
// Map legacy icons to required icons
ImportLegacyIcons(namedBuildTarget.TargetName, kind, icons, m_AllLegacyIcons);
// Serialize required icons
SetPlatformIcons(platform, kind, icons, ref allIcons);
foreach (var icon in icons)
{
if (icon.IsEmpty())
{
icon.SetTextures(null);
}
}
}
else
{
// Map serialized icons to required icons
icons = PlayerSettings.GetPlatformIconsFromStruct(icons, kind, serializedIcons.ToArray());
}
return(icons);
}
void SetIconsForPlatform(BuildTargetGroup targetGroup, PlatformIcon[] icons, PlatformIconKind kind, ref BuildTargetIcons[] allIcons)
{
var namedBuildTarget = NamedBuildTarget.FromBuildTargetGroup(targetGroup);
var platformIconProvider = PlayerSettings.GetPlatformIconProvider(namedBuildTarget);
if (platformIconProvider == null)
{
return;
}
if (m_RequiredIcons == null)
{
m_RequiredIcons = new Dictionary <PlatformIconKind, PlatformIcon[]>();
}
if (!m_RequiredIcons.ContainsKey(kind))
{
var requiredIcons = platformIconProvider.GetRequiredPlatformIcons();
foreach (var requiredIcon in requiredIcons)
{
if (!m_RequiredIcons.ContainsKey(requiredIcon.Key))
{
m_RequiredIcons.Add(requiredIcon.Key, requiredIcon.Value);
}
}
}
var requiredIconCount = PlatformIcon.GetRequiredPlatformIconsByType(platformIconProvider, kind, m_RequiredIcons).Length;
PlatformIconStruct[] iconStructs;
if (icons == null)
{
iconStructs = new PlatformIconStruct[0];
}
else if (requiredIconCount != icons.Length)
{
throw new InvalidOperationException($"Attempting to set an incorrect number of icons for {namedBuildTarget} {kind} kind, it requires {requiredIconCount} icons but trying to assign {icons.Length}.");
}
else
{
iconStructs = icons.Select(
i => i.GetPlatformIconStruct()
).ToArray <PlatformIconStruct>();
}
allIcons = PlayerSettings.SetIconsForPlatformForTargetIcons(namedBuildTarget.TargetName, iconStructs, kind.kind, allIcons);
}
public static NamedBuildTarget CalculateActiveNamedBuildTarget()
{
BuildTargetGroup targetGroup = EditorUserBuildSettings.activeBuildTargetGroup;
// TODO: Eventually NamedBuildTarget will replace completetly BuildTargetGroup, and we won't need this custom check
if (targetGroup == BuildTargetGroup.Standalone)
{
if (EditorUserBuildSettings.standaloneBuildSubtarget == StandaloneBuildSubtarget.Server)
{
return(NamedBuildTarget.Server);
}
return(NamedBuildTarget.Standalone);
}
return(NamedBuildTarget.FromBuildTargetGroup(targetGroup));
}
public UnityLinkerRunInformation(string managedAssemblyFolderPath,
BaseUnityLinkerPlatformProvider platformProvider, BuildTarget buildTarget,
RuntimeClassRegistry rcr, ManagedStrippingLevel managedStrippingLevel,
IIl2CppPlatformProvider il2CppPlatformProvider, BuildReport buildReport = null)
{
this.managedAssemblyFolderPath = managedAssemblyFolderPath;
target = buildTarget;
this.platformProvider = platformProvider;
this.rcr = rcr;
this.managedStrippingLevel = managedStrippingLevel;
this.il2CppPlatformProvider = il2CppPlatformProvider;
this.buildReport = buildReport;
pipelineData = new UnityLinkerBuildPipelineData(target, managedAssemblyFolderPath);
buildTargetGroup = BuildPipeline.GetBuildTargetGroup(buildTarget);
namedBuildTarget = NamedBuildTarget.FromActiveSettings(buildTarget);
argumentProvider = new UnityLinkerArgumentValueProvider(this);
isMonoBackend = PlayerSettings.GetScriptingBackend(namedBuildTarget) == ScriptingImplementation.Mono2x;
engineStrippingSupported = (platformProvider?.supportsEngineStripping ?? false) && !isMonoBackend;
performEngineStripping = rcr != null && PlayerSettings.stripEngineCode && engineStrippingSupported;
}
public override string PrepareForBuild(BuildOptions options, BuildTarget target)
{
var namedBuildTarget = NamedBuildTarget.FromActiveSettings(target);
var isServer = namedBuildTarget == NamedBuildTarget.Server;
if ((!isServer && !m_HasMonoPlayers) || (isServer && !m_HasServerMonoPlayers))
{
if (PlayerSettings.GetScriptingBackend(namedBuildTarget) != ScriptingImplementation.IL2CPP)
{
return("Currently selected scripting backend (Mono) is not installed.");
}
}
if ((!isServer && !m_HasIl2CppPlayers) || (isServer && !m_HasServerIl2CppPlayers))
{
if (PlayerSettings.GetScriptingBackend(namedBuildTarget) == ScriptingImplementation.IL2CPP)
{
return("Currently selected scripting backend (IL2CPP) is not installed.");
}
}
return(base.PrepareForBuild(options, target));
}
IEnumerable <BuildTargetGroup> GetSharedTargets(BuildNumberSharing sharing)
{
var targets = new HashSet <BuildTargetGroup>();
if (sharing == BuildNumberSharing.InProject)
{
foreach (BuildTargetGroup targetGroup in System.Enum.GetValues(typeof(BuildTargetGroup)))
{
if (targetGroup == BuildTargetGroup.Unknown)
{
continue;
}
#if UNITY_2021_2_OR_NEWER
try {
var namedTarget = NamedBuildTarget.FromBuildTargetGroup(targetGroup);
targets.Add(targetGroup);
} catch {
// ignore
}
#else
targets.Add(targetGroup);
#endif
}
}
else if (sharing == BuildNumberSharing.InProfile)
{
foreach (var profileTarget in EditorProfile.BuildTargets)
{
targets.Add(BuildPipeline.GetBuildTargetGroup(profileTarget));
}
}
else
{
throw new System.Exception($"GetSharedTargets: Unexpected sharing value: {sharing}");
}
return(targets);
}
public override void UpdateBootConfig(BuildTarget target, BootConfigData config, BuildOptions options)
{
base.UpdateBootConfig(target, config, options);
if (PlayerSettings.forceSingleInstance)
{
config.AddKey("single-instance");
}
if (!PlayerSettings.useFlipModelSwapchain)
{
config.AddKey("force-d3d11-bitblt-mode");
}
if (IL2CPPUtils.UseIl2CppCodegenWithMonoBackend(NamedBuildTarget.FromActiveSettings(target)))
{
config.Set("mono-codegen", "il2cpp");
}
if ((options & BuildOptions.EnableCodeCoverage) != 0)
{
config.Set("enableCodeCoverage", "1");
}
if (!PlayerSettings.usePlayerLog)
{
config.AddKey("nolog");
}
}
public static void SetTierSettings(NamedBuildTarget target, GraphicsTier tier, TierSettings settings) => SetTierSettings(target.ToBuildTargetGroup(), tier, settings);
internal static string[] GetCompilationDefines(EditorScriptCompilationOptions options, BuildTargetGroup targetGroup, BuildTarget target)
{
return(GetCompilationDefines(options, targetGroup, target, PlayerSettings.GetApiCompatibilityLevel(NamedBuildTarget.FromActiveSettings(target))));
}
public static BuildTarget CalculateSelectedBuildTarget()
{
NamedBuildTarget namedBuildTarget = CalculateSelectedNamedBuildTarget();
return(CalculateSelectedBuildTarget(namedBuildTarget));
}
public static TierSettings GetTierSettings(NamedBuildTarget target, GraphicsTier tier) => GetTierSettings(target.ToBuildTargetGroup(), tier);
internal void ShowPlatformIconsByKind(PlatformIconFieldGroup iconFieldGroup, bool foldByKind, bool foldBySubkind)
{
// All icons that are displayed here are serialized into a single map
// So in the preset we can only exclude/include all icons
using (var vertical = new EditorGUILayout.VerticalScope())
using (new EditorGUI.PropertyScope(vertical.rect, GUIContent.none, m_PlatformIcons))
{
int labelHeight = 20;
foreach (var kind in PlayerSettings.GetSupportedIconKinds(NamedBuildTarget.FromBuildTargetGroup(iconFieldGroup.targetGroup)))
{
iconFieldGroup.SetPlatformIcons(GetPlatformIcons(iconFieldGroup.targetGroup, kind, ref m_AllIcons), kind);
}
foreach (var kindGroup in iconFieldGroup.m_IconsFields)
{
EditorGUI.BeginChangeCheck();
var key = kindGroup.Key;
if (foldByKind)
{
GUIContent kindName = new GUIContent(
string.Format("{0} icons ({1}/{2})", key.m_Label, kindGroup.Key.m_SetIconSlots, kindGroup.Key.m_IconSlotCount),
key.m_KindDescription
);
Rect rectKindLabel = GUILayoutUtility.GetRect(kSlotSize, labelHeight);
rectKindLabel.x += 2;
key.m_State = EditorGUI.Foldout(rectKindLabel, key.m_State, kindName, true, EditorStyles.foldout);
}
else
{
key.m_State = true;
}
if (key.m_State)
{
kindGroup.Key.m_SetIconSlots = 0;
foreach (var subKindGroup in kindGroup.Value)
{
subKindGroup.Key.m_SetIconSlots =
PlayerSettings.GetNonEmptyPlatformIconCount(subKindGroup.Value.Select(x => x.platformIcon)
.ToArray());
kindGroup.Key.m_SetIconSlots += subKindGroup.Key.m_SetIconSlots;
if (foldBySubkind)
{
string subKindName = string.Format("{0} icons ({1}/{2})", subKindGroup.Key.m_Label, subKindGroup.Key.m_SetIconSlots, subKindGroup.Value.Length);
Rect rectSubKindLabel = GUILayoutUtility.GetRect(kSlotSize, labelHeight);
rectSubKindLabel.x += 8;
subKindGroup.Key.m_State = EditorGUI.Foldout(rectSubKindLabel, subKindGroup.Key.m_State, subKindName, true, EditorStyles.foldout);
}
else
{
subKindGroup.Key.m_State = true;
}
if (subKindGroup.Key.m_State || !foldBySubkind)
{
foreach (var iconField in subKindGroup.Value)
{
SetPreviewTextures(iconField.platformIcon);
iconField.DrawAt();
}
}
}
}
if (EditorGUI.EndChangeCheck())
{
SetPlatformIcons(iconFieldGroup.targetGroup, key.m_Kind, iconFieldGroup.m_PlatformIconsByKind[key.m_Kind], ref m_AllIcons);
}
}
}
}
public void IconSectionGUI(NamedBuildTarget namedBuildTarget, ISettingEditorExtension settingsExtension, int platformID, int sectionIndex)
{
m_SelectedPlatform = platformID;
if (!m_Owner.BeginSettingsBox(sectionIndex, SettingsContent.iconTitle))
{
m_Owner.EndSettingsBox();
return;
}
var platformUsesStandardIcons = true;
if (settingsExtension != null)
{
platformUsesStandardIcons = settingsExtension.UsesStandardIcons();
}
if (platformUsesStandardIcons)
{
var selectedDefault = (m_SelectedPlatform < 0);
// Set default platform variables
BuildPlatform platform = null;
namedBuildTarget = NamedBuildTarget.Standalone;
var platformName = "";
// Override if a platform is selected
if (!selectedDefault)
{
platform = m_ValidPlatforms[m_SelectedPlatform];
namedBuildTarget = platform.namedBuildTarget;
platformName = platform.name;
}
if (namedBuildTarget == NamedBuildTarget.WebGL || namedBuildTarget == NamedBuildTarget.Server)
{
PlayerSettingsEditor.ShowNoSettings();
EditorGUILayout.Space();
}
else if (namedBuildTarget != NamedBuildTarget.WindowsStoreApps) // UWP does this in its editor extension
{
// Both default icon and Legacy icons are serialized to the same map
// That's why m_LegacyPlatformIcons can be excluded in two places (other place in CommonSettings())
using (var vertical = new EditorGUILayout.VerticalScope())
using (new EditorGUI.PropertyScope(vertical.rect, GUIContent.none, m_LegacyPlatformIcons))
{
// Get icons and icon sizes for selected platform (or default)
var icons = PlayerSettings.GetPlatformIconsForTargetIcons(platformName, IconKind.Any, m_AllLegacyIcons);
var widths = PlayerSettings.GetIconWidthsForPlatform(platformName, IconKind.Any);
var heights = PlayerSettings.GetIconHeightsForPlatform(platformName, IconKind.Any);
var kinds = PlayerSettings.GetIconKindsForPlatform(platformName);
var overrideIcons = true;
if (!selectedDefault)
{
// If the list of icons for this platform is not empty (and has the correct size),
// consider the icon overridden for this platform
EditorGUI.BeginChangeCheck();
overrideIcons = (icons.Length == widths.Length);
overrideIcons = GUILayout.Toggle(overrideIcons, string.Format(L10n.Tr("Override for {0}"), platform.title.text));
EditorGUI.BeginDisabled(!overrideIcons);
var changed = EditorGUI.EndChangeCheck();
if (changed || (!overrideIcons && icons.Length > 0))
{
// Set the list of icons to correct length if overridden, otherwise to an empty list
if (overrideIcons)
{
icons = new Texture2D[widths.Length];
}
else
{
icons = new Texture2D[0];
}
if (changed)
{
SetLegacyPlatformIcons(platformName, icons, IconKind.Any, ref m_AllLegacyIcons);
}
}
}
// Show the icons for this platform (or default)
EditorGUI.BeginChangeCheck();
for (int i = 0; i < widths.Length; i++)
{
var previewWidth = Mathf.Min(kMaxPreviewSize, widths[i]);
var previewHeight = (int)((float)heights[i] * previewWidth / widths[i]); // take into account the aspect ratio
if (namedBuildTarget == NamedBuildTarget.iOS)
{
// Spotlight icons begin with 120 but there are two in the list.
// So check if the next one is 80.
if (kinds[i] == IconKind.Spotlight && kinds[i - 1] != IconKind.Spotlight)
{
var labelRect = GUILayoutUtility.GetRect(EditorGUIUtility.labelWidth, 20);
GUI.Label(new Rect(labelRect.x, labelRect.y, EditorGUIUtility.labelWidth, 20), "Spotlight icons", EditorStyles.boldLabel);
}
if (kinds[i] == IconKind.Settings && kinds[i - 1] != IconKind.Settings)
{
var labelRect = GUILayoutUtility.GetRect(EditorGUIUtility.labelWidth, 20);
GUI.Label(new Rect(labelRect.x, labelRect.y, EditorGUIUtility.labelWidth, 20), "Settings icons", EditorStyles.boldLabel);
}
if (kinds[i] == IconKind.Notification && kinds[i - 1] != IconKind.Notification)
{
var labelRect = GUILayoutUtility.GetRect(EditorGUIUtility.labelWidth, 20);
GUI.Label(new Rect(labelRect.x, labelRect.y, EditorGUIUtility.labelWidth, 20), "Notification icons", EditorStyles.boldLabel);
}
if (kinds[i] == IconKind.Store && kinds[i - 1] != IconKind.Store)
{
var labelRect = GUILayoutUtility.GetRect(EditorGUIUtility.labelWidth, 20);
GUI.Label(new Rect(labelRect.x, labelRect.y, EditorGUIUtility.labelWidth, 20), "App Store icons", EditorStyles.boldLabel);
}
}
var rect = GUILayoutUtility.GetRect(kSlotSize, Mathf.Max(kSlotSize, previewHeight) + kIconSpacing);
var width = Mathf.Min(rect.width, EditorGUIUtility.labelWidth + 4 + kSlotSize + kIconSpacing + kMaxPreviewSize);
// Label
var label = widths[i] + "x" + heights[i];
GUI.Label(new Rect(rect.x, rect.y, width - kMaxPreviewSize - kSlotSize - 2 * kIconSpacing, 20), label);
// Texture slot
if (overrideIcons)
{
var slotWidth = kSlotSize;
var slotHeight = (int)((float)heights[i] / widths[i] * kSlotSize); // take into account the aspect ratio
icons[i] = (Texture2D)EditorGUI.ObjectField(
new Rect(rect.x + width - kMaxPreviewSize - kSlotSize - kIconSpacing, rect.y, slotWidth, slotHeight),
icons[i],
typeof(Texture2D),
false);
}
// Preview
var previewRect = new Rect(rect.x + width - kMaxPreviewSize, rect.y, previewWidth, previewHeight);
var closestIcon = PlayerSettings.GetPlatformIconForSizeForTargetIcons(platformName, widths[i], heights[i], kinds[i], m_AllLegacyIcons);
if (closestIcon != null)
{
GUI.DrawTexture(previewRect, closestIcon);
}
else
{
GUI.Box(previewRect, "");
}
}
// Save changes
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(m_Owner.targets, SettingsContent.undoChangedIconString);
SetLegacyPlatformIcons(platformName, icons, IconKind.Any, ref m_AllLegacyIcons);
}
EditorGUI.EndDisabled();
if (namedBuildTarget == NamedBuildTarget.iOS || namedBuildTarget == NamedBuildTarget.tvOS)
{
EditorGUILayout.PropertyField(m_UIPrerenderedIcon, SettingsContent.UIPrerenderedIcon);
EditorGUILayout.Space();
}
}
}
}
if (settingsExtension != null)
{
settingsExtension.IconSectionGUI();
}
m_Owner.EndSettingsBox();
}
private void ConvertPlayerDlltoCpp(Il2CppBuildPipelineData data)
{
var arguments = new List <string>();
arguments.Add("--convert-to-cpp");
if (m_PlatformProvider.emitNullChecks)
{
arguments.Add("--emit-null-checks");
}
if (m_PlatformProvider.enableStackTraces)
{
arguments.Add("--enable-stacktrace");
}
if (m_PlatformProvider.enableArrayBoundsCheck)
{
arguments.Add("--enable-array-bounds-check");
}
if (m_PlatformProvider.enableDivideByZeroCheck)
{
arguments.Add("--enable-divide-by-zero-check");
}
if (m_PlatformProvider.development && m_PlatformProvider.enableDeepProfilingSupport)
{
arguments.Add("--enable-deep-profiler");
}
if (m_BuildForMonoRuntime)
{
arguments.Add("--mono-runtime");
}
var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(m_PlatformProvider.target);
var apiCompatibilityLevel = PlayerSettings.GetApiCompatibilityLevel(buildTargetGroup);
arguments.Add(string.Format("--dotnetprofile=\"{0}\"", IL2CPPUtils.ApiCompatibilityLevelToDotNetProfileArgument(apiCompatibilityLevel, m_PlatformProvider.target)));
var namedBuildTarget = NamedBuildTarget.FromBuildTargetGroup(buildTargetGroup);
var il2cppCodeGeneration = PlayerSettings.GetIl2CppCodeGeneration(namedBuildTarget);
if (il2cppCodeGeneration == Il2CppCodeGeneration.OptimizeSize)
{
arguments.Add("--generics-option=EnableFullSharing");
}
var il2CppNativeCodeBuilder = m_PlatformProvider.CreateIl2CppNativeCodeBuilder();
if (il2CppNativeCodeBuilder != null)
{
var buildCacheNativeOutputFile = Path.Combine(GetNativeOutputRelativeDirectory(m_PlatformProvider.il2cppBuildCacheDirectory), m_PlatformProvider.nativeLibraryFileName);
var compilerConfiguration = PlayerSettings.GetIl2CppCompilerConfiguration(buildTargetGroup);
Il2CppNativeCodeBuilderUtils.ClearAndPrepareCacheDirectory(il2CppNativeCodeBuilder);
arguments.AddRange(Il2CppNativeCodeBuilderUtils.AddBuilderArguments(il2CppNativeCodeBuilder, buildCacheNativeOutputFile, m_PlatformProvider.includePaths, m_PlatformProvider.libraryPaths, compilerConfiguration));
}
else
{
arguments.Add($"--cachedirectory={CommandLineFormatter.PrepareFileName(GetShortPathName(Path.GetFullPath(m_PlatformProvider.il2cppBuildCacheDirectory)))}");
}
// Additional files can take any form, depending on platform, so pass anything in the additional files directory
foreach (var additionalCppFile in Directory.GetFiles(GetAdditionalCppFilesDirectory(m_PlatformProvider.il2cppBuildCacheDirectory)))
{
arguments.Add($"--additional-cpp={CommandLineFormatter.PrepareFileName(GetShortPathName(Path.GetFullPath(additionalCppFile)))}");
}
arguments.AddRange(IL2CPPUtils.GetDebuggerIL2CPPArguments(m_PlatformProvider, buildTargetGroup));
foreach (var buildingArgument in IL2CPPUtils.GetBuildingIL2CPPArguments(m_PlatformProvider, buildTargetGroup))
{
if (!arguments.Contains(buildingArgument))
{
arguments.Add(buildingArgument);
}
}
if (CrashReportingSettings.enabled)
{
arguments.Add($"--emit-source-mapping");
}
var additionalArgs = IL2CPPUtils.GetAdditionalArguments();
if (!string.IsNullOrEmpty(additionalArgs))
{
arguments.Add(additionalArgs);
}
arguments.Add($"--directory={CommandLineFormatter.PrepareFileName(GetShortPathName(Path.GetFullPath(data.inputDirectory)))}");
arguments.Add($"--generatedcppdir={CommandLineFormatter.PrepareFileName(GetCppOutputDirectory(m_PlatformProvider.il2cppBuildCacheDirectory))}");
// NOTE: any arguments added here that affect how generated code is built need
// to also be added to PlatformDependent\Win\Extensions\Managed\VisualStudioProjectHelpers.cs
// as that file generated project files that invoke back into IL2CPP in order to build
// generated code
string progressMessage = "Converting managed assemblies to C++";
if (il2CppNativeCodeBuilder != null)
{
progressMessage = "Building native binary with IL2CPP...";
}
if (EditorUtility.DisplayCancelableProgressBar("Building Player", progressMessage, 0.3f))
{
throw new OperationCanceledException();
}
Action <ProcessStartInfo> setupStartInfo = null;
if (il2CppNativeCodeBuilder != null)
{
setupStartInfo = il2CppNativeCodeBuilder.SetupStartInfo;
}
if (PlayerBuildInterface.ExtraTypesProvider != null)
{
var extraTypes = new HashSet <string>();
foreach (var extraType in PlayerBuildInterface.ExtraTypesProvider())
{
extraTypes.Add(extraType);
}
var tempFile = Path.GetFullPath(Path.Combine(m_TempFolder, "extra-types.txt"));
File.WriteAllLines(tempFile, extraTypes.ToArray());
arguments.Add($"--extra-types-file={CommandLineFormatter.PrepareFileName(tempFile)}");
}
RunIl2CppWithArguments(arguments, setupStartInfo);
}
internal static bool UseIl2CppCodegenWithMonoBackend(NamedBuildTarget namedBuildTarget)
{
return(EditorApplication.useLibmonoBackendForIl2cpp &&
PlayerSettings.GetScriptingBackend(namedBuildTarget) == ScriptingImplementation.IL2CPP);
}
