public override void OnEnable(PlayerSettingsEditor editor)
{
this.splashScreenProperties = new SerializedProperty[UnityEditor.iOS.SplashScreen.iOSTypes.Length];
for (int i = 0; i < UnityEditor.iOS.SplashScreen.iOSTypes.Length; i++)
{
this.splashScreenProperties[i] = editor.FindPropertyAssert(UnityEditor.iOS.SplashScreen.iOSTypes[i].serializationName);
}
this.iPhoneLaunchScreenProperties.type = editor.FindPropertyAssert("iOSLaunchScreenType");
this.iPhoneLaunchScreenProperties.portraitImage = editor.FindPropertyAssert("iOSLaunchScreenPortrait");
this.iPhoneLaunchScreenProperties.landscapeImage = editor.FindPropertyAssert("iOSLaunchScreenLandscape");
this.iPhoneLaunchScreenProperties.backgroundColor = editor.FindPropertyAssert("iOSLaunchScreenBackgroundColor");
this.iPhoneLaunchScreenProperties.fillPercentage = editor.FindPropertyAssert("iOSLaunchScreenFillPct");
this.iPhoneLaunchScreenProperties.size = editor.FindPropertyAssert("iOSLaunchScreenSize");
this.iPhoneLaunchScreenProperties.customXibPath = editor.FindPropertyAssert("iOSLaunchScreenCustomXibPath");
this.iPadLaunchScreenProperties.type = editor.FindPropertyAssert("iOSLaunchScreeniPadType");
this.iPadLaunchScreenProperties.portraitAndLandscapeImage = editor.FindPropertyAssert("iOSLaunchScreeniPadImage");
this.iPadLaunchScreenProperties.backgroundColor = editor.FindPropertyAssert("iOSLaunchScreeniPadBackgroundColor");
this.iPadLaunchScreenProperties.fillPercentage = editor.FindPropertyAssert("iOSLaunchScreeniPadFillPct");
this.iPadLaunchScreenProperties.size = editor.FindPropertyAssert("iOSLaunchScreeniPadSize");
this.iPadLaunchScreenProperties.customXibPath = editor.FindPropertyAssert("iOSLaunchScreeniPadCustomXibPath");
this.m_AppleDeveloperTeamID = editor.FindPropertyAssert("appleDeveloperTeamID");
this.m_iOSManualSigningProvisioningProfileID = editor.FindPropertyAssert("iOSManualSigningProvisioningProfileID");
this.m_AppleEnableAutomaticSigning = editor.FindPropertyAssert("appleEnableAutomaticSigning");
this.InitRequirements();
this.m_AppInBackgroundBehavior = editor.FindPropertyAssert("iosAppInBackgroundBehavior");
}
protected ManagedProgram StartCompiler(BuildTarget target, string compiler, List <string> arguments)
{
base.AddCustomResponseFileIfPresent(arguments, Path.GetFileNameWithoutExtension(compiler) + ".rsp");
string monodistro = (!PlayerSettingsEditor.IsLatestApiCompatibility(this._island._api_compatibility_level)) ? MonoInstallationFinder.GetMonoInstallation() : MonoInstallationFinder.GetMonoBleedingEdgeInstallation();
return(this.StartCompiler(target, compiler, arguments, true, monodistro));
}
protected string GetMonoProfileLibDirectory()
{
string profile = BuildPipeline.CompatibilityProfileToClassLibFolder(this._island._api_compatibility_level);
string monoInstallation = (!PlayerSettingsEditor.IsLatestApiCompatibility(this._island._api_compatibility_level)) ? "Mono" : "MonoBleedingEdge";
return(MonoInstallationFinder.GetProfileDirectory(profile, monoInstallation));
}
public void SplashSectionGUI(BuildPlatform platform, ISettingEditorExtension settingsExtension, int sectionIndex = 2)
{
if (m_Owner.BeginSettingsBox(sectionIndex, k_Texts.title))
{
if (platform.namedBuildTarget == NamedBuildTarget.Server)
{
PlayerSettingsEditor.ShowNoSettings();
EditorGUILayout.Space();
}
else
{
ObjectReferencePropertyField <Texture2D>(m_VirtualRealitySplashScreen, k_Texts.vrSplashScreen);
if (TargetSupportsOptionalBuiltinSplashScreen(platform.namedBuildTarget.ToBuildTargetGroup(), settingsExtension))
{
BuiltinCustomSplashScreenGUI(platform.namedBuildTarget.ToBuildTargetGroup(), settingsExtension);
}
if (settingsExtension != null)
{
settingsExtension.SplashSectionGUI();
}
if (m_ShowUnitySplashScreen.boolValue)
{
m_Owner.ShowSharedNote();
}
}
}
m_Owner.EndSettingsBox();
}
public override void OnEnable(PlayerSettingsEditor settingsEditor)
{
this.m_TizenProductDescription = settingsEditor.FindPropertyAssert("tizenProductDescription");
this.m_TizenProductURL = settingsEditor.FindPropertyAssert("tizenProductURL");
this.m_TizenProfileName = settingsEditor.FindPropertyAssert("tizenSigningProfileName");
this.m_TizenMinOSVersion = settingsEditor.FindPropertyAssert("tizenMinOSVersion");
this.m_IPhoneSplashScreen = settingsEditor.FindPropertyAssert("iPhoneSplashScreen");
}
protected ManagedProgram StartCompiler(BuildTarget target, string compiler, List <string> arguments, string profileDirectory)
{
AddCustomResponseFileIfPresent(arguments, Path.GetFileNameWithoutExtension(compiler) + ".rsp");
var monoInstallation = PlayerSettingsEditor.IsLatestApiCompatibility(m_Island._api_compatibility_level)
? MonoInstallationFinder.GetMonoBleedingEdgeInstallation()
: MonoInstallationFinder.GetMonoInstallation();
return(StartCompiler(target, compiler, arguments, profileDirectory, true, monoInstallation));
}
protected string GetMonoProfileLibDirectory()
{
var profile = BuildPipeline.CompatibilityProfileToClassLibFolder(m_Island._api_compatibility_level);
var monoInstall = PlayerSettingsEditor.IsLatestApiCompatibility(m_Island._api_compatibility_level)
? MonoInstallationFinder.MonoBleedingEdgeInstallation
: MonoInstallationFinder.MonoInstallation;
return(MonoInstallationFinder.GetProfileDirectory(profile, monoInstall));
}
public PlayerSettingsEditorVR(PlayerSettingsEditor settingsEditor)
{
m_Settings = settingsEditor;
m_StereoRenderingPath = m_Settings.serializedObject.FindProperty("m_StereoRenderingPath");
m_AndroidEnableTango = m_Settings.FindPropertyAssert("AndroidEnableTango");
SerializedProperty property = m_Settings.serializedObject.FindProperty("vrSettings");
if (property != null)
m_Enable360StereoCapture = property.FindPropertyRelative("enable360StereoCapture");
}
public override void OnEnable(PlayerSettingsEditor settingsEditor)
{
this.m_SettingsEditor = settingsEditor;
this.m_GUIDefaultIsFullScreen = EditorGUIUtility.TextContent("Default Is Full Screen*");
this.m_CompanyName = settingsEditor.FindPropertyAssert("companyName");
this.m_ProductName = settingsEditor.FindPropertyAssert("productName");
this.m_DefaultIsFullScreen = settingsEditor.FindPropertyAssert("defaultIsFullScreen");
this.m_RunInBackground = settingsEditor.FindPropertyAssert("runInBackground");
this.m_MetroPackageName = settingsEditor.FindPropertyAssert("metroPackageName");
this.m_MetroPackageName.stringValue = Utility.TryValidatePackageName(this.m_MetroPackageName.stringValue);
this.m_MetroPackageVersion = settingsEditor.FindPropertyAssert("metroPackageVersion");
this.m_MetroPackageVersion.stringValue = PlayerSettings.WSA.ValidatePackageVersion(this.m_MetroPackageVersion.stringValue);
this.m_MetroApplicationDescription = settingsEditor.FindPropertyAssert("metroApplicationDescription");
this.m_MetroApplicationDescription.stringValue = this.ValidateMetroApplicationDescription(this.m_MetroApplicationDescription.stringValue);
this.m_MetroTileShortName = settingsEditor.FindPropertyAssert("metroTileShortName");
this.m_MetroTileShortName.stringValue = this.ValidateMetroTileShortName(this.m_MetroTileShortName.stringValue);
this.m_MetroTileBackgroundColor = settingsEditor.FindPropertyAssert("metroTileBackgroundColor");
this.m_MetroFTAName = settingsEditor.FindPropertyAssert("metroFTAName");
this.m_MetroFTAFileTypes = settingsEditor.FindPropertyAssert("metroFTAFileTypes");
this.m_MetroProtocolName = settingsEditor.FindPropertyAssert("metroProtocolName");
PlayerSettings.WSAImageScale[] scales = new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale._80 };
PlayerSettings.WSAImageScale[] scaleArray2 = new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale._100 };
PlayerSettings.WSAImageScale[] scaleArray3 = new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale._100 };
this.m_PackageLogos = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.PackageLogo, new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale._100 }, "Scale {0}% ({1}x{2} pixels)|Specifies the image that appears on the Store description page for the product.", new int[] { 50, 0x3f, 70, 0x4b, 90, 100, 120, 200 });
MetroScaledImage[] sourceArray = CreateScaledSquareImages(PlayerSettings.WSAImageType.StoreTileSmallLogo, scales, "Scale {0}% ({1}x{2} pixels)|Specifies the image that is shown when viewing all installed applications.", new int[] { 0x18, 30, 0x2a, 0x36 });
MetroScaledImage[] imageArray2 = CreateScaledSquareImages(PlayerSettings.WSAImageType.StoreTileSmallLogo, new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale.Target16 }, "Target size {0} ({1}x{2} pixels)|Specifies the image that is shown when viewing all installed applications.", new int[] { 0x10, 0x20, 0x30, 0x100 });
MetroScaledImage[] destinationArray = new MetroScaledImage[sourceArray.Length + imageArray2.Length];
Array.Copy(sourceArray, destinationArray, sourceArray.Length);
Array.Copy(imageArray2, 0, destinationArray, sourceArray.Length, imageArray2.Length);
this.m_StoreSmallLogos = new MetroScaledImageGroup(destinationArray);
this.m_MediumTiles = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.StoreTileLogo, scales, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile in Windows.", new int[] { 120, 150, 210, 270 });
this.m_WideTiles = CreateScaledImageGroup(PlayerSettings.WSAImageType.StoreTileWideLogo, scales, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's wide tile in Windows if supported.", new int[] { 0xf8, 310, 0x1b2, 0x22e }, new int[] { 120, 150, 210, 270 });
this.m_SmallTiles = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.StoreSmallTile, scales, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's small tile in Windows if supported.", new int[] { 0x38, 70, 0x62, 0x7e });
this.m_LargeTiles = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.StoreLargeTile, scales, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's large tile in Windows if supported.", new int[] { 0xf8, 310, 0x1b2, 0x22e });
this.m_PhoneAppIcons = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.PhoneAppIcon, scaleArray2, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's small tile.", new int[] { 0x2c, 0x3e, 0x6a });
this.m_PhoneSmallTiles = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.PhoneSmallTile, scaleArray2, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's small tile", new int[] { 0x47, 0x63, 170 });
this.m_PhoneMediumTiles = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.PhoneMediumTile, scaleArray2, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 150, 210, 360 });
this.m_PhoneWideTiles = CreateScaledImageGroup(PlayerSettings.WSAImageType.PhoneWideTile, scaleArray2, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's wide tile.", new int[] { 310, 0x1b2, 0x2e8 }, new int[] { 150, 210, 360 });
MetroScaledImage[] imageArray4 = CreateScaledSquareImages(PlayerSettings.WSAImageType.UWPSquare44x44Logo, scaleArray3, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 0x2c, 0x37, 0x42, 0x58, 0xb0 });
MetroScaledImage[] imageArray5 = CreateScaledSquareImages(PlayerSettings.WSAImageType.UWPSquare44x44Logo, new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale.Target16 }, "Target size {0} ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 0x10, 0x18, 0x30, 0x100 });
MetroScaledImage[] imageArray6 = new MetroScaledImage[imageArray4.Length + imageArray5.Length];
Array.Copy(imageArray4, imageArray6, imageArray4.Length);
Array.Copy(imageArray5, 0, imageArray6, imageArray4.Length, imageArray5.Length);
this.m_UWPSquare44x44Logos = new MetroScaledImageGroup(imageArray6);
this.m_UWPSquare71x71Logos = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.UWPSquare71x71Logo, scaleArray3, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 0x47, 0x59, 0x6b, 0x8e, 0x11c });
this.m_UWPSquare150x150Logos = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.UWPSquare150x150Logo, scaleArray3, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 150, 0xbc, 0xe1, 300, 600 });
this.m_UWPSquare310x310Logos = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.UWPSquare310x310Logo, scaleArray3, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 310, 0x184, 0x1d1, 620, 0x4d8 });
this.m_UWPWide310x150Logos = CreateScaledImageGroup(PlayerSettings.WSAImageType.UWPWide310x150Logo, scaleArray3, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 310, 0x184, 0x1d1, 620, 0x4d8 }, new int[] { 150, 0xbc, 0xe1, 300, 600 });
this.m_WindowsSplashScreens = CreateScaledImages(PlayerSettings.WSAImageType.SplashScreenImage, new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale._100 }, "Scale {0}% ({1}x{2} pixels)|Sets the foreground image for the app's splash screen.", new int[] { 620, 0x307, 0x364, 930, 0x45c, 0x4d8, 0x9b0 }, new int[] { 300, 0x177, 420, 450, 540, 600, 0x4b0 });
this.m_PhoneSplashScreens = CreateScaledImages(PlayerSettings.WSAImageType.PhoneSplashScreen, scaleArray2, "Scale {0}% ({1}x{2} pixels)|Sets the foreground image for the app's splash screen.", new int[] { 480, 0x2a0, 0x480 }, new int[] { 800, 0x460, 0x780 });
this.m_HolographicSplashScreen = settingsEditor.FindPropertyAssert("m_VirtualRealitySplashScreen");
this.m_HolographicPauseOnTrackingLoss = settingsEditor.FindPropertyAssert("m_HolographicPauseOnTrackingLoss");
this.m_HolographicTrackingLossScreen = settingsEditor.FindPropertyAssert("m_HolographicTrackingLossScreen");
}
private string ProjectHeader(MonoIsland island, string[] additionalDefines)
{
string text = "v3.5";
string text2 = "4";
string text3 = "4.0";
string text4 = "10.0.20506";
string text5 = ".";
ScriptingLanguage language = SolutionSynchronizer.ScriptingLanguageFor(island);
if (PlayerSettingsEditor.IsLatestApiCompatibility(island._api_compatibility_level))
{
text = "v4.6";
text2 = "6";
}
else if (ScriptEditorUtility.GetScriptEditorFromPreferences() == ScriptEditorUtility.ScriptEditor.Rider)
{
text = "v4.5";
}
else if (this._settings.VisualStudioVersion == 9)
{
text3 = "3.5";
text4 = "9.0.21022";
}
object[] array = new object[]
{
text3,
text4,
this.ProjectGuid(island._output),
this._settings.EngineAssemblyPath,
this._settings.EditorAssemblyPath,
string.Join(";", new string[]
{
"DEBUG",
"TRACE"
}.Concat(this._settings.Defines).Concat(island._defines).Concat(additionalDefines).Distinct <string>().ToArray <string>()),
SolutionSynchronizer.MSBuildNamespaceUri,
Path.GetFileNameWithoutExtension(island._output),
EditorSettings.projectGenerationRootNamespace,
text,
text2,
text5
};
string result;
try
{
result = string.Format(this._settings.GetProjectHeaderTemplate(language), array);
}
catch (Exception)
{
throw new NotSupportedException("Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " + array.Length);
}
return(result);
}
public override void OnEnable(PlayerSettingsEditor settingsEditor)
{
this.m_SamsungTVDeviceAddress = settingsEditor.FindPropertyAssert("stvDeviceAddress");
this.m_SamsungTVProductDescription = settingsEditor.FindPropertyAssert("stvProductDescription");
this.m_SamsungTVProductAuthor = settingsEditor.FindPropertyAssert("stvProductAuthor");
this.m_SamsungTVProductAuthorEmail = settingsEditor.FindPropertyAssert("stvProductAuthorEmail");
this.m_SamsungTVProductLink = settingsEditor.FindPropertyAssert("stvProductLink");
this.m_SamsungTVProductCategory = settingsEditor.FindPropertyAssert("stvProductCategory");
this.m_IPhoneSplashScreen = settingsEditor.FindPropertyAssert("iPhoneSplashScreen");
this.m_IgnoreAlphaClear = settingsEditor.FindPropertyAssert("ignoreAlphaClear");
this.m_SettingsEditor = settingsEditor;
}
public override void OnEnable(PlayerSettingsEditor settingsEditor)
{
this.m_WebGLMemorySize = settingsEditor.FindPropertyAssert("webGLMemorySize");
this.m_WebGLExceptionSupport = settingsEditor.FindPropertyAssert("webGLExceptionSupport");
this.m_WebGLCompressionFormat = settingsEditor.FindPropertyAssert("webGLCompressionFormat");
this.m_WebGLDataCaching = settingsEditor.FindPropertyAssert("webGLDataCaching");
this.m_WebGLDebugSymbols = settingsEditor.FindPropertyAssert("webGLDebugSymbols");
this.m_WebGLTemplate = settingsEditor.FindPropertyAssert("webGLTemplate");
this.m_DefaultScreenWidthWeb = settingsEditor.FindPropertyAssert("defaultScreenWidthWeb");
this.m_DefaultScreenHeightWeb = settingsEditor.FindPropertyAssert("defaultScreenHeightWeb");
this.m_RunInBackground = settingsEditor.FindPropertyAssert("runInBackground");
}
public override void OnEnable(PlayerSettingsEditor settingsEditor)
{
this.m_WebGLMemorySize = settingsEditor.FindPropertyAssert("webGLMemorySize");
this.m_WebGLExceptionSupport = settingsEditor.FindPropertyAssert("webGLExceptionSupport");
this.m_WebGLCompressionFormat = settingsEditor.FindPropertyAssert("webGLCompressionFormat");
this.m_WebGLDataCaching = settingsEditor.FindPropertyAssert("webGLDataCaching");
this.m_WebGLDebugSymbols = settingsEditor.FindPropertyAssert("webGLDebugSymbols");
this.m_WebGLTemplate = settingsEditor.FindPropertyAssert("webGLTemplate");
this.m_DefaultScreenWidthWeb = settingsEditor.FindPropertyAssert("defaultScreenWidthWeb");
this.m_DefaultScreenHeightWeb = settingsEditor.FindPropertyAssert("defaultScreenHeightWeb");
this.m_RunInBackground = settingsEditor.FindPropertyAssert("runInBackground");
}
public override void OnEnable(PlayerSettingsEditor settingsEditor)
{
this.m_SamsungTVDeviceAddress = settingsEditor.FindPropertyAssert("stvDeviceAddress");
this.m_SamsungTVProductDescription = settingsEditor.FindPropertyAssert("stvProductDescription");
this.m_SamsungTVProductAuthor = settingsEditor.FindPropertyAssert("stvProductAuthor");
this.m_SamsungTVProductAuthorEmail = settingsEditor.FindPropertyAssert("stvProductAuthorEmail");
this.m_SamsungTVProductLink = settingsEditor.FindPropertyAssert("stvProductLink");
this.m_SamsungTVProductCategory = settingsEditor.FindPropertyAssert("stvProductCategory");
this.m_IPhoneSplashScreen = settingsEditor.FindPropertyAssert("iPhoneSplashScreen");
this.m_IgnoreAlphaClear = settingsEditor.FindPropertyAssert("ignoreAlphaClear");
this.m_SettingsEditor = settingsEditor;
}
private string ProjectHeader(MonoIsland island,
ScriptCompilerBase.ResponseFileData responseFileData)
{
string targetframeworkversion = "v3.5";
string targetLanguageVersion = "4";
string toolsversion = "4.0";
string productversion = "10.0.20506";
string baseDirectory = ".";
ScriptingLanguage language = ScriptingLanguageFor(island);
if (PlayerSettingsEditor.IsLatestApiCompatibility(island._api_compatibility_level))
{
if (ScriptEditorUtility.GetScriptEditorFromPreferences() == ScriptEditorUtility.ScriptEditor.Rider ||
ScriptEditorUtility.GetScriptEditorFromPreferences() == ScriptEditorUtility.ScriptEditor.VisualStudioCode)
{
targetframeworkversion = "v4.5";
}
else
{
targetframeworkversion = "v4.7.1";
}
targetLanguageVersion = "7.2";
}
else if (_settings.VisualStudioVersion == 9)
{
toolsversion = "3.5";
productversion = "9.0.21022";
}
var arguments = new object[]
{
toolsversion, productversion, ProjectGuid(island._output),
_settings.EngineAssemblyPath,
_settings.EditorAssemblyPath,
string.Join(";", new[] { "DEBUG", "TRACE" }.Concat(island._defines).Concat(responseFileData.Defines).Distinct().ToArray()),
MSBuildNamespaceUri,
Path.GetFileNameWithoutExtension(island._output),
EditorSettings.projectGenerationRootNamespace,
targetframeworkversion,
targetLanguageVersion,
baseDirectory,
island._allowUnsafeCode | responseFileData.Unsafe
};
try
{
return(string.Format(_settings.GetProjectHeaderTemplate(language), arguments));
}
catch (Exception)
{
throw new System.NotSupportedException("Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " + arguments.Length);
}
}
public override void OnEnable(PlayerSettingsEditor editor)
{
this.splashScreenProperties = new SerializedProperty[splashScreenTypes.Length];
for (int i = 0; i < splashScreenTypes.Length; i++)
{
this.splashScreenProperties[i] = editor.FindPropertyAssert(splashScreenTypes[i].serializationName);
}
this.m_SmallIconsLayers = new ReorderableIconLayerList();
this.m_SmallIconsLayers.headerString = LocalizationDatabase.GetLocalizedString("Small icon layers");
this.m_SmallIconsLayers.minItems = 2;
this.m_SmallIconsLayers.SetImageSize(400, 240);
if (<>f__am$cache0 == null)
{
public override void OnEnable(PlayerSettingsEditor editor)
{
this.splashScreenProperties = new SerializedProperty[splashScreenTypes.Length];
for (int i = 0; i < splashScreenTypes.Length; i++)
{
this.splashScreenProperties[i] = editor.FindPropertyAssert(splashScreenTypes[i].serializationName);
}
this.m_SmallIconsLayers = new ReorderableIconLayerList();
this.m_SmallIconsLayers.headerString = LocalizationDatabase.GetLocalizedString("Small icon layers");
this.m_SmallIconsLayers.minItems = 2;
this.m_SmallIconsLayers.SetImageSize(400, 240);
if (< > f__am$cache0 == null)
{
public static void ShowArchitectureButton(BuildTargetGroup target)
{
bool flag;
if (target == BuildTargetGroup.tvOS)
{
flag = PlayerSettings.tvOS.sdkVersion == tvOSSdkVersion.Simulator;
}
else
{
flag = PlayerSettings.iOS.sdkVersion == iOSSdkVersion.SimulatorSDK;
}
int scriptingBackend = (int)PlayerSettings.GetScriptingBackend(target);
if (!flag)
{
int num3;
int architecture = PlayerSettings.GetArchitecture(target);
if (scriptingBackend == 1)
{
if (target == BuildTargetGroup.tvOS)
{
num3 = 1;
PlayerSettingsEditor.BuildDisabledEnumPopup(new GUIContent("ARM64"), EditorGUIUtility.TextContent("Architecture"));
}
else
{
num3 = PlayerSettingsEditor.BuildEnumPopup <Architecture>(EditorGUIUtility.TextContent("Architecture"), architecture, kArchitectureOrder, kArchitectureDescriptions);
}
}
else
{
num3 = 0;
PlayerSettingsEditor.BuildDisabledEnumPopup(new GUIContent("ARMv7"), EditorGUIUtility.TextContent("Architecture"));
}
if (num3 != architecture)
{
PlayerSettings.SetArchitecture(target, num3);
}
}
else if (scriptingBackend == 1)
{
PlayerSettingsEditor.BuildDisabledEnumPopup(EditorGUIUtility.TextContent("x86_64"), EditorGUIUtility.TextContent("Architecture"));
}
else
{
PlayerSettingsEditor.BuildDisabledEnumPopup(EditorGUIUtility.TextContent("i386"), EditorGUIUtility.TextContent("Architecture"));
}
}
public override void OnEnable(PlayerSettingsEditor settingsEditor)
{
this.m_AndroidBundleVersionCode = settingsEditor.FindPropertyAssert("AndroidBundleVersionCode");
this.m_AndroidKeystoreName = settingsEditor.FindPropertyAssert("AndroidKeystoreName");
this.m_AndroidKeyaliasName = settingsEditor.FindPropertyAssert("AndroidKeyaliasName");
this.m_AndroidMinSdkVersion = settingsEditor.FindPropertyAssert("AndroidMinSdkVersion");
this.m_AndroidPreferredInstallLocation = settingsEditor.FindPropertyAssert("AndroidPreferredInstallLocation");
this.m_AndroidSplashScreenScale = settingsEditor.FindPropertyAssert("AndroidSplashScreenScale");
this.m_AndroidTargetDevice = settingsEditor.FindPropertyAssert("AndroidTargetDevice");
this.m_AndroidTVCompatibility = settingsEditor.FindPropertyAssert("AndroidTVCompatibility");
this.m_AndroidIsGame = settingsEditor.FindPropertyAssert("AndroidIsGame");
this.m_AndroidEnableBanner = settingsEditor.FindPropertyAssert("androidEnableBanner");
this.m_AndroidGamepadSupportLevel = settingsEditor.FindPropertyAssert("androidGamepadSupportLevel");
this.m_APKExpansionFiles = settingsEditor.FindPropertyAssert("APKExpansionFiles");
this.m_ForceInternetPermission = settingsEditor.FindPropertyAssert("ForceInternetPermission");
this.m_ForceSDCardPermission = settingsEditor.FindPropertyAssert("ForceSDCardPermission");
this.m_AndroidSplashScreen = settingsEditor.FindPropertyAssert("androidSplashScreen");
this.m_SettingsEditor = settingsEditor;
}
internal static void SetColorGamuts(ColorGamut[] colorSpaces)
{
SetColorGamutsImpl(colorSpaces);
// Color space data is cached in player settings editor
PlayerSettingsEditor.SyncColorGamuts();
}
public static void SetGraphicsAPIs(BuildTarget platform, UnityEngine.Rendering.GraphicsDeviceType[] apis)
{
SetGraphicsAPIsImpl(platform, apis);
// we do cache api list in player settings editor, so if we update from script we should forcibly update cache
PlayerSettingsEditor.SyncPlatformAPIsList(platform);
}
private static bool StripAssembliesTo(string[] assemblies, string[] searchDirs, string outputFolder, string workingDirectory, out string output, out string error, string linkerPath, IIl2CppPlatformProvider platformProvider, IEnumerable <string> additionalBlacklist, BuildTargetGroup buildTargetGroup, ManagedStrippingLevel managedStrippingLevel)
{
if (!Directory.Exists(outputFolder))
{
Directory.CreateDirectory(outputFolder);
}
additionalBlacklist = additionalBlacklist.Select(s => Path.IsPathRooted(s) ? s : Path.Combine(workingDirectory, s)).Where(File.Exists);
var userBlackLists = GetUserBlacklistFiles();
foreach (var ub in userBlackLists)
{
Console.WriteLine("UserBlackList: " + ub);
}
additionalBlacklist = additionalBlacklist.Concat(userBlackLists);
var args = new List <string>
{
"-out=\"" + outputFolder + "\"",
"-x=\"" + GetModuleWhitelist("Core", platformProvider.moduleStrippingInformationFolder) + "\"",
};
args.AddRange(additionalBlacklist.Select(path => "-x \"" + path + "\""));
args.AddRange(searchDirs.Select(d => "-d \"" + d + "\""));
args.AddRange(assemblies.Select(assembly => "--include-unity-root-assembly=\"" + Path.GetFullPath(assembly) + "\""));
args.Add($"--dotnetruntime={GetRuntimeArgumentValueForLinker(buildTargetGroup)}");
args.Add($"--dotnetprofile={GetProfileArgumentValueForLinker(buildTargetGroup)}");
args.Add("--use-editor-options");
args.Add($"--include-directory={CommandLineFormatter.PrepareFileName(workingDirectory)}");
if (EditorUserBuildSettings.allowDebugging)
{
args.Add("--editor-settings-flag=AllowDebugging");
}
if (EditorUserBuildSettings.development)
{
args.Add("--editor-settings-flag=Development");
}
args.Add($"--rule-set={GetRuleSetForStrippingLevel(managedStrippingLevel)}");
// One final check to make sure we only run high on latest runtime.
if ((managedStrippingLevel == ManagedStrippingLevel.High) && (PlayerSettingsEditor.IsLatestApiCompatibility(PlayerSettings.GetApiCompatibilityLevel(buildTargetGroup))))
{
// Prepare the arguments to run the UnityLinker. When in high mode, need to also
// supply the IL2CPP compiler platform and compiler architecture. When the scripting backend
// is not IL2CPP, we have to map those strings and use a utility function to figure out proper strings.
// Currently only need to do this on the non aot platforms of Android, Windows, Mac, Linux.
var compilerPlatform = "";
var compilerArchitecture = "";
Il2CppNativeCodeBuilder il2cppNativeCodeBuilder = platformProvider.CreateIl2CppNativeCodeBuilder();
if (il2cppNativeCodeBuilder != null)
{
compilerPlatform = il2cppNativeCodeBuilder.CompilerPlatform;
compilerArchitecture = il2cppNativeCodeBuilder.CompilerArchitecture;
}
else
{
GetUnityLinkerPlatformStringsFromBuildTarget(platformProvider.target, out compilerPlatform, out compilerArchitecture);
}
args.Add($"--platform={compilerPlatform}");
if (platformProvider.target != BuildTarget.Android)
{
args.Add($"--architecture={compilerArchitecture}");
}
}
var additionalArgs = System.Environment.GetEnvironmentVariable("UNITYLINKER_ADDITIONAL_ARGS");
if (!string.IsNullOrEmpty(additionalArgs))
{
args.Add(additionalArgs);
}
additionalArgs = Debug.GetDiagnosticSwitch("VMUnityLinkerAdditionalArgs") as string;
if (!string.IsNullOrEmpty(additionalArgs))
{
args.Add(additionalArgs.Trim('\''));
}
return(RunAssemblyLinker(args, out output, out error, linkerPath, workingDirectory));
}
public override void OnEnable(PlayerSettingsEditor settingsEditor)
{
this.m_AndroidBundleVersionCode = settingsEditor.FindPropertyAssert("AndroidBundleVersionCode");
this.m_AndroidKeystoreName = settingsEditor.FindPropertyAssert("AndroidKeystoreName");
this.m_AndroidKeyaliasName = settingsEditor.FindPropertyAssert("AndroidKeyaliasName");
this.m_AndroidMinSdkVersion = settingsEditor.FindPropertyAssert("AndroidMinSdkVersion");
this.m_AndroidPreferredInstallLocation = settingsEditor.FindPropertyAssert("AndroidPreferredInstallLocation");
this.m_AndroidSplashScreenScale = settingsEditor.FindPropertyAssert("AndroidSplashScreenScale");
this.m_AndroidTargetDevice = settingsEditor.FindPropertyAssert("AndroidTargetDevice");
this.m_AndroidTVCompatibility = settingsEditor.FindPropertyAssert("AndroidTVCompatibility");
this.m_AndroidIsGame = settingsEditor.FindPropertyAssert("AndroidIsGame");
this.m_AndroidEnableBanner = settingsEditor.FindPropertyAssert("androidEnableBanner");
this.m_AndroidGamepadSupportLevel = settingsEditor.FindPropertyAssert("androidGamepadSupportLevel");
this.m_APKExpansionFiles = settingsEditor.FindPropertyAssert("APKExpansionFiles");
this.m_ForceInternetPermission = settingsEditor.FindPropertyAssert("ForceInternetPermission");
this.m_ForceSDCardPermission = settingsEditor.FindPropertyAssert("ForceSDCardPermission");
this.m_AndroidSplashScreen = settingsEditor.FindPropertyAssert("androidSplashScreen");
this.m_SettingsEditor = settingsEditor;
}
private static void RunAssemblyStripper(IEnumerable assemblies, string managedAssemblyFolderPath, string[] assembliesToStrip, string[] searchDirs, string monoLinkerPath, IIl2CppPlatformProvider platformProvider, RuntimeClassRegistry rcr)
{
string output;
string error;
var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(platformProvider.target);
bool isMono = PlayerSettings.GetScriptingBackend(buildTargetGroup) == ScriptingImplementation.Mono2x;
bool stripEngineCode = rcr != null && PlayerSettings.stripEngineCode && platformProvider.supportsEngineStripping;
IEnumerable <string> blacklists = Il2CppBlacklistPaths;
if (rcr != null)
{
blacklists = blacklists.Concat(new[] {
WriteMethodsToPreserveBlackList(rcr, platformProvider.target),
WriteUnityEngineBlackList(),
MonoAssemblyStripping.GenerateLinkXmlToPreserveDerivedTypes(managedAssemblyFolderPath, rcr)
});
}
if (PlayerSettingsEditor.IsLatestApiCompatibility(PlayerSettings.GetApiCompatibilityLevel(buildTargetGroup)))
{
var il2cppFolder = Path.Combine(platformProvider.il2CppFolder, "LinkerDescriptors");
blacklists = blacklists.Concat(Directory.GetFiles(il2cppFolder, "*45.xml"));
}
if (isMono)
{
// Apply mono-specific assembly whitelists, taken from old Mono assembly stripping code path.
var il2cppFolder = Path.Combine(platformProvider.il2CppFolder, "LinkerDescriptors");
blacklists = blacklists.Concat(Directory.GetFiles(il2cppFolder, "*_mono.xml"));
// The old Mono assembly stripper uses per-platform link.xml files if available. Apply these here.
var platformDescriptor = Path.Combine(BuildPipeline.GetBuildToolsDirectory(platformProvider.target), "link.xml");
if (File.Exists(platformDescriptor))
{
blacklists = blacklists.Concat(new[] { platformDescriptor });
}
}
if (!stripEngineCode)
{
// if we don't do stripping, add all modules blacklists.
foreach (var file in Directory.GetFiles(platformProvider.moduleStrippingInformationFolder, "*.xml"))
{
blacklists = blacklists.Concat(new[] { file });
}
}
var tempStripPath = Path.GetFullPath(Path.Combine(managedAssemblyFolderPath, "tempStrip"));
bool addedMoreBlacklists;
do
{
addedMoreBlacklists = false;
if (EditorUtility.DisplayCancelableProgressBar("Building Player", "Stripping assemblies", 0.0f))
{
throw new OperationCanceledException();
}
if (!StripAssembliesTo(
assembliesToStrip,
searchDirs,
tempStripPath,
managedAssemblyFolderPath,
out output,
out error,
monoLinkerPath,
platformProvider,
blacklists))
{
throw new Exception("Error in stripping assemblies: " + assemblies + ", " + error);
}
if (platformProvider.supportsEngineStripping)
{
var icallSummaryPath = Path.Combine(managedAssemblyFolderPath, "ICallSummary.txt");
GenerateInternalCallSummaryFile(icallSummaryPath, managedAssemblyFolderPath, tempStripPath);
if (stripEngineCode)
{
// Find which modules we must include in the build based on Assemblies
HashSet <UnityType> nativeClasses;
HashSet <string> nativeModules;
CodeStrippingUtils.GenerateDependencies(tempStripPath, icallSummaryPath, rcr, stripEngineCode, out nativeClasses, out nativeModules, platformProvider);
// Add module-specific blacklists.
addedMoreBlacklists = AddWhiteListsForModules(nativeModules, ref blacklists, platformProvider.moduleStrippingInformationFolder);
}
}
// If we had to add more whitelists, we need to run AssemblyStripper again with the added whitelists.
}while (addedMoreBlacklists);
// keep unstripped files for debugging purposes
var tempUnstrippedPath = Path.GetFullPath(Path.Combine(managedAssemblyFolderPath, "tempUnstripped"));
if (debugUnstripped)
{
Directory.CreateDirectory(tempUnstrippedPath);
}
foreach (var file in Directory.GetFiles(managedAssemblyFolderPath))
{
var extension = Path.GetExtension(file);
if (string.Equals(extension, ".dll", StringComparison.InvariantCultureIgnoreCase) ||
string.Equals(extension, ".winmd", StringComparison.InvariantCultureIgnoreCase) ||
string.Equals(extension, ".mdb", StringComparison.InvariantCultureIgnoreCase) ||
string.Equals(extension, ".pdb", StringComparison.InvariantCultureIgnoreCase))
{
if (debugUnstripped)
{
File.Move(file, Path.Combine(tempUnstrippedPath, Path.GetFileName(file)));
}
else
{
File.Delete(file);
}
}
}
foreach (var file in Directory.GetFiles(tempStripPath))
{
File.Move(file, Path.Combine(managedAssemblyFolderPath, Path.GetFileName(file)));
}
Directory.Delete(tempStripPath);
}
public virtual void OnEnable(PlayerSettingsEditor settingsEditor)
{
}
private string ProjectHeader(MonoIsland island,
IEnumerable <ResponseFileData> responseFilesData)
{
string targetframeworkversion = "v3.5";
string targetLanguageVersion = "4";
string toolsversion = "4.0";
string productversion = "10.0.20506";
string baseDirectory = ".";
string cscToolPath = "$(CscToolPath)";
string cscToolExe = "$(CscToolExe)";
ScriptingLanguage language = ScriptingLanguageFor(island);
if (PlayerSettingsEditor.IsLatestApiCompatibility(island._api_compatibility_level))
{
targetframeworkversion = "v4.7.1";
targetLanguageVersion = "latest";
cscToolPath = Paths.Combine(EditorApplication.applicationContentsPath, "Tools", "RoslynScripts");
if (Application.platform == RuntimePlatform.WindowsEditor)
{
cscToolExe = "unity_csc.bat";
}
else
{
cscToolExe = "unity_csc.sh";
}
cscToolPath = Paths.UnifyDirectorySeparator(cscToolPath);
}
else if (_settings.VisualStudioVersion == 9)
{
toolsversion = "3.5";
productversion = "9.0.21022";
}
var arguments = new object[]
{
toolsversion, productversion, ProjectGuid(island._output),
_settings.EngineAssemblyPath,
_settings.EditorAssemblyPath,
string.Join(";", new[] { "DEBUG", "TRACE" }.Concat(island._defines).Concat(responseFilesData.SelectMany(x => x.Defines)).Distinct().ToArray()),
MSBuildNamespaceUri,
Utility.FileNameWithoutExtension(island._output),
EditorSettings.projectGenerationRootNamespace,
targetframeworkversion,
targetLanguageVersion,
baseDirectory,
island._allowUnsafeCode | responseFilesData.Any(x => x.Unsafe),
cscToolPath,
cscToolExe,
};
try
{
return(string.Format(_settings.GetProjectHeaderTemplate(language), arguments));
}
catch (Exception)
{
throw new System.NotSupportedException("Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " + arguments.Length);
}
}
public override void ShowPlatformBuildOptions()
{
int iOSBuildConfigType = (int)EditorUserBuildSettings.iOSBuildConfigType;
EditorUserBuildSettings.iOSBuildConfigType = (iOSBuildType)PlayerSettingsEditor.BuildEnumPopup <iOSBuildType>(EditorGUIUtility.TextContent("Run in Xcode as"), iOSBuildConfigType, kOptionsOrder, kOptionDescriptions);
}
private void DrawLaunchScreenGUI(LaunchScreenProperties properties, UnityEditor.iOS.DeviceType device)
{
PlayerSettingsEditor.BuildEnumPopup <iOSLaunchScreenType>(properties.type, EditorGUIUtility.TextContent("Launch screen type"), kLaunchScreenTypeOrder, kLaunchScreenUIDescriptions);
iOSLaunchScreenType intValue = (iOSLaunchScreenType)properties.type.intValue;
switch (intValue)
{
case iOSLaunchScreenType.ImageAndBackgroundRelative:
case iOSLaunchScreenType.ImageAndBackgroundConstant:
if (device == UnityEditor.iOS.DeviceType.iPhone)
{
SettingsUI.Texture2DField(properties.portraitImage, EditorGUIUtility.TextContent("Portrait Image | Use only advanced type textures"));
SettingsUI.Texture2DField(properties.landscapeImage, EditorGUIUtility.TextContent("Landscape Image | Use only advanced type textures"));
}
if (device == UnityEditor.iOS.DeviceType.iPad)
{
SettingsUI.Texture2DField(properties.portraitAndLandscapeImage, EditorGUIUtility.TextContent("Image | Use only advanced type textures"));
}
EditorGUILayout.Space();
EditorGUILayout.PropertyField(properties.backgroundColor, EditorGUIUtility.TextContent("Background Color"), new GUILayoutOption[0]);
if (intValue == iOSLaunchScreenType.ImageAndBackgroundConstant)
{
GUIContent label = null;
if (device == UnityEditor.iOS.DeviceType.iPad)
{
label = EditorGUIUtility.TextContent("Size in points | Vertical in both portrait and landscape");
}
else
{
label = EditorGUIUtility.TextContent("Size in points | Horizontal in portrait, vertical in landscape");
}
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(properties.size, label, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck() && (properties.size.floatValue < 0f))
{
properties.size.floatValue = 0f;
}
}
else
{
GUIContent content2 = null;
if (device == UnityEditor.iOS.DeviceType.iPad)
{
content2 = EditorGUIUtility.TextContent("Fill percentage | Vertical in both portrait and landscape");
}
else
{
content2 = EditorGUIUtility.TextContent("Fill percentage | Horizontal in portrait, vertical in landscape");
}
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(properties.fillPercentage, content2, new GUILayoutOption[0]);
if (EditorGUI.EndChangeCheck())
{
if (properties.fillPercentage.floatValue < 1f)
{
properties.fillPercentage.floatValue = 1f;
}
else if (properties.fillPercentage.floatValue > 100f)
{
properties.fillPercentage.floatValue = 100f;
}
}
}
break;
default:
if (intValue == iOSLaunchScreenType.CustomXib)
{
PlayerSettingsEditor.BuildFileBoxButton(properties.customXibPath, LocalizationDatabase.GetLocalizedString("Custom Xib"), Application.dataPath, "xib", null);
}
break;
}
}
private static void RunAssemblyStripper(IEnumerable assemblies, string managedAssemblyFolderPath, string[] assembliesToStrip, string[] searchDirs, string monoLinkerPath, IIl2CppPlatformProvider platformProvider, RuntimeClassRegistry rcr)
{
BuildTargetGroup buildTargetGroup = BuildPipeline.GetBuildTargetGroup(platformProvider.target);
bool flag = PlayerSettings.GetScriptingBackend(buildTargetGroup) == ScriptingImplementation.Mono2x;
bool flag2 = rcr != null && PlayerSettings.stripEngineCode && platformProvider.supportsEngineStripping;
IEnumerable <string> enumerable = AssemblyStripper.Il2CppBlacklistPaths;
if (rcr != null)
{
enumerable = enumerable.Concat(new string[]
{
AssemblyStripper.WriteMethodsToPreserveBlackList(rcr, platformProvider.target),
AssemblyStripper.WriteUnityEngineBlackList(),
MonoAssemblyStripping.GenerateLinkXmlToPreserveDerivedTypes(managedAssemblyFolderPath, rcr)
});
}
if (PlayerSettingsEditor.IsLatestApiCompatibility(PlayerSettings.GetApiCompatibilityLevel(buildTargetGroup)))
{
string path = Path.Combine(platformProvider.il2CppFolder, "LinkerDescriptors");
enumerable = enumerable.Concat(Directory.GetFiles(path, "*45.xml"));
}
if (flag)
{
string path2 = Path.Combine(platformProvider.il2CppFolder, "LinkerDescriptors");
enumerable = enumerable.Concat(Directory.GetFiles(path2, "*_mono.xml"));
string text = Path.Combine(BuildPipeline.GetBuildToolsDirectory(platformProvider.target), "link.xml");
if (File.Exists(text))
{
enumerable = enumerable.Concat(new string[]
{
text
});
}
}
if (!flag2)
{
string[] files = Directory.GetFiles(platformProvider.moduleStrippingInformationFolder, "*.xml");
for (int i = 0; i < files.Length; i++)
{
string text2 = files[i];
enumerable = enumerable.Concat(new string[]
{
text2
});
}
}
string fullPath = Path.GetFullPath(Path.Combine(managedAssemblyFolderPath, "tempStrip"));
string text4;
while (true)
{
bool flag3 = false;
if (EditorUtility.DisplayCancelableProgressBar("Building Player", "Stripping assemblies", 0f))
{
break;
}
string text3;
if (!AssemblyStripper.StripAssembliesTo(assembliesToStrip, searchDirs, fullPath, managedAssemblyFolderPath, out text3, out text4, monoLinkerPath, platformProvider, enumerable))
{
goto Block_9;
}
if (platformProvider.supportsEngineStripping)
{
string text5 = Path.Combine(managedAssemblyFolderPath, "ICallSummary.txt");
AssemblyStripper.GenerateInternalCallSummaryFile(text5, managedAssemblyFolderPath, fullPath);
if (flag2)
{
HashSet <UnityType> hashSet;
HashSet <string> nativeModules;
CodeStrippingUtils.GenerateDependencies(fullPath, text5, rcr, flag2, out hashSet, out nativeModules, platformProvider);
flag3 = AssemblyStripper.AddWhiteListsForModules(nativeModules, ref enumerable, platformProvider.moduleStrippingInformationFolder);
}
}
if (!flag3)
{
goto Block_12;
}
}
throw new OperationCanceledException();
Block_9:
throw new Exception(string.Concat(new object[]
{
"Error in stripping assemblies: ",
assemblies,
", ",
text4
}));
Block_12:
string fullPath2 = Path.GetFullPath(Path.Combine(managedAssemblyFolderPath, "tempUnstripped"));
if (AssemblyStripper.debugUnstripped)
{
Directory.CreateDirectory(fullPath2);
}
string[] files2 = Directory.GetFiles(managedAssemblyFolderPath);
for (int j = 0; j < files2.Length; j++)
{
string text6 = files2[j];
string extension = Path.GetExtension(text6);
if (string.Equals(extension, ".dll", StringComparison.InvariantCultureIgnoreCase) || string.Equals(extension, ".winmd", StringComparison.InvariantCultureIgnoreCase) || string.Equals(extension, ".mdb", StringComparison.InvariantCultureIgnoreCase) || string.Equals(extension, ".pdb", StringComparison.InvariantCultureIgnoreCase))
{
if (AssemblyStripper.debugUnstripped)
{
File.Move(text6, Path.Combine(fullPath2, Path.GetFileName(text6)));
}
else
{
File.Delete(text6);
}
}
}
string[] files3 = Directory.GetFiles(fullPath);
for (int k = 0; k < files3.Length; k++)
{
string text7 = files3[k];
File.Move(text7, Path.Combine(managedAssemblyFolderPath, Path.GetFileName(text7)));
}
Directory.Delete(fullPath);
}
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();
}
public PlayerSettingsIconsEditor(PlayerSettingsEditor owner)
{
m_Owner = owner;
}
public virtual void OnEnable(PlayerSettingsEditor settingsEditor)
{
}
public virtual void OnEnable(PlayerSettingsEditor settingsEditor)
{
m_playerSettingsEditor = settingsEditor;
m_MTRendering = playerSettingsEditor.FindPropertyAssert("m_MTRendering");
}
public PlayerSettingsSplashScreenEditor(PlayerSettingsEditor owner)
{
m_Owner = owner;
}
public override void OnEnable(PlayerSettingsEditor settingsEditor)
{
this.m_SettingsEditor = settingsEditor;
this.m_GUIDefaultIsFullScreen = EditorGUIUtility.TextContent("Default Is Full Screen*");
this.m_CompanyName = settingsEditor.FindPropertyAssert("companyName");
this.m_ProductName = settingsEditor.FindPropertyAssert("productName");
this.m_DefaultIsFullScreen = settingsEditor.FindPropertyAssert("defaultIsFullScreen");
this.m_RunInBackground = settingsEditor.FindPropertyAssert("runInBackground");
this.m_MetroPackageName = settingsEditor.FindPropertyAssert("metroPackageName");
this.m_MetroPackageName.stringValue = Utility.TryValidatePackageName(this.m_MetroPackageName.stringValue);
this.m_MetroPackageVersion = settingsEditor.FindPropertyAssert("metroPackageVersion");
this.m_MetroPackageVersion.stringValue = PlayerSettings.WSA.ValidatePackageVersion(this.m_MetroPackageVersion.stringValue);
this.m_MetroApplicationDescription = settingsEditor.FindPropertyAssert("metroApplicationDescription");
this.m_MetroApplicationDescription.stringValue = this.ValidateMetroApplicationDescription(this.m_MetroApplicationDescription.stringValue);
this.m_MetroTileShortName = settingsEditor.FindPropertyAssert("metroTileShortName");
this.m_MetroTileShortName.stringValue = this.ValidateMetroTileShortName(this.m_MetroTileShortName.stringValue);
this.m_MetroTileBackgroundColor = settingsEditor.FindPropertyAssert("metroTileBackgroundColor");
this.m_MetroFTAName = settingsEditor.FindPropertyAssert("metroFTAName");
this.m_MetroFTAFileTypes = settingsEditor.FindPropertyAssert("metroFTAFileTypes");
this.m_MetroProtocolName = settingsEditor.FindPropertyAssert("metroProtocolName");
PlayerSettings.WSAImageScale[] scales = new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale._80 };
PlayerSettings.WSAImageScale[] scaleArray2 = new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale._100 };
PlayerSettings.WSAImageScale[] scaleArray3 = new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale._100 };
this.m_PackageLogos = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.PackageLogo, new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale._100 }, "Scale {0}% ({1}x{2} pixels)|Specifies the image that appears on the Store description page for the product.", new int[] { 50, 0x3f, 70, 0x4b, 90, 100, 120, 200 });
MetroScaledImage[] sourceArray = CreateScaledSquareImages(PlayerSettings.WSAImageType.StoreTileSmallLogo, scales, "Scale {0}% ({1}x{2} pixels)|Specifies the image that is shown when viewing all installed applications.", new int[] { 0x18, 30, 0x2a, 0x36 });
MetroScaledImage[] imageArray2 = CreateScaledSquareImages(PlayerSettings.WSAImageType.StoreTileSmallLogo, new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale.Target16 }, "Target size {0} ({1}x{2} pixels)|Specifies the image that is shown when viewing all installed applications.", new int[] { 0x10, 0x20, 0x30, 0x100 });
MetroScaledImage[] destinationArray = new MetroScaledImage[sourceArray.Length + imageArray2.Length];
Array.Copy(sourceArray, destinationArray, sourceArray.Length);
Array.Copy(imageArray2, 0, destinationArray, sourceArray.Length, imageArray2.Length);
this.m_StoreSmallLogos = new MetroScaledImageGroup(destinationArray);
this.m_MediumTiles = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.StoreTileLogo, scales, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile in Windows.", new int[] { 120, 150, 210, 270 });
this.m_WideTiles = CreateScaledImageGroup(PlayerSettings.WSAImageType.StoreTileWideLogo, scales, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's wide tile in Windows if supported.", new int[] { 0xf8, 310, 0x1b2, 0x22e }, new int[] { 120, 150, 210, 270 });
this.m_SmallTiles = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.StoreSmallTile, scales, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's small tile in Windows if supported.", new int[] { 0x38, 70, 0x62, 0x7e });
this.m_LargeTiles = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.StoreLargeTile, scales, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's large tile in Windows if supported.", new int[] { 0xf8, 310, 0x1b2, 0x22e });
this.m_PhoneAppIcons = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.PhoneAppIcon, scaleArray2, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's small tile.", new int[] { 0x2c, 0x3e, 0x6a });
this.m_PhoneSmallTiles = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.PhoneSmallTile, scaleArray2, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's small tile", new int[] { 0x47, 0x63, 170 });
this.m_PhoneMediumTiles = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.PhoneMediumTile, scaleArray2, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 150, 210, 360 });
this.m_PhoneWideTiles = CreateScaledImageGroup(PlayerSettings.WSAImageType.PhoneWideTile, scaleArray2, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's wide tile.", new int[] { 310, 0x1b2, 0x2e8 }, new int[] { 150, 210, 360 });
MetroScaledImage[] imageArray4 = CreateScaledSquareImages(PlayerSettings.WSAImageType.UWPSquare44x44Logo, scaleArray3, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 0x2c, 0x37, 0x42, 0x58, 0xb0 });
MetroScaledImage[] imageArray5 = CreateScaledSquareImages(PlayerSettings.WSAImageType.UWPSquare44x44Logo, new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale.Target16 }, "Target size {0} ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 0x10, 0x18, 0x30, 0x100 });
MetroScaledImage[] imageArray6 = new MetroScaledImage[imageArray4.Length + imageArray5.Length];
Array.Copy(imageArray4, imageArray6, imageArray4.Length);
Array.Copy(imageArray5, 0, imageArray6, imageArray4.Length, imageArray5.Length);
this.m_UWPSquare44x44Logos = new MetroScaledImageGroup(imageArray6);
this.m_UWPSquare71x71Logos = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.UWPSquare71x71Logo, scaleArray3, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 0x47, 0x59, 0x6b, 0x8e, 0x11c });
this.m_UWPSquare150x150Logos = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.UWPSquare150x150Logo, scaleArray3, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 150, 0xbc, 0xe1, 300, 600 });
this.m_UWPSquare310x310Logos = CreateScaledSquareImageGroup(PlayerSettings.WSAImageType.UWPSquare310x310Logo, scaleArray3, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 310, 0x184, 0x1d1, 620, 0x4d8 });
this.m_UWPWide310x150Logos = CreateScaledImageGroup(PlayerSettings.WSAImageType.UWPWide310x150Logo, scaleArray3, "Scale {0}% ({1}x{2} pixels)|Specifies the image to display on the app's tile.", new int[] { 310, 0x184, 0x1d1, 620, 0x4d8 }, new int[] { 150, 0xbc, 0xe1, 300, 600 });
this.m_WindowsSplashScreens = CreateScaledImages(PlayerSettings.WSAImageType.SplashScreenImage, new PlayerSettings.WSAImageScale[] { PlayerSettings.WSAImageScale._100 }, "Scale {0}% ({1}x{2} pixels)|Sets the foreground image for the app's splash screen.", new int[] { 620, 0x307, 0x364, 930, 0x45c, 0x4d8, 0x9b0 }, new int[] { 300, 0x177, 420, 450, 540, 600, 0x4b0 });
this.m_PhoneSplashScreens = CreateScaledImages(PlayerSettings.WSAImageType.PhoneSplashScreen, scaleArray2, "Scale {0}% ({1}x{2} pixels)|Sets the foreground image for the app's splash screen.", new int[] { 480, 0x2a0, 0x480 }, new int[] { 800, 0x460, 0x780 });
this.m_HolographicSplashScreen = settingsEditor.FindPropertyAssert("m_VirtualRealitySplashScreen");
this.m_HolographicPauseOnTrackingLoss = settingsEditor.FindPropertyAssert("m_HolographicPauseOnTrackingLoss");
this.m_HolographicTrackingLossScreen = settingsEditor.FindPropertyAssert("m_HolographicTrackingLossScreen");
}
