Esempio n. 1
0
	static bool RevertBuild ()
	{
		try {
			if (!cloudBuild && !debugBuild) {
				// If this is not a cloud build, revert to the original build target if we saved one earlier

				if (regularTarget != BuildTarget.NoTarget && regularTargetGroup != BuildTargetGroup.Unknown) {
					if (!regularTarget.Equals (EditorUserBuildSettings.activeBuildTarget)) {
						HeadlessAPI.VersionedSwitchActiveBuildTarget (regularTargetGroup, regularTarget);
					}
				}
			}

			return true;
		} catch (Exception e) {
			UnityEngine.Debug.LogError (e);
			return false;
		}
	}
Esempio n. 2
0
	static bool PrepareBuild ()
	{

		try {

			if (manualBuild || debugBuild) {
				if (File.Exists(backupFolder + "/lock.txt")) {
					if (!EditorUtility.DisplayDialog ("Headless Builder",
						"A previous build has modified some project files\n" +
						"and the backup in the 'headless_builder_backup' folder has not yet been restored.\n\n" + 
						"We recommend you manually restore the backup first.\n" + 
						"Please refer to the Troubleshooting chapter in the documentation on how to do this.\n\n" +
						"If you choose to ignore this, the previously made backup will be overwritten.\n\n" + 
						"Are you sure you want to continue?", "Yes", "Cancel")) {

						return false;
					} else {
						if (!EditorUtility.DisplayDialog ("Headless Builder",
							"Are you absolutely sure that you have no need for the backup stored in the 'headless_builder_backup' folder?\n\n" + 
							"If you continue this previous backup will be overwritten.\n\n" + 
							"Are you sure you want to continue?", "Yes", "Cancel")) {

							return false;
						}
					}
				}
			}

			try {
				if (Directory.Exists (backupFolder)) {
					Directory.Delete (backupFolder, true);
				}
				Directory.CreateDirectory (backupFolder);
			} catch (Exception e) {
				UnityEngine.Debug.LogError (e);
				UnityEngine.Debug.LogError ("Headless Builder does not have write permissions for " + projectFolder + "\n" + "Please read the Permissions chapter in the documentation.");
				return false;
			}


			// Get the scenes that should be included in this build
			sceneAssets = new List<string> ();
			if (!headlessSettings.valueOverrideScenes) {
				foreach (var sceneAsset in EditorBuildSettings.scenes) {
					string scenePath = sceneAsset.path;
					if (!string.IsNullOrEmpty (scenePath)) {
						if (File.Exists (projectFolder + "/" + scenePath)) {
							sceneAssets.Add (scenePath);
						}
					}
				}
			} else {
				foreach (var sceneAsset in headlessSettings.valueSceneAssets) {
					string scenePath = AssetDatabase.GetAssetPath (sceneAsset);
					if (!string.IsNullOrEmpty (scenePath)) {
						sceneAssets.Add (scenePath);
					}
				}
			}
			sceneList = sceneAssets.ToArray ();
			currentScene = EditorSceneManager.GetActiveScene ().path;

			if (sceneList.Length == 0) {
				UnityEngine.Debug.LogError ("There are no (existing) scenes in the Unity build settings!\nHeadless Builder (v" + Headless.version + ")");
				return false;
			}

            //if (!debugBuild)
            //{

                // If needed, set the build path to a certain value based on Editor settings
                string[] args = Environment.GetCommandLineArgs();
                bool commandTarget = false;
                if (Array.IndexOf(args, "-buildTarget") >= 0)
                {
                    commandTarget = true;
                }
                if (cloudBuild || commandTarget || !headlessSettings.valueOverrideTarget)
                {
                    if (EditorUserBuildSettings.activeBuildTarget.Equals(BuildTarget.StandaloneWindows))
                    {
                        headlessSettings.valuePlatform = HeadlessEditor.WINDOWS;
                        headlessSettings.valueArchitecture = HeadlessEditor.X86;
                    }
                    else if (EditorUserBuildSettings.activeBuildTarget.Equals(BuildTarget.StandaloneWindows64))
                    {
                        headlessSettings.valuePlatform = HeadlessEditor.WINDOWS;
                        headlessSettings.valueArchitecture = HeadlessEditor.X64;
                    }
                    else if (EditorUserBuildSettings.activeBuildTarget.Equals(HeadlessAPI.VersionedBuildTargetOSX()))
                    {
                        headlessSettings.valuePlatform = HeadlessEditor.OSX;
                        headlessSettings.valueArchitecture = HeadlessEditor.X64;
                    }
                    else if (EditorUserBuildSettings.activeBuildTarget.Equals(BuildTarget.StandaloneLinux))
                    {
                        headlessSettings.valuePlatform = HeadlessEditor.LINUX;
                        headlessSettings.valueArchitecture = HeadlessEditor.X86;
                    }
                    else if (EditorUserBuildSettings.activeBuildTarget.Equals(BuildTarget.StandaloneLinux64))
                    {
                        headlessSettings.valuePlatform = HeadlessEditor.LINUX;
                        headlessSettings.valueArchitecture = HeadlessEditor.X64;
                    }
                    else
                    {
                        UnityEngine.Debug.LogError("This build target is not supported by Headless Builder!\nHeadless Builder (v" + Headless.version + ")");
                        return false;
                    }
                }

                // Set the various file names, file types and other stuff according to the target build
                String platformName = "";
                String architectureName = "";
                if (headlessSettings.valuePlatform == HeadlessEditor.WINDOWS)
                {
                    platformName = "Windows";
                }
                if (headlessSettings.valuePlatform == HeadlessEditor.OSX)
                {
                    platformName = "Mac OS X";
                }
                if (headlessSettings.valuePlatform == HeadlessEditor.LINUX)
                {
                    platformName = "Linux";
                }
                if (headlessSettings.valueArchitecture == HeadlessEditor.X64)
                {
                    architectureName = "64-bit";
                }
                if (headlessSettings.valueArchitecture == HeadlessEditor.X86)
                {
                    architectureName = "32-bit";
                }
                if (headlessSettings.valueArchitecture == HeadlessEditor.UNIVERSAL)
                {
                    architectureName = "universal";
                }

                UnityEngine.Debug.Log("Commencing build for " + platformName + " (" + architectureName + ") with profile \"" + headlessSettings.profileName + "\"\nHeadless Builder (v" + Headless.version + ")");


                packageName = PlayerSettings.productName.Replace(" ", String.Empty) + "Headless_" + headlessSettings.profileName;
                packageName = CleanFileName(packageName);

                if (headlessSettings.valuePlatform == HeadlessEditor.WINDOWS)
                {
                    buildExtension = ".exe";
                }
                else if (headlessSettings.valuePlatform == HeadlessEditor.LINUX &&
                         headlessSettings.valueArchitecture == HeadlessEditor.X64)
                {
                    buildExtension = ".x86_64";
                }
                else if (headlessSettings.valuePlatform == HeadlessEditor.LINUX &&
                         headlessSettings.valueArchitecture == HeadlessEditor.X86)
                {
                    buildExtension = ".x86";
                }
                else
                {
                    buildExtension = "";
                }
                buildName = CleanFileName(headlessSettings.profileName + "_Core");
                buildExecutable = buildName + buildExtension;


                buildTarget = BuildTarget.NoTarget;
                if (headlessSettings.valuePlatform == HeadlessEditor.WINDOWS &&
                    headlessSettings.valueArchitecture == HeadlessEditor.X64)
                {
                    buildTarget = BuildTarget.StandaloneWindows64;
                }
                if (headlessSettings.valuePlatform == HeadlessEditor.WINDOWS &&
                    headlessSettings.valueArchitecture == HeadlessEditor.X86)
                {
                    buildTarget = BuildTarget.StandaloneWindows;
                }
                if (headlessSettings.valuePlatform == HeadlessEditor.OSX &&
                    headlessSettings.valueArchitecture == HeadlessEditor.X64)
                {
                    buildTarget = HeadlessAPI.VersionedBuildTargetOSX();
                }
                if (headlessSettings.valuePlatform == HeadlessEditor.LINUX &&
                    headlessSettings.valueArchitecture == HeadlessEditor.X64)
                {
                    buildTarget = BuildTarget.StandaloneLinux64;
                }
                if (headlessSettings.valuePlatform == HeadlessEditor.LINUX &&
                    headlessSettings.valueArchitecture == HeadlessEditor.X86)
                {
                    buildTarget = BuildTarget.StandaloneLinux;
                }

                buildOptions = 0;
                if (headlessSettings.valuePlatform == HeadlessEditor.LINUX)
                {
                    buildOptions |= BuildOptions.EnableHeadlessMode;
                }
            //}

			SetProgress ("PREPROCESS");

			return true;
		} catch (Exception e) {
			UnityEngine.Debug.LogError (e);
			return false;
		}

	}