public void RefreshConfig(LocalizationType type, bool isDebug, BuildPlatform platform)
{
string isDebugStr = isDebug ? "_debug.xml" : "_release.xml";
//TODO Fix me
string path = Application.dataPath + "/../../Settings/BuildSettings/jenkins_" + platform.ToString() + "_" + type.ToString() + isDebugStr;
RefreshConfig(path);
}
static void CreateDirectory(BuildPlatform platform)
{
// ビルドするために必要な設定を行う（ディレクトリの作成等）
var dirBuild = Path.Combine( Application.dataPath.Replace("Assets", ""), "Build");
var dir = "";
if (Directory.Exists(dirBuild) == false) {
Directory.CreateDirectory(dirBuild);
}
// Win32
if ((platform & BuildPlatform.Win) != 0) {
dir = Path.Combine( dirBuild+"/", "Win");
if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);
}
// Win64
if ((platform & BuildPlatform.Win64) != 0) {
dir = Path.Combine( dirBuild+"/", "Win64");
if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);
}
// Mac OSX
if ((platform & BuildPlatform.OSX) != 0) {
dir = Path.Combine( dirBuild+"/", "OSX-Intel");
if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);
}
// iOS
if ((platform & BuildPlatform.iOS) != 0) {
dir = Path.Combine( dirBuild+"/", "iOS");
if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);
}
// Android
if ((platform & BuildPlatform.Android) != 0) {
dir = Path.Combine( dirBuild+"/", "Android");
if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);
}
// WebPlayer
if ((platform & BuildPlatform.Web) != 0) {
dir = Path.Combine( dirBuild+"/", "Web");
if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);
}
// WebPlayer(Streamed)
if ((platform & BuildPlatform.WebStreamed) != 0) {
dir = Path.Combine( dirBuild+"/", "WebStreamed");
if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);
}
}
/// <summary>
/// Starts building game for the specified platform.
/// </summary>
/// <param name="platform">The target platform.</param>
/// <param name="options">The build options.</param>
/// <param name="outputPath">The output path (output directory).</param>
/// <param name="defines">Scripts compilation define symbols (macros).</param>
public static void Build(BuildPlatform platform, BuildOptions options, string outputPath, string[] defines = null)
{
if (IsRunning)
{
throw new InvalidOperationException("Cannot start build while already running.");
}
if (string.IsNullOrEmpty(outputPath))
{
throw new ArgumentNullException(nameof(outputPath));
}
// Cache options (reuse them for build step events)
_lastOptions.Platform = platform;
_lastOptions.Flags = options;
_lastOptions.OutputPath = StringUtils.ConvertRelativePathToAbsolute(Globals.ProjectFolder, StringUtils.NormalizePath(outputPath));
_lastOptions.Defines = defines;
Internal_Build(platform, options, outputPath, defines);
}
/// <summary>
/// Gets the type of the platform from the game build platform type.
/// </summary>
/// <param name="buildPlatform">The build platform.</param>
/// <returns>The run-type platform type.</returns>
public static PlatformType GetPlatformType(BuildPlatform buildPlatform)
{
switch (buildPlatform)
{
case BuildPlatform.Windows32:
case BuildPlatform.Windows64: return(PlatformType.Windows);
case BuildPlatform.WindowsStoreX86:
case BuildPlatform.WindowsStoreX64: return(PlatformType.WindowsStore);
case BuildPlatform.XboxOne: return(PlatformType.XboxOne);
case BuildPlatform.LinuxX64: return(PlatformType.Linux);
case BuildPlatform.PS4: return(PlatformType.PS4);
default: throw new ArgumentOutOfRangeException(nameof(buildPlatform), buildPlatform, null);
}
}
public static bool BuildTargetSupportsRenderer(BuildPlatform platform, GraphicsDeviceType type)
{
BuildTarget buildTarget = platform.defaultTarget;
if (platform.targetGroup == BuildTargetGroup.Standalone)
{
buildTarget = DesktopStandaloneBuildWindowExtension.GetBestStandaloneTarget(buildTarget);
}
foreach (int var in GetRenderList(buildTarget))
{
if ((GraphicsDeviceType)var == type)
{
return(true);
}
}
return(false);
}
public override void PerBuildExecute(BuildReleaseType releaseType, BuildPlatform platform, BuildArchitecture architecture, BuildDistribution distribution, System.DateTime buildTime, ref BuildOptions options, string configKey, string buildPath)
{
// Verify that butler executable exists.
if (!File.Exists(pathToButlerExe))
{
UnityEngine.Debug.LogError("Couldn't find butler.exe file at path \"" + pathToButlerExe + "\", please check provided path");
return;
}
buildPath = Path.GetFullPath(buildPath);
// Generate build args for the form: butler push {optional args} {build path} {itch username}/{itch game}:{channel}
StringBuilder scriptArguments = new StringBuilder("push ");
switch (architecture.target)
{
case BuildTarget.StandaloneOSX:
#if !UNITY_2019_2_OR_NEWER
case BuildTarget.StandaloneLinux:
case BuildTarget.StandaloneLinuxUniversal:
#endif
case BuildTarget.StandaloneLinux64:
// Fix exe permissions for Linux/OSX.
scriptArguments.Append("--fix-permissions ");
break;
}
if (useGeneratedBuildVersion)
{
// Append generated versions string.
scriptArguments.Append(string.Format("--userversion \"{0}\" ", BuildSettings.productParameters.buildVersion));
}
scriptArguments.Append("\"" + buildPath + "\"" + " " + nameOfItchUser + "/" + nameOfItchGame + ":");
scriptArguments.Append(!string.IsNullOrEmpty(itchChannelOverride) ?
itchChannelOverride :
GetChannelName(channelName, architecture.target, releaseType)
);
// UnityEngine.Debug.Log("Would have run itch uploader with following command line: \"" + pathToButlerExe + " " + scriptArguments + "\"");
RunScript(pathToButlerExe, scriptArguments.ToString());
}
void ShowOption(BuildPlatform bp, GUIContent title, GUIStyle background)
{
Rect r = GUILayoutUtility.GetRect(50, 36);
r.x += 1;
r.y += 1;
bool valid = BuildPipeline.LicenseCheck(bp.defaultTarget);
GUI.contentColor = new Color(1, 1, 1, valid ? 1 : .7f);
bool enabled = EditorUserBuildSettings.selectedBuildTargetGroup == bp.targetGroup;
if (Event.current.type == EventType.Repaint)
{
background.Draw(r, GUIContent.none, false, false, enabled, false);
GUI.Label(new Rect(r.x + 3, r.y + 3, 32, 32), title.image, GUIStyle.none);
if (EditorUserBuildSettings.activeBuildTargetGroup == bp.targetGroup)
{
GUI.Label(new Rect(r.xMax - styles.activePlatformIcon.width - 8, r.y + 3 + (32 - styles.activePlatformIcon.height) / 2,
styles.activePlatformIcon.width, styles.activePlatformIcon.height),
styles.activePlatformIcon, GUIStyle.none);
}
}
if (GUI.Toggle(r, enabled, title.text, styles.platformSelector))
{
if (EditorUserBuildSettings.selectedBuildTargetGroup != bp.targetGroup)
{
EditorUserBuildSettings.selectedBuildTargetGroup = bp.targetGroup;
// Repaint inspectors, as they may be showing platform target specific things.
Object[] inspectors = Resources.FindObjectsOfTypeAll(typeof(InspectorWindow));
for (int i = 0; i < inspectors.Length; i++)
{
InspectorWindow inspector = inspectors[i] as InspectorWindow;
if (inspector != null)
{
inspector.Repaint();
}
}
}
}
}
public Inputs()
{
string[] cmdArgs = Environment.GetCommandLineArgs();
for (int i = 0; i < cmdArgs.Length; i++)
{
if (cmdArgs[i].Equals("-buildPlatform"))
{
buildPlatform = (BuildPlatform)Enum.Parse(typeof(BuildPlatform), cmdArgs[i + 1]);
}
if (cmdArgs[i].Equals("-androidSdkPath"))
{
androidSdkPath = cmdArgs[i + 1];
}
if (cmdArgs[i].Equals("-androidJdkPath"))
{
androidJdkPath = cmdArgs[i + 1];
}
if (cmdArgs[i].Equals("-androidNdkPath"))
{
androidNdkPath = cmdArgs[i + 1];
}
if (cmdArgs[i].Equals("-buildOutput"))
{
buildOutput = cmdArgs[i + 1];
}
if (cmdArgs[i].Equals("-androidKeystorePath"))
{
androidKeystorePath = cmdArgs[i + 1];
}
if (cmdArgs[i].Equals("-androidKeystoreAlias"))
{
androidKeystoreAlias = cmdArgs[i + 1];
}
if (cmdArgs[i].Equals("-androidKeystorePassword"))
{
androidKeystorePassword = cmdArgs[i + 1];
}
if (cmdArgs[i].Equals("-androidKeystoreAliasPassword"))
{
androidKeystoreAliasPassword = cmdArgs[i + 1];
}
}
}
public static bool IsPlatform(BuildPlatform platform)
{
switch (platform)
{
case BuildPlatform.Windows:
return(IsWindows);
case BuildPlatform.Ubuntu:
return(IsUbuntu);
case BuildPlatform.OSX:
return(IsOSX);
case BuildPlatform.FreeBSD:
return(IsFreeBSD);
case BuildPlatform.CentOS:
return(IsCentOS);
case BuildPlatform.RHEL:
return(IsRHEL);
case BuildPlatform.Debian:
return(IsDebian);
case BuildPlatform.Fedora:
return(IsFedora);
case BuildPlatform.OpenSuse:
return(IsOpenSuse);
case BuildPlatform.Unix:
return(IsUnix);
case BuildPlatform.Linux:
return(IsLinux);
default:
throw new Exception("Unrecognized Platform.");
}
}
static bool PlatformFromTarget(BuildTarget target, out BuildPlatform platform)
{
switch (target)
{
case BuildTarget.iOS:
platform = BuildPlatform.iOS;
return(true);
case BuildTarget.tvOS:
platform = BuildPlatform.tvOS;
return(true);
case BuildTarget.StandaloneOSX:
platform = BuildPlatform.MacOS;
return(true);
default:
platform = BuildPlatform.iOS;
return(false);
}
}
private static string EnvVarToString(string varString, BuildPlatform platform)
{
switch (varString)
{
case "DataPath":
return(Application.dataPath);
case "PersistentDataPath":
return(Application.persistentDataPath);
case "StreamingAssetsPath":
return(Application.streamingAssetsPath);
case "Platform":
return(platform.ToString());
default:
Debug.LogError("Cannot solve enviroment var " + varString);
return("");
}
}
public static void SetAssetBundleBuildOutput()
{
BuildPlatform build_platform = BuildConfiger.BundleBuildTarget;
string build_target_string = build_platform.ToString();
//string build_output = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
string build_output = "$(Personal)";
string download_url = "";
// Joe Li: don't use '~', it only works in shell.
build_output += "/LTSites/" + "$(Version)/$(Platform)";
download_url += build_target_string;
if (BuildConfiger.BuildOutputStr != build_output || DownloadConfiger.downloadUrl != download_url)
{
DownloadConfiger.downloadUrl = download_url;
BuildConfiger.BuildOutputStr = build_output;
EB.Debug.Log("Output: {0}=>{1}", build_output, BuildConfiger.InterpretedOutputPath);
EB.Debug.Log("Download: {0}", download_url);
}
}
public override void PerBuildExecute(BuildReleaseType releaseType, BuildPlatform platform, BuildArchitecture architecture, BuildDistribution distribution, DateTime buildTime, ref BuildOptions options, string configKey, string buildPath)
{
string resolvedInputPath = FileUtility.ResolvePerBuildPath(inputPath, releaseType, platform, architecture, distribution, buildTime, buildPath);
string resolvedOutputPath = FileUtility.ResolvePerBuildPath(outputPath, releaseType, platform, architecture, distribution, buildTime, buildPath);
switch (operation)
{
case Operation.Copy:
Copy(resolvedInputPath, resolvedOutputPath);
break;
case Operation.Move:
Move(resolvedInputPath, resolvedOutputPath);
break;
case Operation.Delete:
Delete(resolvedInputPath);
break;
}
AssetDatabase.Refresh();
}
public static BuildTarget CalculateSelectedBuildTarget()
{
BuildTargetGroup targetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
switch (targetGroup)
{
case BuildTargetGroup.Standalone:
return(DesktopStandaloneBuildWindowExtension.GetBestStandaloneTarget(EditorUserBuildSettings.selectedStandaloneTarget));
default:
if (BuildPlatforms.instance == null)
{
throw new System.Exception("Build platforms are not initialized.");
}
BuildPlatform platform = BuildPlatforms.instance.BuildPlatformFromTargetGroup(targetGroup);
if (platform == null)
{
throw new System.Exception("Could not find build platform for target group " + targetGroup);
}
return(platform.defaultTarget);
}
}
void Configure(Rect popoverPosition, OnSelectedItem selectedItemCallback, Styling style, BuildPlatform platform)
{
_xcodeFinder = new XcodeSDKFinder(platform);
var minWidth = style.MaxLabelWidth(_xcodeFinder.FrameworkNames, popoverPosition.width) + 40;
var width = popoverPosition.width;
_platform = platform;
if (minWidth > popoverPosition.width)
{
width = Mathf.Max(minWidth, popoverPosition.width);
float delta = (minWidth - popoverPosition.width) * 0.5f;
popoverPosition.x -= delta;
}
var size = new Vector2(width, popoverPosition.height);
popoverPosition.width = popoverPosition.height = 0;
_onSelectedItem = selectedItemCallback;
_style = style;
ShowAsDropDown(popoverPosition, size);
}
public override void PerBuildExecute(BuildReleaseType releaseType, BuildPlatform platform, BuildArchitecture architecture, BuildDistribution distribution, System.DateTime buildTime, ref BuildOptions options, string configKey, string buildPath)
{
// Verify that butler executable exists.
if (!File.Exists(pathTGJPushExe))
{
UnityEngine.Debug.LogError("Couldn't find gjpush.exe file at path \"" + pathTGJPushExe + "\", please check provided path");
return;
}
string resolvedOutputPath = Path.Combine(outputPath.Replace("$BUILDPATH", buildPath), outputFileName);
resolvedOutputPath = BuildProject.ResolvePath(resolvedOutputPath, releaseType, platform, architecture, distribution, buildTime);
if (!resolvedOutputPath.EndsWith(".zip"))
{
resolvedOutputPath += ".zip";
}
buildPath = Path.GetFullPath(buildPath);
string zip = Path.GetFullPath(resolvedOutputPath);
PerformZip(Path.GetFullPath(buildPath), Path.GetFullPath(resolvedOutputPath));
// Generate build args for the form: butler push {optional args} {build path} {itch username}/{itch game}:{channel}
StringBuilder scriptArguments = new StringBuilder("");
scriptArguments.Append(string.Format("-r {0} ", BuildSettings.productParameters.lastGeneratedVersion));
scriptArguments.Append("-g " + gameID + " -p " + packageID + " ");
if (BrowserBuild)
{
scriptArguments.Append("-b ");
}
scriptArguments.Append("\"" + zip + "\"");
// UnityEngine.Debug.Log("Would have run itch uploader with following command line: \"" + pathToButlerExe + " " + scriptArguments + "\"");
UnityEngine.Debug.Log(scriptArguments.ToString());
RunScript(pathTGJPushExe, scriptArguments.ToString());
}
private void Build(BuildPlatform platform, BuildArchitecture arch)
{
if (!platform.enabled || !arch.enabled)
{
return;
}
// Resolve build path.
StringBuilder platformBundlePath = new StringBuilder(Path.Combine(baseBuildPath, innerBuildPath));
platformBundlePath.Replace("$PLATFORM", BuildProject.SanitizeFolderName(platform.platformName));
platformBundlePath.Replace("$ARCHITECTURE", BuildProject.SanitizeFolderName(arch.name));
// Create build destination directory if it does not exist.
if (!Directory.Exists(platformBundlePath.ToString()))
{
Directory.CreateDirectory(platformBundlePath.ToString());
}
// Build AssetBundles.
BuildPipeline.BuildAssetBundles(platformBundlePath.ToString(), options, arch.target);
}
void OnGUI()
{
GUIStyle style = new GUIStyle();
style.fontSize = 18;
var color = GUI.backgroundColor;
using (var v = new EditorGUILayout.VerticalScope(GUI.skin.box))
{
GUILayout.Space(5);
using (var vv = new EditorGUILayout.VerticalScope(GUI.skin.box))
{
EditorGUILayout.LabelField("打包", style);
GUILayout.Space(5);
using (var h = new EditorGUILayout.HorizontalScope())
{
EditorGUILayout.LabelField("选择目标平台:", style);
GUILayout.Space(15);
this.platform = (BuildPlatform)EditorGUILayout.EnumPopup(this.platform);
}
GUILayout.Space(20);
GUI.backgroundColor = Color.green;
if (GUILayout.Button("开始打包", GUILayout.Height(30)))
{
if (EditorUtility.DisplayDialog("提示", "确认开始打包?", "确认"))
{
}
}
GUI.backgroundColor = color;
}
GUILayout.Space(10);
using (var vv = new EditorGUILayout.VerticalScope(GUI.skin.box))
{
EditorGUILayout.LabelField("打热更包", style);
GUILayout.Space(5);
}
}
}
public void SplashSectionGUI(BuildPlatform platform, BuildTargetGroup targetGroup, ISettingEditorExtension settingsExtension, int sectionIndex = 2)
{
if (m_Owner.BeginSettingsBox(sectionIndex, k_Texts.title))
{
ObjectReferencePropertyField <Texture2D>(m_VirtualRealitySplashScreen, k_Texts.vrSplashScreen);
if (TargetSupportsOptionalBuiltinSplashScreen(targetGroup, settingsExtension))
{
BuiltinCustomSplashScreenGUI();
}
if (settingsExtension != null)
{
settingsExtension.SplashSectionGUI();
}
if (m_ShowUnitySplashScreen.boolValue)
{
m_Owner.ShowSharedNote();
}
}
m_Owner.EndSettingsBox();
}
public static int GetGameCookCount(BuildPlatform platform)
{
Dictionary <BuildPlatform, FGameVersion> m_GameVersion = ReadGameVersion();
FGameVersion m_Version = null;
if (m_GameVersion.ContainsKey(platform) == false)
{
m_Version = new FGameVersion();
m_Version.build = 0;
m_Version.release_version = "1.1.0";
m_Version.development_version = "1.1.0";
m_Version.platform = (int)platform;
PlayerSettings.bundleVersion = m_Version.release_version;
m_GameVersion.Add(platform, m_Version);
}
else
{
m_Version = m_GameVersion[platform];
}
return(m_Version.build);
}
public XcodeChangeFile MergedChanges(BuildPlatform platform)
{
var configuration = _configurations.Configuration(platform);
string[] changeFiles;
//TODO this is a reason for the Platform Configuration to hold all the change files.
if (configuration.ActiveConfiguration == PlatformConfiguration.DEFAULT_CONFIG_NAME)
{
changeFiles = ChangeFiles(platform);
}
else
{
changeFiles = configuration.ChangeFilesInConfiguration(configuration.ActiveConfiguration);
}
XcodeChangeFile merged = new XcodeChangeFile();
merged.Platform = platform;
if (changeFiles == null || changeFiles.Length == 0)
{
return(merged);
}
foreach (var c in changeFiles)
{
XcodeChangeFile cf = XcodeChangeFile.Load(c);
if (cf != null)
{
merged.Merge(cf);
}
}
return(merged);
}
internal void OnGuiHorizontal(BuildPlatform platform)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.BeginVertical();
EditorGUIUtility.labelWidth = 140;
EditorGUILayout.LabelField(Styles.empty, EditorStyles.boldLabel);
OnFieldLabelsGUI(false);
EditorGUILayout.LabelField(Styles.empty, EditorStyles.boldLabel);
EditorGUILayout.LabelField(Styles.autoSettings, EditorStyles.boldLabel);
EditorGUILayout.EndVertical();
EditorGUIUtility.labelWidth = 50;
foreach (GraphicsTier tier in Enum.GetValues(typeof(GraphicsTier)))
{
bool autoSettings = EditorGraphicsSettings.AreTierSettingsAutomatic(platform.namedBuildTarget.ToBuildTargetGroup(), tier);
EditorGUILayout.BeginVertical();
EditorGUILayout.LabelField(Styles.tierName[(int)tier], EditorStyles.boldLabel);
using (new EditorGUI.DisabledScope(autoSettings))
OnTierGUI(platform, tier, false);
EditorGUILayout.LabelField(Styles.empty, EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
autoSettings = EditorGUILayout.Toggle(autoSettings);
if (EditorGUI.EndChangeCheck())
{
EditorGraphicsSettings.RegisterUndo();
EditorGraphicsSettings.MakeTierSettingsAutomatic(platform.namedBuildTarget.ToBuildTargetGroup(), tier, autoSettings);
EditorGraphicsSettings.OnUpdateTierSettings(platform.namedBuildTarget.ToBuildTargetGroup(), true);
}
EditorGUILayout.EndVertical();
}
EditorGUIUtility.labelWidth = 0;
EditorGUILayout.EndHorizontal();
}
public void SplashSectionGUI(BuildPlatform platform, BuildTargetGroup targetGroup, ISettingEditorExtension settingsExtension, int sectionIndex = 2)
{
if (m_Owner.BeginSettingsBox(sectionIndex, k_Texts.title))
{
if (targetGroup == BuildTargetGroup.Standalone)
{
ObjectReferencePropertyField <Texture2D>(m_ResolutionDialogBanner, k_Texts.configDialogBanner);
if (m_ResolutionDialogBanner.objectReferenceValue != null)
{
EditorGUILayout.HelpBox(k_Texts.configDialogBannerDeprecationWarning.text, MessageType.Warning, true);
}
EditorGUILayout.Space();
}
if (m_Owner.m_VRSettings.TargetGroupSupportsVirtualReality(targetGroup))
{
ObjectReferencePropertyField <Texture2D>(m_VirtualRealitySplashScreen, k_Texts.vrSplashScreen);
}
if (TargetSupportsOptionalBuiltinSplashScreen(targetGroup, settingsExtension))
{
BuiltinCustomSplashScreenGUI();
}
if (settingsExtension != null)
{
settingsExtension.SplashSectionGUI();
}
if (m_ShowUnitySplashScreen.boolValue)
{
m_Owner.ShowSharedNote();
}
}
m_Owner.EndSettingsBox();
}
private void OnGUI()
{
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
m_ExportAssetBundleDir = EditorGUILayout.TextField("AssetBundle导出目录:", m_ExportAssetBundleDir);
CreateOrExploreButton(m_ExportAssetBundleDir);
EditorGUILayout.EndHorizontal();
GUIContent[] guiObjs =
{
new GUIContent("PC"),
new GUIContent("Android"),
};
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
m_BuildPlatform = (BuildPlatform)GUILayout.Toolbar((int)m_BuildPlatform, guiObjs);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
if (m_BuildPlatform == BuildPlatform.StandaloneWindows)
{
ShowBuildUI("PC");
}
else if (m_BuildPlatform == BuildPlatform.Android)
{
ShowBuildUI("Android");
}
if (m_BuildPlatform != m_OldBuildPlatform)
{
m_VersionMap.Clear();
m_PatchMap.Clear();
}
m_OldBuildPlatform = m_BuildPlatform;
}
void Start()
{
#if !RECOURCE_CLIENT
foreach (ChannelConfig cc in sChannelConfigs.GetUnits().Values)
{
BuildPlatform bp = BuildPlatform.Windows;
if (cc.Platform == "android")
{
bp = BuildPlatform.Android;
}
else if (cc.Platform == "ios")
{
bp = BuildPlatform.Ios;
}
BuildGroup bg = sBuildSettings.BuildGroups[(int)bp];
bool exist = false;
foreach (BuildChannel bc in bg.Channels)
{
if (bc.ChannelName == cc.ChannelName)
{
exist = true;
break;
}
}
if (!exist)
{
BuildChannel bc = new BuildChannel();
bc.ChannelName = cc.ChannelName;
bg.Channels.Add(bc);
}
}
#endif
var a = sBuildSettings;
SaveSettings();
}
public static bool IsPlatform(BuildPlatform platform)
{
switch (platform)
{
case BuildPlatform.Windows:
return IsWindows;
case BuildPlatform.Ubuntu:
return IsUbuntu;
case BuildPlatform.OSX:
return IsOSX;
case BuildPlatform.CentOS:
return IsCentOS;
case BuildPlatform.RHEL:
return IsRHEL;
case BuildPlatform.Debian:
return IsDebian;
case BuildPlatform.Unix:
return IsUnix;
case BuildPlatform.Linux:
return IsLinux;
default:
throw new Exception("Unrecognized Platform.");
}
}
static BuildReportTool.SizePart[] GetAllUnusedAssets(
BuildReportTool.SizePart[] scriptDLLs,
string projectAssetsPath,
bool includeSvn, bool includeGit,
BuildPlatform buildPlatform,
bool includeUnusedPrefabs,
int fileCountBatchSkip, int fileCountLimit,
Dictionary<string, bool> usedAssetsDict,
List<BuildReportTool.SizePart> inOutAllUsedAssets)
{
List<BuildReportTool.SizePart> unusedAssets = new List<BuildReportTool.SizePart>();
// now loop through all assets in the whole project,
// check if that file exists in the usedAssetsDict,
// if not, include it in the unusedAssets list,
// then sort by size
int projectStringLen = projectAssetsPath.Length - "Assets".Length;
bool has32BitPluginsFolder = Directory.Exists(projectAssetsPath + "/Plugins/x86");
bool has64BitPluginsFolder = Directory.Exists(projectAssetsPath + "/Plugins/x86_64");
string currentAsset = "";
int assetIdx = 0;
int fileCountOffset = fileCountBatchSkip * fileCountLimit;
foreach (string fullAssetPath in DldUtil.TraverseDirectory.Do(projectAssetsPath))
{
++assetIdx;
if (assetIdx < fileCountOffset)
{
continue;
}
BRT_BuildReportWindow.GetValueMessage = "Getting list of used assets " + assetIdx + " ...";
//Debug.Log(fullAssetPath);
//string fullAssetPath = allAssets[assetIdx];
currentAsset = fullAssetPath;
currentAsset = currentAsset.Substring(projectStringLen, currentAsset.Length - projectStringLen);
// Unity .meta files are not considered part of the assets
// Unity .mask (Avatar masks): whether a .mask file is used or not currently cannot be reliably found out, so they are skipped
// anything in a /Resources/ folder will always be in the build, so don't bother checking for it
if (Util.IsFileOfType(currentAsset, ".meta") || Util.IsFileOfType(currentAsset, ".mask") || Util.IsFileInAPath(currentAsset, "/resources/"))
{
continue;
}
// include version control files only if requested to do so
if (!includeSvn && Util.IsFileInAPath(currentAsset, "/.svn/"))
{
continue;
}
if (!includeGit && Util.IsFileInAPath(currentAsset, "/.git/"))
{
continue;
}
// NOTE: if a .dll is present in the Script DLLs list, that means
// it is a managed DLL, and thus, is always used in the build
if (Util.IsFileOfType(currentAsset, ".dll"))
{
string assetFilenameOnly = Path.GetFileName(currentAsset);
//Debug.Log(assetFilenameOnly);
bool foundMatch = false;
// is current asset found in the script DLLs list?
for (int mdllIdx = 0; mdllIdx < scriptDLLs.Length; ++mdllIdx)
{
if (scriptDLLs[mdllIdx].Name == assetFilenameOnly)
{
// it's a managed DLL. Managed DLLs are always included in the build.
foundMatch = true;
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
break;
}
}
if (foundMatch)
{
continue;
}
}
// per platform special cases
// involving native plugins
// in windows and linux, the issue gets dicey as we have to check if its a 32 bit, 64 bit, or universal build
// so for windows/linux 32 bit, if Assets/Plugins/x86 exists, it will include all dll/so in those. if that folder does not exist, all dll/so in Assets/Plugins are included instead.
//
// what if there's a 64 bit dll/so in Assets/Plugins? surely it would not get included in a 32 bit build?
// for windows/linux 64 bit, if Assets/Plugins/x86_64 exists, it will include all dll/so in those. if that folder does not exist, all dll/so in Assets/Plugins are included instead.
// right now there is no such thing as a windows universal build
// For linux universal build, any .so in Assets/Plugins/x86 and Assets/Plugins/x86_64 are included. No .so in Assets/Plugins will be included (as it wouldn't be able to determine if such an .so in that folder is 32 or 64 bit) i.e. it relies on the .so being in the x86 or x86_64 subfolder to determine which is the 32 bit and which is the 64 bit version
// NOTE: in Unity 3.x there is no Linux build target, but there is Windows 32/64 bit
/*
from http://docs.unity3d.com/Documentation/Manual/PluginsForDesktop.html
On Windows and Linux, plugins can be managed manually (e.g, before building a 64-bit player, you copy the 64-bit library into the Assets/Plugins folder, and before building a 32-bit player, you copy the 32-bit library into the Assets/Plugins folder)
OR you can place the 32-bit version of the plugin in Assets/Plugins/x86 and the 64-bit version of the plugin in Assets/Plugins/x86_64.
By default the editor will look in the architecture-specific sub-directory first, and if that directory does not exist, it will use plugins from the root Assets/Plugins folder instead.
Note that for the Universal Linux build, you are required to use the architecture-specific sub-directories (when building a Universal Linux build, the Editor will not copy any plugins from the root Assets/Plugins folder).
For Mac OS X, you should build your plugin as a universal binary that contains both 32-bit and 64-bit architectures.
*/
switch (buildPlatform)
{
case BuildPlatform.Android:
// .jar files inside /Assets/Plugins/Android/ are always included in the build if built for Android
if (Util.IsFileInAPath(currentAsset, "assets/plugins/android/") && (Util.IsFileOfType(currentAsset, ".jar") || Util.IsFileOfType(currentAsset, ".so")))
{
//Debug.Log(".jar file in android " + currentAsset);
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
break;
case BuildPlatform.iOS:
if (Util.IsFileOfType(currentAsset, ".a") || Util.IsFileOfType(currentAsset, ".m") || Util.IsFileOfType(currentAsset, ".mm") || Util.IsFileOfType(currentAsset, ".c") || Util.IsFileOfType(currentAsset, ".cpp"))
{
// any .a, .m, .mm, .c, or .cpp files inside Assets/Plugins/iOS are automatically symlinked/used
if (Util.IsFileInAPath(currentAsset, "assets/plugins/ios/"))
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
}
// if there are any .a, .m, .mm, .c, or .cpp files outside of Assets/Plugins/iOS
// we can't determine if they are really used or not because the user may manually copy them to the Xcode project, or a post-process .sh script may copy them to the Xcode project.
// so we don't put them in the unused assets list
continue;
}
break;
case BuildPlatform.MacOSX32:
// when in mac build, .bundle files that are in Assets/Plugins are always included
// supposedly, Unity expects all .bundle files as universal builds (even if this is only a 32-bit build?)
if (Util.IsFileInAPath(currentAsset, "assets/plugins/") && Util.IsFileOfType(currentAsset, ".bundle"))
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
break;
case BuildPlatform.MacOSX64:
// when in mac build, .bundle files that are in Assets/Plugins are always included
// supposedly, Unity expects all .bundle files as universal builds (even if this is only a 64-bit build?)
if (Util.IsFileInAPath(currentAsset, "assets/plugins/") && Util.IsFileOfType(currentAsset, ".bundle"))
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
break;
case BuildPlatform.MacOSXUniversal:
// when in mac build, .bundle files that are in Assets/Plugins are always included
// supposedly, Unity expects all .bundle files as universal builds
if (Util.IsFileInAPath(currentAsset, "assets/plugins/") && Util.IsFileOfType(currentAsset, ".bundle"))
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
break;
case BuildPlatform.Windows32:
if (Util.IsFileOfType(currentAsset, ".dll"))
{
if (Util.IsFileInAPath(currentAsset, "assets/plugins/x86/"))
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
// Unity only makes use of Assets/Plugins/ if Assets/Plugins/x86/ does not exist
else if (Util.IsFileInAPath(currentAsset, "assets/plugins/") && !has32BitPluginsFolder)
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
}
break;
case BuildPlatform.Windows64:
if (Util.IsFileOfType(currentAsset, ".dll"))
{
if (Util.IsFileInAPath(currentAsset, "assets/plugins/x86_64/"))
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
// Unity only makes use of Assets/Plugins/ if Assets/Plugins/x86_64/ does not exist
else if (Util.IsFileInAPath(currentAsset, "assets/plugins/") && !has64BitPluginsFolder)
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
}
break;
case BuildPlatform.Linux32:
if (Util.IsFileOfType(currentAsset, ".so"))
{
if (Util.IsFileInAPath(currentAsset, "assets/plugins/x86/"))
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
// Unity only makes use of Assets/Plugins/ if Assets/Plugins/x86/ does not exist
else if (Util.IsFileInAPath(currentAsset, "assets/plugins/") && !has32BitPluginsFolder)
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
}
break;
case BuildPlatform.Linux64:
if (Util.IsFileOfType(currentAsset, ".so"))
{
if (Util.IsFileInAPath(currentAsset, "assets/plugins/x86_64/"))
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
// Unity only makes use of Assets/Plugins/ if Assets/Plugins/x86_64/ does not exist
else if (Util.IsFileInAPath(currentAsset, "assets/plugins/") && !has64BitPluginsFolder)
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
}
break;
case BuildPlatform.LinuxUniversal:
if (Util.IsFileOfType(currentAsset, ".so"))
{
if (Util.IsFileInAPath(currentAsset, "assets/plugins/x86/") || Util.IsFileInAPath(currentAsset, "assets/plugins/x86_64/"))
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
}
break;
}
// check prefabs only when requested to do so
if (Util.IsFileOfType(currentAsset, ".prefab"))
{
//Debug.Log("GetAllUnusedAssets: found prefab: " + Path.GetFileName(currentAsset));
if (!includeUnusedPrefabs)
{
continue;
}
}
// assets in StreamingAssets folder are always included
if (Util.IsFileInAPath(currentAsset, "assets/streamingassets"))
{
inOutAllUsedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
continue;
}
// if asset not in used assets list
if (!usedAssetsDict.ContainsKey(currentAsset))
{
// then that simply means this asset is unused
unusedAssets.Add(BuildReportTool.Util.CreateSizePartFromFile(currentAsset, fullAssetPath));
}
if (unusedAssets.Count >= fileCountLimit)
{
break;
}
}
return unusedAssets.ToArray();
}
static string GetPlatformFolderToCreate(BuildPlatform platform)
{
string folderCreated = "" ;
switch(platform)
{
case BuildPlatform.iOS:
{
folderCreated = "iOS" ;
}
break ;
case BuildPlatform.Android:
{
folderCreated = "Android" ;
}
break ;
case BuildPlatform.PC_x86:
{
folderCreated = "PC/x86" ;
}
break ;
case BuildPlatform.PC_x64:
{
folderCreated = "PC/x64" ;
}
break ;
case BuildPlatform.Mac_Intel:
{
folderCreated = "Mac/Intel/x86" ;
}
break ;
case BuildPlatform.Mac_Intel_64:
{
folderCreated = "Mac/Intel/x64" ;
}
break ;
case BuildPlatform.Mac_Universal:
{
folderCreated = "Mac/Universal" ;
}
break ;
}
return folderCreated ;
}
private IHttpWebRequest CreateRequest(BuildPlatform platforms, MemoryStream source, PlatformResources resources)
{
IHttpWebRequest request = _requestFactory.BuildRequest("POST", _serviceURL);
//add our headers
request.Accept = "application/json";
request.ContentType = String.Format("multipart/form-data; boundary={0}", BOUNDARY);
Dictionary<string, string> nameValues = new Dictionary<string, string>();
Dictionary<string, Tuple<string, MemoryStream>> nameStreams = new Dictionary<string, Tuple<string, MemoryStream>>();
nameValues.Add("email", _email);
nameValues.Add("password", _password);
source.Position = 0;
nameStreams.Add("src_zip", new Tuple<string, MemoryStream>("src.zip", source));
//Android
if ((platforms & BuildPlatform.Android) == BuildPlatform.Android)
{
resources.AndroidKeystore.Position = 0;
nameStreams.Add("and_keystore", new Tuple<string, MemoryStream>(resources.AndroidKeystoreFileName, resources.AndroidKeystore));
nameValues.Add("and_keypass", resources.AndroidKeyPassword);
nameValues.Add("and_storepass", resources.AndroidKeystorePassword);
nameValues.Add("and_keyalias", resources.AndroidKeyAlias);
}//end if
//iOS
if ((platforms & BuildPlatform.iOS) == BuildPlatform.iOS)
{
resources.iOSCertificate.Position = 0;
resources.iOSProfile.Position = 0;
nameStreams.Add("ios_certificate", new Tuple<string, MemoryStream>(resources.iOSCertificateFileName, resources.iOSCertificate));
nameStreams.Add("ios_profile", new Tuple<string, MemoryStream>(resources.iOSProfileFileName, resources.iOSProfile));
nameValues.Add("ios_password", resources.iOSCertificatePassword);
}//end if
//build the body
using (Stream s = request.GetRequestStream())
{
//add our form text values
foreach (String name in nameValues.Keys)
{
String line = String.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"\r\n\r\n{2}\r\n", BOUNDARY, name, nameValues[name]);
byte[] buff = Encoding.UTF8.GetBytes(line);
s.Write(buff, 0, buff.Length);
}//end foreach
//add our form files
foreach (String name in nameStreams.Keys)
{
String line = String.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\";filename=\"{2}\"\r\nContent-Type: application/base64\r\n\r\n", BOUNDARY, name, nameStreams[name].Item1);
//stream the description
byte[] buff = Encoding.UTF8.GetBytes(line);
s.Write(buff, 0, buff.Length);
//stream the file
buff = new byte[nameStreams[name].Item2.Length];
nameStreams[name].Item2.Read(buff, 0, buff.Length);
//buff = nameStreams[name].Item2.GetBuffer();//File.ReadAllBytes(namePaths[name]);
s.Write(buff, 0, buff.Length);
//stream endline
buff = Encoding.UTF8.GetBytes(Environment.NewLine);
s.Write(buff, 0, buff.Length);
}//end foreach
//end our form data
String endLine = String.Format("--{0}--", BOUNDARY);
byte[] endBuff = Encoding.UTF8.GetBytes(endLine);
s.Write(endBuff, 0, endBuff.Length);
}//end using
return request;
}
public Dictionary<BuildPlatform, System.IO.MemoryStream> BuildForPlatforms(BuildPlatform platforms, MemoryStream source, PlatformResources resources)
{
String platformString = "";
if ((platforms & (BuildPlatform.Android | BuildPlatform.iOS)) == (BuildPlatform.Android | BuildPlatform.iOS))
//Trace.TraceInformation("Building for Android and iOS");
//FireProgressEvent("Begin build iOS & Android", ProgressStatus.BEGIN);
platformString = "Android & iOS";
else if ((platforms & BuildPlatform.Android) == BuildPlatform.Android)
//Trace.TraceInformation("Building for Android");
//FireProgressEvent("Begin build Android", ProgressStatus.BEGIN);
platformString = "Android";
else if ((platforms & BuildPlatform.iOS) == BuildPlatform.iOS)
//Trace.TraceInformation("Building for iOS");
//FireProgressEvent("Begin build iOS", ProgressStatus.BEGIN);
platformString = "iOS";
else
throw new ArgumentException("unknown platform");
//create our POST request
IHttpWebRequest request = CreateRequest(platforms, source, resources);
request.Timeout = 600000;
JavaScriptSerializer jsSerializer = new JavaScriptSerializer();
FireProgressEvent(String.Format("Uploading - {0}", platformString));
//get the url to monitor for build progress
string monitorURL = null;
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
if (response.StatusCode != HttpStatusCode.OK)
{
String msg = String.Format("Failed to upload package. Status: {0}", response.StatusCode);
throw new BuildFailureException(msg);
}
FireProgressEvent("Upload success");
StringBuilder sb = new StringBuilder();
using (StreamReader r = new StreamReader(response.GetResponseStream()))
{
while (!r.EndOfStream)
sb.Append(r.ReadLine());
}//end using
var postResult = jsSerializer.DeserializeObject(sb.ToString()) as Dictionary<string, object>;
if (!postResult.ContainsKey("result") || String.Compare(postResult["result"].ToString(), "ok", true) != 0 || !postResult.ContainsKey("id")) {
Array errors = ((Dictionary<string, object>)postResult["errors"])["__all__"] as Array;
StringBuilder sbError = new StringBuilder();
if (errors != null)
{
foreach (string error in errors)
sbError.Append(error + " ");
}
throw new BuildFailureException(sbError.ToString());
}
monitorURL = String.Format("{0}/{1}?email={2}&password={3}", _monitorURL, postResult["id"].ToString(), HttpUtility.UrlEncode(_email), HttpUtility.UrlEncode(_password));
}//end using
FireProgressEvent(String.Format("Monitoring - {0}", platformString));
//monitor and get download url(s)
string androidDownloadURL = null, iOSDownloadURL = null;
while (true)
{
IHttpWebRequest monitorRequest = _requestFactory.BuildRequest("GET", monitorURL);
using (HttpWebResponse monitorResponse = monitorRequest.GetResponse() as HttpWebResponse)
{
if (monitorResponse.StatusCode != HttpStatusCode.OK)
{
String msg = String.Format("Unable to get monitoring url. Response: {0}", monitorResponse.StatusCode);
throw new BuildFailureException(msg);
}
StringBuilder sb = new StringBuilder();
using (StreamReader r = new StreamReader(monitorResponse.GetResponseStream()))
{
while (!r.EndOfStream)
sb.Append(r.ReadLine());
}//end using
String askResponseBody = sb.ToString();
var monitorResult = jsSerializer.DeserializeObject(askResponseBody) as Dictionary<string, object>;
String state = monitorResult.ContainsKey("state") ? monitorResult["state"].ToString() : null;
if (String.Compare(state, "success", true) == 0)
{
var info = monitorResult["info"] as Dictionary<string, object>;
var files = info["files"] as Dictionary<string, object>;
if ((platforms & BuildPlatform.Android) == BuildPlatform.Android)
androidDownloadURL = files["android"].ToString();
if ((platforms & BuildPlatform.iOS) == BuildPlatform.iOS)
iOSDownloadURL = files["ios"].ToString();
break;
}
else if (String.Compare(state, "failure", true) == 0)
{
String msg = "Build failure";
//TODO: Spit out the whole reason, including stack trace if we can get it from the server
throw new BuildFailureException(msg);
}
else if (String.Compare(state, "pending", true) != 0) //not pending, unknown status
{
String msg = String.Format("Build failure. Unexpected state {0}", state);
throw new BuildFailureException(msg);
}//end if
}//end using
}//end while(true)
FireProgressEvent("Downloading packages");
//download the package(s)
Dictionary<BuildPlatform, MemoryStream> ret = new Dictionary<BuildPlatform, MemoryStream>();
if ((platforms & BuildPlatform.Android) == BuildPlatform.Android)
{
FireProgressEvent("Downloading - Android");
IHttpWebRequest dlReq = _requestFactory.BuildRequest("GET", androidDownloadURL);
dlReq.Timeout = 600000;
using (HttpWebResponse dlResp = (HttpWebResponse)dlReq.GetResponse())
{
if (dlResp.StatusCode != HttpStatusCode.OK)
{
String msg = String.Format("Unable to get Android download url. Response: {0}", dlResp.StatusCode);
throw new BuildFailureException(msg);
}
//save to memory stream
MemoryStream ms = new MemoryStream();
using (Stream r = dlResp.GetResponseStream())
{
byte[] buff = new byte[2048];
int bytesRead = 0, totalBytesRead = 0;
while ((bytesRead = r.Read(buff, 0, buff.Length)) > 0)
{
ms.Write(buff, 0, bytesRead);
totalBytesRead += bytesRead;
//FireProgressEvent(String.Format("Downloaded {0} bytes", totalBytesRead), ProgressStatus.INPROGRESS);
}//end while
}//end using
ms.Position = 0;
ret.Add(BuildPlatform.Android, ms);
}//end using
}//end if
if ((platforms & BuildPlatform.iOS) == BuildPlatform.iOS)
{
FireProgressEvent("Downloading - iOS");
IHttpWebRequest dlReq = _requestFactory.BuildRequest("GET", iOSDownloadURL);
dlReq.Timeout = 600000;
using (HttpWebResponse dlResp = (HttpWebResponse)dlReq.GetResponse())
{
if (dlResp.StatusCode != HttpStatusCode.OK)
{
String msg = String.Format("Unable to get iOS download url. Response: {0}", dlResp.StatusCode);
throw new BuildFailureException(msg);
}
//save to memory stream
MemoryStream ms = new MemoryStream();
using (Stream r = dlResp.GetResponseStream())
{
byte[] buff = new byte[2048];
int bytesRead = 0, totalBytesRead = 0;
while ((bytesRead = r.Read(buff, 0, buff.Length)) > 0)
{
ms.Write(buff, 0, bytesRead);
totalBytesRead += bytesRead;
//FireProgressEvent(String.Format("Downloaded {0} bytes", totalBytesRead), ProgressStatus.INPROGRESS);
}//end while
}//end using
ms.Position = 0;
ret.Add(BuildPlatform.iOS, ms);
}//end using
}//end if
return ret;
}
public static bool IsPlatform(BuildPlatform platform, string version = null)
{
return(IsPlatform(platform) && (version == null || IsVersion(version)));
}
public string GetInterpretedOutputPath(BuildPlatform platform)
{
return(BMUtility.InterpretPath(outputs[platform.ToString()], platform));
}
private static void GUIBuildButtons(IBuildWindowExtension buildWindowExtension,
bool enableBuildButton,
bool enableBuildAndRunButton,
bool canInstallInBuildFolder,
BuildPlatform platform)
{
GUILayout.FlexibleSpace();
if (canInstallInBuildFolder)
{
GUILayout.BeginHorizontal();
EditorUserBuildSettings.installInBuildFolder = GUILayout.Toggle(EditorUserBuildSettings.installInBuildFolder, "Install in Builds folder\n(for debugging with source code)", GUILayout.ExpandWidth(false));
var content = new GUIContent(EditorGUI.GUIContents.helpIcon);
content.tooltip = "Open documentation for debugging source code";
if (GUILayout.Button(content, EditorStyles.iconButton))
{
var path = Path.Combine(Directory.GetParent(EditorApplication.applicationPath).FullName, "../../Documentation/BuildDocs/view_build_docs");
if (Application.platform == RuntimePlatform.WindowsEditor)
{
System.Diagnostics.Process.Start(path + ".cmd");
}
else
{
System.Diagnostics.Process.Start("/bin/bash", path);
}
}
GUILayout.EndHorizontal();
}
else
{
EditorUserBuildSettings.installInBuildFolder = false;
}
if ((buildWindowExtension != null) && Unsupported.IsSourceBuild())
{
buildWindowExtension.ShowInternalPlatformBuildOptions();
}
if (buildWindowExtension != null)
{
buildWindowExtension.ShowPlatformBuildWarnings();
}
// Disable the 'Build' and 'Build And Run' buttons when the project setup doesn't satisfy the platform requirements
if (!IsColorSpaceValid(platform) && enableBuildButton && enableBuildAndRunButton)
{
enableBuildAndRunButton = false;
enableBuildButton = false;
EditorGUILayout.HelpBox(styles.invalidColorSpaceMessage);
}
else if (!IsLightmapEncodingValid(platform) && enableBuildButton && enableBuildAndRunButton)
{
enableBuildAndRunButton = false;
enableBuildButton = false;
EditorGUILayout.HelpBox(styles.invalidLightmapEncodingMessage);
}
if (EditorApplication.isCompiling || EditorApplication.isUpdating)
{
enableBuildAndRunButton = false;
enableBuildButton = false;
EditorGUILayout.HelpBox(styles.compilingMessage);
}
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (EditorGUILayout.LinkLabel(styles.learnAboutUnityCloudBuild))
{
Application.OpenURL(string.Format("{0}/from/editor/buildsettings?upid={1}&pid={2}¤tplatform={3}&selectedplatform={4}&unityversion={5}",
UnityEditorInternal.WebURLs.cloudBuildPage, CloudProjectSettings.projectId, PlayerSettings.productGUID, EditorUserBuildSettings.activeBuildTarget, EditorUserBuildSettingsUtils.CalculateSelectedBuildTarget(), Application.unityVersion));
}
GUILayout.EndHorizontal();
// Space 6 for alignment with platform column and to reduce missclicks with Build And Run button
GUILayout.Space(6);
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUIContent buildButton = null;
GUIContent buildAndRunButton = null;
bool askForBuildLocation = true;
if (buildWindowExtension != null)
{
buildWindowExtension.GetBuildButtonTitles(out buildButton, out buildAndRunButton);
askForBuildLocation = buildWindowExtension.AskForBuildLocation();
}
buildButton = buildButton ?? styles.build;
buildAndRunButton = buildAndRunButton ?? styles.buildAndRun;
// Switching build target in the editor
BuildTarget selectedTarget = EditorUserBuildSettingsUtils.CalculateSelectedBuildTarget();
BuildTargetGroup selectedTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
bool selectedTargetIsActive = EditorUserBuildSettings.activeBuildTarget == selectedTarget &&
EditorUserBuildSettings.activeBuildTargetGroup == selectedTargetGroup;
if (selectedTargetIsActive)
{
// Build Button
GUI.enabled = enableBuildButton;
if (GUILayout.Button(buildButton, GUILayout.Width(Styles.kButtonWidth)))
{
CallBuildMethods(askForBuildLocation, BuildOptions.ShowBuiltPlayer);
GUIUtility.ExitGUI();
}
}
else
{
GUI.enabled = BuildPipeline.IsBuildTargetSupported(selectedTargetGroup, selectedTarget) && EditorUserBuildSettings.activeBuildTargetGroup != selectedTargetGroup;
if (GUILayout.Button(styles.switchPlatform, GUILayout.Width(Styles.kButtonWidth)))
{
EditorUserBuildSettings.SwitchActiveBuildTargetAsync(selectedTargetGroup, selectedTarget);
GUIUtility.ExitGUI();
}
}
// Build and Run button
GUI.enabled = enableBuildAndRunButton && selectedTargetIsActive;
if (GUILayout.Button(buildAndRunButton, GUILayout.Width(Styles.kButtonWidth)))
{
BuildPlayerAndRun(askForBuildLocation);
GUIUtility.ExitGUI();
}
GUILayout.EndHorizontal();
}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
static void Build_Platform(BuildPlatform platform)
{
m_logInfo = "" ;
bool buildSuccessfull = false ;
string successMessage = "" ;
AppendLogInfo("AutoBuild: TASK: Starting to build for platform: " + platform) ;
CheckBuildSettings() ;
if(BuildPlatform.Android == platform)
{
//CheckAndroidSpecificSettings() ;
}
// Get current project directory
string pwd = Directory.GetCurrentDirectory() ;
AppendLogInfo("AutoBuild: INFO: Current Directory: " + pwd) ;
// Check and/or Create "Builds" directory
if(CheckAndCreateDirectory(pwd, "Builds"))
{
// Check and/or Create "iOS" directory
string currBuildsDir = pwd + "/Builds" ;
string getPlatformFolderToCreate = GetPlatformFolderToCreate(platform) ;
if(CheckAndCreateDirectory(currBuildsDir, getPlatformFolderToCreate))
{
AppendLogInfo("AutoBuild: INFO: All " + platform + " build directories initialized") ;
// Get all the scenes which have been selected
List<EditorBuildSettingsScene> scenes = new List<EditorBuildSettingsScene>(EditorBuildSettings.scenes) ;
if(0 == scenes.Count)
{
AppendLogInfo("AutoBuild: ERROR: No Scenes have been added for Build. Add atleast ONE scene in Build Settings.") ;
}
else if(scenes.Count > 0)
{
List<string> enabledScenes = new List<string>() ;
foreach (EditorBuildSettingsScene scene in scenes)
{
//AppendLogInfo("Found Scene: " + scene.path + ", enabled = " + scene.enabled) ;
if(scene.enabled)
{
enabledScenes.Add(scene.path);
}
}
// Check if any scenes have been
if(0 == enabledScenes.Count)
{
AppendLogInfo("AutoBuild: ERROR: No Scenes have been selected for Build. Select atleast ONE scene to build in Build Settings.") ;
}
else if(enabledScenes.Count > 0)
{
AppendLogInfo("AutoBuild: INFO: Total Scenes Enabled = " + enabledScenes.Count) ;
string productName = PlayerSettings.productName ;
productName = productName.Replace(" ", "") ;
string buildFolder = "Builds/" + getPlatformFolderToCreate + "/" ;
BuildTarget buildTarget = BuildTarget.iPhone ;
BuildOptions buildOptions = BuildOptions.None ;
switch(platform)
{
case BuildPlatform.iOS:
{
buildTarget = BuildTarget.iPhone ;
successMessage = "AutoBuild: SUCCESS: Created iOS Xcode Project Folder." ;
}
break ;
case BuildPlatform.Android:
{
productName = productName.ToLowerInvariant() ;
buildTarget = BuildTarget.Android ;
buildFolder += productName + ".apk" ;
successMessage = "AutoBuild: SUCCESS: Created Google Play - Android APK file." ;
}
break ;
case BuildPlatform.PC_x86:
{
productName = productName.Replace(" ", "") ;
buildTarget = BuildTarget.StandaloneWindows ;
buildFolder += productName + ".exe" ;
successMessage = "AutoBuild: SUCCESS: Created PC (x86 -> 32-bit) Build folder." ;
}
break ;
case BuildPlatform.PC_x64:
{
productName = productName.Replace(" ", "") ;
buildTarget = BuildTarget.StandaloneWindows64 ;
buildFolder += productName + ".exe" ;
successMessage = "AutoBuild: SUCCESS: Created PC (x64 -> 64-bit) Build folder." ;
}
break ;
case BuildPlatform.Mac_Intel:
{
productName = productName.Replace(" ", "") ;
buildTarget = BuildTarget.StandaloneOSXIntel ;
buildFolder += productName ;
successMessage = "AutoBuild: SUCCESS: Created Mac (Intel -> 32-bit) Build folder." ;
}
break ;
case BuildPlatform.Mac_Intel_64:
{
productName = productName.Replace(" ", "") ;
buildTarget = BuildTarget.StandaloneOSXIntel64 ;
buildFolder += productName ;
successMessage = "AutoBuild: SUCCESS: Created Mac (Intel -> 64-bit) Build folder." ;
}
break ;
case BuildPlatform.Mac_Universal:
{
productName = productName.Replace(" ", "") ;
buildTarget = BuildTarget.StandaloneOSXUniversal ;
buildFolder += productName ;
successMessage = "AutoBuild: SUCCESS: Created Mac (Universal) Build folder." ;
}
break ;
}
BuildPipeline.BuildPlayer(
enabledScenes.ToArray(),
buildFolder,
buildTarget,
buildOptions
);
buildSuccessfull = true ;
}
}
}
}
if(buildSuccessfull)
{
AppendLogInfo(successMessage) ;
}
else
{
AppendLogInfo("AutoBuild: FAILED: Check error log file: " + AB_LOG_FILE + " for more info.") ;
}
SaveAutoBuildLogFile(m_logInfo) ;
m_logInfo = "" ;
}
static BuildReportTool.SizePart[] GetAllUnusedAssets(
string[] scenesIncludedInProject,
BuildReportTool.SizePart[] scriptDLLs,
string projectAssetsPath,
bool includeSvn, bool includeGit,
BuildPlatform buildPlatform,
bool includeUnusedPrefabs,
int fileCountBatchSkip, int fileCountLimit,
List<BuildReportTool.SizePart> inOutAllUsedAssets)
{
Dictionary<string, bool> usedAssetsDict = new Dictionary<string, bool>();
for (int n = 0, len = inOutAllUsedAssets.Count; n < len; ++n)
{
usedAssetsDict[inOutAllUsedAssets[n].Name] = true;
}
// consider scenes used to be part of used assets
if (scenesIncludedInProject != null)
{
for (int n = 0, len = scenesIncludedInProject.Length; n < len; ++n)
{
//Debug.Log("scene " + n + ": " + scenesIncludedInProject[n]);
usedAssetsDict[scenesIncludedInProject[n]] = true;
}
}
return GetAllUnusedAssets(
scriptDLLs,
projectAssetsPath,
includeSvn, includeGit,
buildPlatform,
includeUnusedPrefabs,
fileCountBatchSkip, fileCountLimit,
usedAssetsDict,
inOutAllUsedAssets);
}
public static bool IsPlatform(BuildPlatform platform, string version = null)
{
return IsPlatform(platform) && (version == null || IsVersion(version));
}
private void ShowOption(BuildPlatform bp, GUIContent title, GUIStyle background)
{
Rect position = GUILayoutUtility.GetRect((float) 50f, (float) 36f);
position.x++;
position.y++;
bool flag = BuildPipeline.LicenseCheck(bp.DefaultTarget);
GUI.contentColor = new Color(1f, 1f, 1f, !flag ? 0.7f : 1f);
bool on = EditorUserBuildSettings.selectedBuildTargetGroup == bp.targetGroup;
if (Event.current.type == EventType.Repaint)
{
background.Draw(position, GUIContent.none, false, false, on, false);
GUI.Label(new Rect(position.x + 3f, position.y + 3f, 32f, 32f), title.image, GUIStyle.none);
if (BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget) == bp.targetGroup)
{
GUI.Label(new Rect((position.xMax - styles.activePlatformIcon.width) - 8f, (position.y + 3f) + ((0x20 - styles.activePlatformIcon.height) / 2), (float) styles.activePlatformIcon.width, (float) styles.activePlatformIcon.height), styles.activePlatformIcon, GUIStyle.none);
}
}
if (GUI.Toggle(position, on, title.text, styles.platformSelector) && (EditorUserBuildSettings.selectedBuildTargetGroup != bp.targetGroup))
{
EditorUserBuildSettings.selectedBuildTargetGroup = bp.targetGroup;
UnityEngine.Object[] objArray = Resources.FindObjectsOfTypeAll(typeof(InspectorWindow));
for (int i = 0; i < objArray.Length; i++)
{
InspectorWindow window = objArray[i] as InspectorWindow;
if (window != null)
{
window.Repaint();
}
}
}
}
private static BuildTarget RestoreLastKnownPlatformsBuildTarget(BuildPlatform bp)
{
BuildTargetGroup targetGroup = bp.targetGroup;
if (targetGroup == BuildTargetGroup.Standalone)
{
return EditorUserBuildSettings.selectedStandaloneTarget;
}
if (targetGroup != BuildTargetGroup.WebPlayer)
{
return bp.DefaultTarget;
}
return (!EditorUserBuildSettings.webPlayerStreamed ? BuildTarget.WebPlayer : BuildTarget.WebPlayerStreamed);
}
private static void GUIBuildButtons(IBuildWindowExtension buildWindowExtension, bool enableBuildButton, bool enableBuildAndRunButton, bool canInstallInBuildFolder, BuildPlatform platform)
{
GUILayout.FlexibleSpace();
if (canInstallInBuildFolder)
{
GUILayoutOption[] optionArray1 = new GUILayoutOption[] { GUILayout.ExpandWidth(false) };
EditorUserBuildSettings.installInBuildFolder = GUILayout.Toggle(EditorUserBuildSettings.installInBuildFolder, "Install in Builds folder\n(for debugging with source code)", optionArray1);
}
else
{
EditorUserBuildSettings.installInBuildFolder = false;
}
if ((buildWindowExtension != null) && Unsupported.IsDeveloperBuild())
{
buildWindowExtension.ShowInternalPlatformBuildOptions();
}
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
GUILayout.FlexibleSpace();
GUIContent build = styles.build;
if ((platform.targetGroup == BuildTargetGroup.Android) && EditorUserBuildSettings.exportAsGoogleAndroidProject)
{
build = styles.export;
}
if ((platform.targetGroup == BuildTargetGroup.iPhone) && (Application.platform != RuntimePlatform.OSXEditor))
{
enableBuildAndRunButton = false;
}
GUI.enabled = enableBuildButton;
GUILayoutOption[] options = new GUILayoutOption[] { GUILayout.Width(110f) };
if (GUILayout.Button(build, options))
{
BuildPlayerWithDefaultSettings(true, BuildOptions.ShowBuiltPlayer);
GUIUtility.ExitGUI();
}
GUI.enabled = enableBuildAndRunButton;
GUILayoutOption[] optionArray3 = new GUILayoutOption[] { GUILayout.Width(110f) };
if (GUILayout.Button(styles.buildAndRun, optionArray3))
{
BuildPlayerWithDefaultSettings(true, BuildOptions.AutoRunPlayer);
GUIUtility.ExitGUI();
}
GUILayout.EndHorizontal();
}
public static string InterpretPath(string origPath, BuildPlatform platform)
{
var matches = Regex.Matches(origPath, @"\$\((\w+)\)");
foreach (Match match in matches)
{
string var = match.Groups[1].Value;
origPath = origPath.Replace(@"$(" + var + ")", EnvVarToString(var, platform));
}
return origPath;
}
void ShowBuildTargetSettings()
{
EditorGUIUtility.labelWidth = Mathf.Min(180, (position.width - 265) * 0.47f);
BuildTarget buildTarget = EditorUserBuildSettingsUtils.CalculateSelectedBuildTarget();
BuildTargetGroup buildTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
BuildPlatform platform = BuildPlatforms.instance.BuildPlatformFromTargetGroup(buildTargetGroup);
bool licensed = BuildPipeline.LicenseCheck(buildTarget);
// Draw the group name
GUILayout.Space(18);
// Draw icon and text of title separately so we can control the space between them
Rect r = GUILayoutUtility.GetRect(50, 36);
r.x += 1;
GUI.Label(new Rect(r.x + 3, r.y + 3, 32, 32), platform.title.image, GUIStyle.none);
GUI.Toggle(r, false, platform.title.text, styles.platformSelector);
GUILayout.Space(10);
if (platform.targetGroup == BuildTargetGroup.WebGL && !BuildPipeline.IsBuildTargetSupported(platform.targetGroup, buildTarget))
{
if (IntPtr.Size == 4)
{
GUILayout.Label("Building for WebGL requires a 64-bit Unity editor.");
GUIBuildButtons(false, false, false, platform);
return;
}
}
string moduleName = Modules.ModuleManager.GetTargetStringFrom(buildTargetGroup, buildTarget);
if (IsModuleNotInstalled(buildTargetGroup, buildTarget))
{
GUILayout.Label(EditorGUIUtility.TextContent(string.Format(styles.noModuleLoaded, BuildPlatforms.instance.GetModuleDisplayName(buildTargetGroup, buildTarget))));
if (GUILayout.Button(styles.openDownloadPage, EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
{
string url = GetPlaybackEngineDownloadURL(moduleName);
Help.BrowseURL(url);
}
GUIBuildButtons(false, false, false, platform);
return;
}
else if (Application.HasProLicense() && !InternalEditorUtility.HasAdvancedLicenseOnBuildTarget(buildTarget))
{
// Show copy for using personal edition build targets with pro edition editor
string infoText = string.Format(styles.infoText,
BuildPlatforms.instance.GetBuildTargetDisplayName(buildTargetGroup, buildTarget));
GUILayout.BeginVertical(EditorStyles.helpBox);
GUILayout.Label(infoText, EditorStyles.wordWrappedMiniLabel);
GUILayout.BeginHorizontal();
if (GUILayout.Button(styles.eula, EditorStyles.miniButton))
{
Application.OpenURL("http://unity3d.com/legal/eula");
}
if (GUILayout.Button(string.Format(styles.addToYourPro, BuildPlatforms.instance.GetBuildTargetDisplayName(buildTargetGroup, buildTarget)), EditorStyles.miniButton))
{
Application.OpenURL("http://unity3d.com/get-unity");
}
GUILayout.EndHorizontal();
GUILayout.EndVertical();
}
GUIContent error = styles.GetDownloadErrorForTarget(buildTarget);
if (error != null)
{
GUILayout.Label(error, EditorStyles.wordWrappedLabel);
GUIBuildButtons(false, false, false, platform);
return;
}
// Draw not licensed buy now UI
if (!licensed)
{
string niceName = BuildPipeline.GetBuildTargetGroupDisplayName(buildTargetGroup);
string licenseMsg = "Your license does not cover {0} Publishing.";
string buttonMsg = "Go to Our Online Store";
if (BuildTargetDiscovery.PlatformHasFlag(buildTarget, TargetAttributes.IsConsole))
{
licenseMsg += "Please see the {0} section of the Platform Module Installation documentation for more details.";
buttonMsg = "Platform Module Installation";
}
else if (BuildTargetDiscovery.PlatformHasFlag(buildTarget, TargetAttributes.IsStandalonePlatform))
{
buttonMsg = "";
}
GUIContent[] notLicensedMessage =
{
EditorGUIUtility.TextContent(string.Format(L10n.Tr(licenseMsg), niceName)),
EditorGUIUtility.TextContent(L10n.Tr(buttonMsg)),
new GUIContent(styles.shopURL)
};
GUILayout.Label(notLicensedMessage[0], EditorStyles.wordWrappedLabel);
GUILayout.Space(5);
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (notLicensedMessage[1].text.Length != 0)
{
if (GUILayout.Button(notLicensedMessage[1]))
{
Application.OpenURL(notLicensedMessage[2].text);
}
}
GUILayout.EndHorizontal();
GUIBuildButtons(false, false, false, platform);
return;
}
// FIXME: WHY IS THIS ALL IN ONE FUNCTION?!
// Draw the side bar to the right. Different options like specific Standalone player to build, profiling and debugging options, etc.
string module = ModuleManager.GetTargetStringFrom(platform.targetGroup, buildTarget);
IBuildWindowExtension buildWindowExtension = ModuleManager.GetBuildWindowExtension(module);
if (buildWindowExtension != null)
{
buildWindowExtension.ShowPlatformBuildOptions();
}
GUI.changed = false;
GUI.enabled = true;
bool enableBuildButton = buildWindowExtension != null?buildWindowExtension.EnabledBuildButton() : true;
bool enableBuildAndRunButton = false;
bool shouldDrawDebuggingToggle = buildWindowExtension != null?buildWindowExtension.ShouldDrawScriptDebuggingCheckbox() : true;
bool shouldDrawExplicitNullChecksToggle = buildWindowExtension != null?buildWindowExtension.ShouldDrawExplicitNullCheckbox() : false;
bool shouldDrawDivideByZeroChecksToggle = buildWindowExtension != null?buildWindowExtension.ShouldDrawExplicitDivideByZeroCheckbox() : false;
bool shouldDrawArrayBoundsChecksToggle = buildWindowExtension != null?buildWindowExtension.ShouldDrawExplicitArrayBoundsCheckbox() : false;
bool shouldDrawDevelopmentPlayerToggle = buildWindowExtension != null?buildWindowExtension.ShouldDrawDevelopmentPlayerCheckbox() : true;
IBuildPostprocessor postprocessor = ModuleManager.GetBuildPostProcessor(buildTargetGroup, buildTarget);
bool enableBuildScriptsOnly = (postprocessor != null ? postprocessor.SupportsScriptsOnlyBuild() : false);
bool canInstallInBuildFolder = false;
if (BuildPipeline.IsBuildTargetSupported(buildTargetGroup, buildTarget))
{
bool shouldDrawConnectProfilerToggle = buildWindowExtension != null?buildWindowExtension.ShouldDrawProfilerCheckbox() : true;
GUI.enabled = shouldDrawDevelopmentPlayerToggle;
if (shouldDrawDevelopmentPlayerToggle)
{
EditorUserBuildSettings.development = EditorGUILayout.Toggle(styles.debugBuild, EditorUserBuildSettings.development);
}
bool developmentBuild = EditorUserBuildSettings.development;
GUI.enabled = developmentBuild;
if (shouldDrawConnectProfilerToggle)
{
if (!GUI.enabled)
{
if (!developmentBuild)
{
styles.profileBuild.tooltip = "Profiling only enabled in Development Player";
}
}
else
{
styles.profileBuild.tooltip = "";
}
EditorUserBuildSettings.connectProfiler = EditorGUILayout.Toggle(styles.profileBuild, EditorUserBuildSettings.connectProfiler);
}
GUI.enabled = developmentBuild;
if (shouldDrawDebuggingToggle)
{
using (new EditorGUI.DisabledScope(buildWindowExtension != null ? buildWindowExtension.ShouldDisableManagedDebuggerCheckboxes() : false))
{
EditorUserBuildSettings.allowDebugging = EditorGUILayout.Toggle(styles.allowDebugging, EditorUserBuildSettings.allowDebugging);
// Not all platforms have native dialog implemented in Runtime\Misc\GiveDebuggerChanceToAttachIfRequired.cpp
// Display this option only for developer builds
bool shouldDrawWaitForManagedDebugger = buildWindowExtension != null?buildWindowExtension.ShouldDrawWaitForManagedDebugger() : false;
if (EditorUserBuildSettings.allowDebugging && shouldDrawWaitForManagedDebugger)
{
var buildTargetName = BuildPipeline.GetBuildTargetName(buildTarget);
bool value = EditorGUILayout.Toggle(styles.waitForManagedDebugger, EditorUserBuildSettings.GetPlatformSettings(buildTargetName, kSettingDebuggingWaitForManagedDebugger) == "true");
EditorUserBuildSettings.SetPlatformSettings(buildTargetName, kSettingDebuggingWaitForManagedDebugger, value.ToString().ToLower());
}
}
if (EditorUserBuildSettings.allowDebugging && PlayerSettings.GetScriptingBackend(buildTargetGroup) == ScriptingImplementation.IL2CPP)
{
var apiCompatibilityLevel = PlayerSettings.GetApiCompatibilityLevel(buildTargetGroup);
bool isDebuggerUsable = apiCompatibilityLevel == ApiCompatibilityLevel.NET_4_6 || apiCompatibilityLevel == ApiCompatibilityLevel.NET_Standard_2_0;
if (!isDebuggerUsable)
{
EditorGUILayout.HelpBox("Script debugging is only supported with IL2CPP on .NET 4.x and .NET Standard 2.0 API Compatibility Levels.", MessageType.Warning);
}
}
}
if (shouldDrawExplicitNullChecksToggle)
{
// Force 'ExplicitNullChecks' to true if it's a development build.
GUI.enabled = !developmentBuild;
if (GUI.enabled == false)
{
EditorUserBuildSettings.explicitNullChecks = true;
}
EditorUserBuildSettings.explicitNullChecks = EditorGUILayout.Toggle(styles.explicitNullChecks, EditorUserBuildSettings.explicitNullChecks);
// Undo force from above
GUI.enabled = developmentBuild;
}
if (shouldDrawDivideByZeroChecksToggle)
{
// Force 'explicitDivideByZeroChecks' to true if it's a development build.
GUI.enabled = !developmentBuild;
if (GUI.enabled == false)
{
EditorUserBuildSettings.explicitDivideByZeroChecks = true;
}
EditorUserBuildSettings.explicitDivideByZeroChecks = EditorGUILayout.Toggle(styles.explicitDivideByZeroChecks, EditorUserBuildSettings.explicitDivideByZeroChecks);
// Undo force from above
GUI.enabled = developmentBuild;
}
if (shouldDrawArrayBoundsChecksToggle)
{
// Force 'explicitArrayBoundsChecks' to true if it's a development build.
GUI.enabled = !developmentBuild;
if (GUI.enabled == false)
{
EditorUserBuildSettings.explicitArrayBoundsChecks = true;
}
EditorUserBuildSettings.explicitArrayBoundsChecks = EditorGUILayout.Toggle(styles.explicitArrayBoundsChecks, EditorUserBuildSettings.explicitArrayBoundsChecks);
// Undo force from above
GUI.enabled = developmentBuild;
}
if (buildWindowExtension != null && enableBuildScriptsOnly)
{
buildWindowExtension.DoScriptsOnlyGUI();
}
GUI.enabled = true;
GUILayout.FlexibleSpace();
if (postprocessor != null && postprocessor.SupportsLz4Compression())
{
var cmpIdx = Array.IndexOf(styles.compressionTypes, EditorUserBuildSettings.GetCompressionType(buildTargetGroup));
if (cmpIdx == -1)
{
cmpIdx = 1; // Lz4 by default.
}
cmpIdx = EditorGUILayout.Popup(styles.compressionMethod, cmpIdx, styles.compressionStrings);
EditorUserBuildSettings.SetCompressionType(buildTargetGroup, styles.compressionTypes[cmpIdx]);
}
canInstallInBuildFolder = Unsupported.IsSourceBuild() && PostprocessBuildPlayer.SupportsInstallInBuildFolder(buildTargetGroup, buildTarget);
if (enableBuildButton)
{
enableBuildAndRunButton = buildWindowExtension != null?buildWindowExtension.EnabledBuildAndRunButton() &&
!(EditorUserBuildSettings.installInBuildFolder) : !(EditorUserBuildSettings.installInBuildFolder);
}
}
else
{
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.BeginVertical(GUILayout.ExpandWidth(true));
GUILayout.Label(string.Format(L10n.Tr("{0} is not supported in this build.\nDownload a build that supports it."), BuildPipeline.GetBuildTargetGroupDisplayName(buildTargetGroup)));
GUILayout.EndVertical();
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
if (buildTarget == BuildTarget.Android)
{
AndroidPublishGUI();
}
GUIBuildButtons(buildWindowExtension, enableBuildButton, enableBuildAndRunButton,
canInstallInBuildFolder, platform);
}
public override void PerBuildExecute(BuildReleaseType releaseType, BuildPlatform platform, BuildArchitecture architecture, BuildDistribution distribution, DateTime buildTime, ref BuildOptions options, string configKey, string buildPath)
{
// Set spatializer plugin
AudioSettings.SetSpatializerPluginName(SpatializerPlugin);
}
public string GetInterpretedDownloadUrl(BuildPlatform platform)
{
return(BMUtility.InterpretPath(downloadUrls[platform.ToString()], platform));
}
public string GetInterpretedDownloadUrl(BuildPlatform platform)
{
return BMUtility.InterpretPath(this.downloadUrls[platform.ToString()], platform);
}
internal static string GetPlatformName(BuildTargetGroup targetGroup)
{
BuildPlatform platform = BuildPlatforms.instance.GetValidPlatforms().Find(p => p.targetGroup == targetGroup);
return(platform == null ? string.Empty : platform.name);
}
private static string EnvVarToString(string varString, BuildPlatform platform)
{
switch (varString)
{
case "DataPath":
return Application.dataPath;
case "PersistentDataPath":
return Application.persistentDataPath;
case "StreamingAssetsPath":
return Application.streamingAssetsPath;
case "Platform":
return platform.ToString();
case "BundlePath":
return EditorConfig.Instance.BundlePath;
case "Localization":
return JenkinsBuildConfig.Instance.Language.ToString();
case "BundleVersion":
return JenkinsBuildConfig.Instance.Bundleversion;
default:
Debug.LogError("Cannot solve enviroment var " + varString);
return "";
}
}
public BuildPlatformsAttribute(BuildPlatform platform, string version)
{
_buildPlatforms = new BuildPlatform[] { platform };
_version = version;
}
public static void RefreshConfig(LocalizationType type, bool isDebug, BuildPlatform platform)
{
JenkinsBuildConfig.Instance.RefreshConfig(type, isDebug, platform);
}
private static void GUIBuildButtons(bool enableBuildButton, bool enableBuildAndRunButton, bool canInstallInBuildFolder, BuildPlatform platform)
{
GUIBuildButtons(null, enableBuildButton, enableBuildAndRunButton, canInstallInBuildFolder, platform);
}
public string GetInterpretedOutputPath(BuildPlatform platform)
{
return BMUtility.InterpretPath(this.outputs[platform.ToString()], platform);
}
