private static BuildPlayerOptions GetBuildOptions(Scene scene)
{
BuildPlayerOptions options = new BuildPlayerOptions();
options.scenes = new string[] { scene.path };
options.options |= BuildOptions.AutoRunPlayer | BuildOptions.Development;
options.target = EditorUserBuildSettings.activeBuildTarget;
string str = Path.Combine(Path.Combine(FileUtil.GetUniqueTempPathInProject(), "TestRun"), "test." + PostprocessBuildPlayer.GetExtensionForBuildTarget(options.target, options.options));
options.locationPathName = str;
return options;
}
private static UnityEditor.Build.Reporting.BuildReport UnityBuildPlayer()
{
var sceneList = GetScenesToBuild();
var buildPlayerOptions = new BuildPlayerOptions
{
scenes = sceneList.ToArray(),
locationPathName = gradleTempExport,
target = BuildTarget.Android,
options = BuildOptions.AcceptExternalModificationsToPlayer |
BuildOptions.Development |
BuildOptions.AllowDebugging
};
var buildResult = BuildPipeline.BuildPlayer(buildPlayerOptions);
UnityEngine.Debug.Log(UnityBuildPlayerSummary(buildResult));
return(buildResult);
}
static void BuildAndroidTest()
{
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions();
buildPlayerOptions.scenes = new[] { "Assets/Scene/dome.unity" };
buildPlayerOptions.locationPathName = "Package/Android Build.apk";
buildPlayerOptions.target = BuildTarget.Android;
buildPlayerOptions.options = BuildOptions.None;
var error = BuildPipeline.BuildPlayer(buildPlayerOptions);
if (!string.IsNullOrEmpty(error))
{
UnityEngine.Debug.Log("error:" + error);
}
else
{
Debug.Log("build success!");
}
}
public static void AndroidApp()
{
string folder = Path.Combine(Application.persistentDataPath + @"/CI");
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
string file = Path.Combine(folder, "Android-version.txt");
string currentversion = Application.version;
string oldversion = File.ReadAllText(file);
if (!currentversion.Equals(oldversion))
{
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions();
buildPlayerOptions.scenes = collectBuildScenes();
buildPlayerOptions.locationPathName = "build/android/kennig-demo-android.apk";
buildPlayerOptions.target = BuildTarget.Android;
buildPlayerOptions.options = BuildOptions.None;
BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions);
BuildSummary summary = report.summary;
if (summary.result == BuildResult.Succeeded)
{
Debug.Log("Serapion ANDROID Build succeeded: " + summary.totalSize + " bytes");
}
if (summary.result == BuildResult.Failed)
{
Debug.Log("Serapion ANDROID Build failed");
}
string getVersion = Application.version;
File.WriteAllText(file, getVersion);
}
else
{
Debug.Log("There is no new version for build!");
}
}
private static void DoBuildPipeline(bool package)
{
if (!EditorUtility.DisplayDialog(GetGameName(), "Continue making builds for all targets?", "Build", "Cancel"))
{
return;
}
// determine build folder paths
var locationDir = Application.dataPath + "/../Build/Staging/";
var locationExe = GetGameName();
// set up player build configuration
var conf = new BuildPlayerOptions {
options = /*BuildOptions.CompressWithLz4 |*/ BuildOptions.StrictMode,
scenes = EditorBuildSettingsScene.GetActiveSceneList(EditorBuildSettings.scenes)
};
// clear the staging area
if (Directory.Exists(locationDir))
{
Directory.Delete(locationDir, true);
}
// create builds for each target platform
//if (!CreateBuild(conf, BuildTarget.WebGL, "Web", locationExe, locationDir, package))
// return;
//if (!CreateBuild(conf, BuildTarget.StandaloneLinuxUniversal, "Linux", locationExe, locationDir, package))
// return;
//if (!CreateBuild(conf, BuildTarget.StandaloneOSX, "OSX", locationExe, locationDir, package))
// return;
if (!CreateBuild(conf, BuildTarget.StandaloneWindows, "Win32", locationExe + ".exe", locationDir, package))
{
return;
}
if (!CreateBuild(conf, BuildTarget.StandaloneWindows64, "Win64", locationExe + ".exe", locationDir, package))
{
return;
}
// remove the staging directory
//Directory.Delete(locationDir);
Debug.Log("--- All builds finished ---");
}
public static void BuildWeb()
{
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions();
buildPlayerOptions.scenes = new[]
{
"Assets/Scenes/Results.unity",
"Assets/Scenes/2D Physics Boxes.unity",
"Assets/Scenes/2D Physics Polygons.unity",
"Assets/Scenes/2D Physics Spheres.unity",
"Assets/Scenes/AI Agents.unity",
"Assets/Scenes/Animation & Skinning.unity",
"Assets/Scenes/Asteroid Field.unity",
"Assets/Scenes/CryptoHash Script.unity",
"Assets/Scenes/Cubes.unity",
"Assets/Scenes/Instantiate & Destroy.unity",
"Assets/Scenes/Mandelbrot Script.unity",
"Assets/Scenes/Particles.unity",
"Assets/Scenes/Physics Cubes.unity",
"Assets/Scenes/Physics Meshes.unity",
"Assets/Scenes/Physics Spheres.unity"
// "Assets/Scenes/Mandelbrot GPU.unity",
};
buildPlayerOptions.locationPathName = PlayerSettings.WebGL.threadsSupport ? "builds/WebMT" : "builds/Web";
buildPlayerOptions.target = BuildTarget.WebGL;
buildPlayerOptions.options = BuildOptions.None;
BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions);
BuildSummary summary = report.summary;
if (summary.result == BuildResult.Succeeded)
{
Debug.Log("Build succeeded: " + summary.totalSize + " bytes");
}
if (summary.result == BuildResult.Failed)
{
Debug.Log("Build failed");
}
}
static string BaseBuild(BuildTargetGroup buildTargetGroup, BuildTarget buildTarget, BuildOptions buildOptions, string buildPath, string definesSymbols, bool isPassbyBuild)
{
if (isPassbyBuild)
{
return(buildPath);
}
if (buildTarget == BuildTarget.Android && PlayerSettings.Android.useCustomKeystore && string.IsNullOrEmpty(PlayerSettings.Android.keyaliasPass))
{
PlayerSettings.Android.keyaliasPass = PlayerSettings.Android.keystorePass = "******";
}
BuildTarget targetBeforeStart = EditorUserBuildSettings.activeBuildTarget;
BuildTargetGroup targetGroupBeforeStart = BuildPipeline.GetBuildTargetGroup(targetBeforeStart);
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions {
scenes = EditorBuildSettings.scenes.Where(s => s.enabled).Select(s => s.path).ToArray(),
locationPathName = buildPath,
targetGroup = buildTargetGroup,
target = buildTarget,
options = buildOptions,
};
PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, definesSymbols);
BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions);
BuildSummary summary = report.summary;
if (summary.result == BuildResult.Succeeded)
{
Debug.Log($"{summary.platform} succeeded. \t Time: {string.Format("{0:mm\\:ss}", summary.totalTime)} \t Size: {summary.totalSize / 1048576} Mb");
}
else if (summary.result == BuildResult.Failed)
{
Debug.Log(
$"{summary.platform} failed. \t Time: {string.Format("{0:mm\\:ss}", summary.totalTime)} \t Size: {summary.totalSize / 1048576} Mb" + "\n" +
$"Warnings: {summary.totalWarnings}" + "\n" +
$"Errors: {summary.totalErrors}"
);
}
return(summary.result == BuildResult.Succeeded ? buildPath : "");
}
private void Build(ref BuildPlayerOptions options)
{
string ext;
switch (target)
{
case BuildTarget.Android:
ext = ".apk";
break;
default:
ext = "";
break;
}
options.locationPathName = $"Builds/Benchmark/{target:G}/BoatattackBenchmark{ext}";
options.target = target;
options.targetGroup = BuildPipeline.GetBuildTargetGroup(target);
options.options |= (BuildOptions.Development | BuildOptions.AutoRunPlayer);
var curTar = EditorUserBuildSettings.activeBuildTarget;
if (target != curTar)
{
EditorUserBuildSettings.SwitchActiveBuildTarget(options.targetGroup, options.target);
}
var report = BuildPipeline.BuildPlayer(options);
var summary = report.summary;
EditorUserBuildSettings.SwitchActiveBuildTarget(BuildPipeline.GetBuildTargetGroup(curTar), curTar);
switch (summary.result)
{
case BuildResult.Succeeded:
Debug.Log("Benchmark Build Complete");
break;
case BuildResult.Failed:
Debug.LogError("Benchmark Build Failed");
break;
}
}
public void Build()
{
string exportFolder;
if (!TryGetPackageExportFolder(out exportFolder, promptIfNotDefined: true))
{
UnityEngine.Debug.LogError("Could not build " + DefinitionName + " because no export folder was chosen.");
return;
}
if (_trySuffixWithGitHash)
{
string hash;
if (tryGetGitCommitHash(out hash))
{
exportFolder = Path.Combine(exportFolder, DefinitionName + "_" + hash);
}
else
{
UnityEngine.Debug.LogWarning("Failed to get git hash.");
}
}
string fullPath = Path.Combine(exportFolder, DefinitionName);
var buildOptions = new BuildPlayerOptions()
{
scenes = _scenes.Where(s => s != null).
Select(s => AssetDatabase.GetAssetPath(s)).
ToArray(),
options = _options,
};
foreach (var target in _targets)
{
buildOptions.target = target;
buildOptions.locationPathName = fullPath + "." + getFileSuffix(target);
BuildPipeline.BuildPlayer(buildOptions);
}
Process.Start(exportFolder);
}
/// <summary>
/// 通用打包函数
/// </summary>
/// <param name="buidleType"></param>
/// <param name="type"></param>
/// <param name="BuildName"></param>
/// <param name="isClearPath"></param>
private static void BuidleByType(EnumBuidleType buidleType, BuildTarget type, bool isClearPath = false)
{
//取得保存路径
string savePath = GetTargetDirPath();
//取得保存exe路径
string saveExEPath = savePath + GetSavePath(buidleType, type);
savePath = savePath + buidleType.ToString();
if (isClearPath)
{
//清空目录
ClearPath(saveExEPath);
}
//删除已经存在的游戏包
if (System.IO.File.Exists(saveExEPath))
{
System.IO.File.Delete(saveExEPath);
}
//创建目录
MakePath(saveExEPath);
UnityEngine.Debug.Log("保存路径" + saveExEPath);
//UnityEngine.Debug.Log("TYPE" + (type == BuildTarget.iOS));
//设置预先配置信息
PerSetting(buidleType);
////刷新Unity保存
//AssetDatabase.Refresh();
//设置宏定义
SetBuildingDefine(GetBuildTargetGroup(type), GetDefine(buidleType));
//取得打包Options
BuildPlayerOptions option = GetBuildPlayerOptions(type, saveExEPath);
//打包
BuildForPlatform(option, savePath);
}
void Build(BuildTarget buildTarget)
{
string fileExtension = "";
switch (buildTarget)
{
case BuildTarget.Android: fileExtension = ".apk"; break;
case BuildTarget.StandaloneWindows64: fileExtension = ".exe"; break;
default: break;
}
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions();
var appName = Application.productName;
var version = System.DateTime.Now.ToKzFormatNoStrings();
buildPlayerOptions.locationPathName = "KZBUILD/" + buildTarget.ToString() + "/" + appName + "_" + version + fileExtension;
buildPlayerOptions.target = buildTarget;
buildPlayerOptions.options = BuildOptions.None;
buildPlayerOptions.scenes = EditorBuildSettings.scenes
.Where(s => s.enabled)
.Select(s => s.path)
.ToArray();
BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions);
BuildSummary summary = report.summary;
if (summary.result == BuildResult.Succeeded)
{
Debug.Log("Build succeeded: " + summary.totalSize + " bytes, " + buildTarget.ToString());
Debug.Log(summary.outputPath);
Debug.Log("build time: " + (summary.buildEndedAt - summary.buildStartedAt).TotalSeconds);
OpenInFolder(summary.outputPath);
}
if (summary.result == BuildResult.Failed)
{
Debug.Log("Build failed");
}
}
public static void BuildStandalonePlayer()
{
var outputPath = EditorUtility.SaveFolderPanel("Choose Location of the Built Game", "", "");
if (outputPath.Length == 0)
{
return;
}
string[] levels = GetLevelsFromBuildSettings();
if (levels.Length == 0)
{
Debug.Log("Nothing to build.");
return;
}
string targetName = GetBuildTargetName(EditorUserBuildSettings.activeBuildTarget);
if (targetName == null)
{
return;
}
// Build and copy AssetBundles.
BuildScript.BuildAssetBundles();
BuildScript.CopyAssetBundlesTo(Path.Combine(Application.streamingAssetsPath, Utility.AssetBundlesOutputPath));
AssetDatabase.Refresh();
#if UNITY_5_4 || UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0
BuildOptions option = EditorUserBuildSettings.development ? BuildOptions.Development : BuildOptions.None;
BuildPipeline.BuildPlayer(levels, outputPath + targetName, EditorUserBuildSettings.activeBuildTarget, option);
#else
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions();
buildPlayerOptions.scenes = levels;
buildPlayerOptions.locationPathName = outputPath + targetName;
buildPlayerOptions.assetBundleManifestPath = GetAssetBundleManifestFilePath();
buildPlayerOptions.target = EditorUserBuildSettings.activeBuildTarget;
buildPlayerOptions.options = EditorUserBuildSettings.development ? BuildOptions.Development : BuildOptions.None;
BuildPipeline.BuildPlayer(buildPlayerOptions);
#endif
}
private static bool BuildPlayer(BuildParams param)
{
var sourAbPath = BuildHelper.GetABDirPath(param.target);
var destAbPath = Application.streamingAssetsPath;
if (!Directory.Exists(sourAbPath))
{
BuildLog.LogError("ab path not exists:" + sourAbPath);
return(false);
}
BuildHelper.ClearDir(destAbPath);
BuildHelper.CopyDir(sourAbPath, destAbPath, ".manifest|.meta");
PlayerSettings.productName = param.productName;
PlayerSettings.companyName = param.companyName;
PlayerSettings.applicationIdentifier = param.applicationIdentifier;
PlayerSettings.bundleVersion = param.version;
PlayerSettings.Android.bundleVersionCode = param.GetVersionCode();
PlayerSettings.iOS.buildNumber = param.GetVersionCode().ToString();
PlayerSettings.iOS.appleEnableAutomaticSigning = true;
PlayerSettings.iOS.appleDeveloperTeamID = param.appleDeveloperTeamID;
BuildPlayerOptions op = new BuildPlayerOptions();
op.scenes = new[] { param.startScene };
op.locationPathName = param.GetLocationPathName();
op.target = param.target;
op.options = param.isDebug ?
(BuildOptions.Development | BuildOptions.AllowDebugging | BuildOptions.ConnectWithProfiler) :
BuildOptions.None;
var result = BuildPipeline.BuildPlayer(op);
var summary = result.summary;
if (summary.result == BuildResult.Succeeded)
{
}
if (summary.result == BuildResult.Failed)
{
return(false);
}
return(true);
}
static void Android()
{
#if UNITY_EDITOR_OSX
EditorPrefs.SetString("AndroidSdkRoot", "/Applications/Android/sdk");
EditorPrefs.SetString("AndroidNdkRoot", "/Applications/android-ndk-r13b");
#elif UNITY_EDITOR_WIN
EditorPrefs.SetString("AndroidSdkRoot", "C:/Users/Public/android-sdk");
EditorPrefs.SetString("AndroidNdkRoot", "C:/Users/Public/android-ndk-r13b");
#endif
PlayerSettings.Android.keystorePass = Environment.GetCommandLineArgs().Last();
PlayerSettings.Android.keyaliasPass = Environment.GetCommandLineArgs().Last();
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions();
buildPlayerOptions.scenes = BuildScenes;
buildPlayerOptions.locationPathName = AndroidBuildPath;
buildPlayerOptions.target = BuildTarget.Android;
buildPlayerOptions.options = BuildOptions.None;
BuildPipeline.BuildPlayer(buildPlayerOptions);
}
private static void CopyAdditionalFolders(BuildPlayerOptions buildOptions, string[] additionalFolders)
{
string targetRoot = GetFolder(buildOptions);
if (string.IsNullOrEmpty(targetRoot))
{
return;
}
foreach (var additionalFolder in additionalFolders)
{
var source = Path.Combine(GetProjectPath(), additionalFolder);
var target = Path.Combine(targetRoot, additionalFolder);
if (Directory.Exists(target))
{
Directory.Delete(target, true);
}
CopyFilesRecursively(source, target);
}
}
static void BuildWindows()
{
Debug.Log("Starting Windows 64 Build");
if (InBatchMode())
{
Debug.Log("ERROR: EDITOR ONLY");
return;
}
BuildPlayerOptions options = new BuildPlayerOptions
{
scenes = GetScenesFromSettings(),
locationPathName = GetPath("win64", ".exe"),
target = BuildTarget.StandaloneWindows64,
options = BuildOptions.None
};
_Build(options);
}
static void PerformBuild()
{
string[] args = System.Environment.GetCommandLineArgs();
string buildFor = null;
for (int i = 0; i < args.Length - 1; i++)
{
if (args[i] == "-buildFor")
{
buildFor = args[i + 1].ToLower();
}
}
if (buildFor == null)
{
System.Environment.Exit(1);
}
BuildPlayerOptions options = GetBuildPlayerOptions(buildFor);
BuildPipeline.BuildPlayer(options);
}
/// <summary>
/// Generates a Player solution using the default configuration.
/// </summary>
public static void GenerateIOsPlayerSolution()
{
PlayerSettings.SetScriptingBackend(BuildTargetGroup.iOS, ScriptingImplementation.Mono2x);
EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.iOS, BuildTarget.iOS);
EditorUserBuildSettings.iOSBuildConfigType = iOSBuildType.Release;
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions()
{
locationPathName = "iOS\\Xcode",
target = BuildTarget.iOS,
targetGroup = BuildTargetGroup.iOS,
options = BuildOptions.None,
scenes = EditorBuildSettings.scenes
.Where(scene => scene.enabled)
.Select(scene => scene.path)
.ToArray(),
};
BuildPipeline.BuildPlayer(buildPlayerOptions);
}
private static void BuildPlayer(BuildTarget target, BuildParams param)
{
PlayerSettings.productName = param.productName;
PlayerSettings.applicationIdentifier = param.applicationIdentifier;
PlayerSettings.bundleVersion = param.apkVersion;
PlayerSettings.Android.bundleVersionCode = param.bundleVersionCode;
PlayerSettings.iOS.buildNumber = param.bundleVersionCode.ToString();
PlayerSettings.iOS.appleEnableAutomaticSigning = true;
PlayerSettings.iOS.appleDeveloperTeamID = param.appleDeveloperTeamID;
BuildPlayerOptions op = new BuildPlayerOptions();
op.scenes = new[] { param.startScene };
op.target = target;
op.options = param.isDebug ? (BuildOptions.Development | BuildOptions.AllowDebugging | BuildOptions.ConnectWithProfiler) :
BuildOptions.None;
var result = BuildPipeline.BuildPlayer(op);
var summary = result.summary;
}
public static void BuildiOS()
{
Debug.Log("Starting iOS Build");
if (InBatchMode())
{
Debug.Log("ERROR: EDITOR ONLY");
return;
}
BuildPlayerOptions options = new BuildPlayerOptions
{
scenes = GetScenesFromSettings(),
locationPathName = GetPath("ios", ""),
target = BuildTarget.iOS,
options = BuildOptions.Il2CPP
};
_Build(options);
}
static void BuildLinux()
{
Debug.Log("Starting Linux Build");
if (InBatchMode())
{
Debug.Log("ERROR: EDITOR ONLY");
return;
}
BuildPlayerOptions options = new BuildPlayerOptions
{
scenes = GetScenesFromSettings(),
locationPathName = GetPath("linux", ".x86"),
target = BuildTarget.StandaloneLinuxUniversal,
options = BuildOptions.Il2CPP
};
_Build(options);
}
// Gets the config file used the build the game for the target
protected virtual BuildPlayerOptions GetConfig(BuildTarget target)
{
// setup for target platform
BuildPlayerOptions config = new BuildPlayerOptions();
config.targetGroup = BuildTargetGroup.Standalone;
config.target = target;
// loads scenes provided in build settings
config.scenes =
UnityEditor.EditorBuildSettings.scenes
.Where(scene => scene.enabled)
.Select(scene => scene.path)
.ToArray();
// determine build path
config.locationPathName = GetBuildDeliverablePath(target);
return(config);
}
public static void BuildWebGL()
{
var buildPath = GetArg("-buildPath", "obj/webgl");
PlayerSettings.WebGL.emscriptenArgs = "";
var buildPlayerOptions = new BuildPlayerOptions()
{
locationPathName = buildPath,
scenes = EditorBuildSettings.scenes.Select(s => s.path).ToArray(),
targetGroup = BuildTargetGroup.WebGL,
target = BuildTarget.WebGL,
options = BuildOptions.None
};
PlayerSettings.WebGL.compressionFormat = WebGLCompressionFormat.Brotli;
PlayerSettings.WebGL.linkerTarget = WebGLLinkerTarget.Both;
PlayerSettings.SetManagedStrippingLevel(BuildTargetGroup.WebGL, ManagedStrippingLevel.Medium);
BuildPlayerWindow.DefaultBuildMethods.BuildPlayer(buildPlayerOptions);
}
public void BuildingBenchmark()
{
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions();
buildPlayerOptions.scenes = new[] { "Assets/Artemis Benchmarking Tool/Resources/Scenes/Shapes.unity", "Assets/Artemis Benchmarking Tool/Resources/Scenes/CorridorDemo.unity", "Assets/Artemis Benchmarking Tool/Resources/Scenes/Tanks.unity" };
buildPlayerOptions.locationPathName = "BenchmarkBuild";
buildPlayerOptions.target = BuildTarget.StandaloneWindows;
buildPlayerOptions.options = BuildOptions.None;
double TimeBefore = EditorApplication.timeSinceStartup;
if (ClearCache)
{
AssetDatabase.Refresh();
}
BuildPipeline.BuildPlayer(buildPlayerOptions);
double TimeElapsed = EditorApplication.timeSinceStartup - TimeBefore;
StoreResults(TimeElapsed);
}
static void ProductionBuild()
{
BuildPlayerOptions bpo = new BuildPlayerOptions();
bpo.locationPathName = "Builds/WinServer";
bpo.target = BuildTarget.StandaloneWindows64;
bpo.options = BuildOptions.EnableHeadlessMode; // headless mode for server
// get gameplay scenes... they should all be included for client+server
var scenesForBuild = GetGameplayScenes();
// configure startup scene for the server build.
scenesForBuild.Insert(0, "Assets/Scenes/ServerStart.unity");
// assign scenes to build
bpo.scenes = scenesForBuild.ToArray();
// run the build
BuildPipeline.BuildPlayer(bpo);
}
/// <summary>
/// Callback invoked before a profile build is started.
/// </summary>
/// <remarks>
/// When a build is started on a <see cref="T:sttz.Trimmer.Editor.BuildProfile"/>, all options
/// will receive this callback before the build is started.
///
/// This callback allows Option to influence the build settings, including
/// build options, output path and included scenes.
///
/// By default, the build will include the scenes set in Unity's build
/// player window and the options will be set to `BuildOptions.None`.
/// If no Option sets the location path name, the user will be prompted
/// to choose it.
///
/// > [!WARNING]
/// > This method will not be called for regular Unity builds,
/// > started from the build player window or using the build menu item.
///
/// > [!NOTE]
/// > This method is only available in the editor.
/// </remarks>
/// <param name="options">The current options</param>
/// <param name="inclusion">Wether the Option is included in the build.</param>
/// <returns>The modified options.</returns>
public virtual BuildPlayerOptions PrepareBuild(BuildPlayerOptions options, OptionInclusion inclusion)
{
if (variants != null)
{
foreach (var variant in variants)
{
options = variant.PrepareBuild(options, inclusion);
}
}
if (children != null)
{
foreach (var child in children)
{
options = child.PrepareBuild(options, inclusion);
}
}
return(options);
}
public static void BuildStandalonePlayer()
{
var outputPath =
Path.Combine(Environment.CurrentDirectory,
"Build/" + GetPlatformName()
.ToLower()); //EditorUtility.SaveFolderPanel("Choose Location of the Built Game", "", "");
if (outputPath.Length == 0)
{
return;
}
var levels = GetLevelsFromBuildSettings();
if (levels.Length == 0)
{
Log.Print("Nothing to build.");
return;
}
var targetName = GetBuildTargetName(EditorUserBuildSettings.activeBuildTarget);
if (targetName == null)
{
return;
}
#if UNITY_5_4 || UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0
BuildOptions option = EditorUserBuildSettings.development ? BuildOptions.Development : BuildOptions.None;
BuildPipeline.BuildPlayer(levels, outputPath + targetName, EditorUserBuildSettings.activeBuildTarget, option);
#else
var buildPlayerOptions = new BuildPlayerOptions
{
scenes = levels,
locationPathName = outputPath + targetName,
assetBundleManifestPath = GetAssetBundleManifestFilePath(),
target = EditorUserBuildSettings.activeBuildTarget,
options = EditorUserBuildSettings.development ? BuildOptions.Development : BuildOptions.None
};
BuildPipeline.BuildPlayer(buildPlayerOptions);
#endif
}
public static void MyBuildBothPc()
{
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions();
buildPlayerOptions.scenes = new[] { "Assets/Project/Scenes/MenuReseau.unity", "Assets/Project/Scenes/Game.unity" };
buildPlayerOptions.locationPathName = "Build/Client/Client.exe";
buildPlayerOptions.target = BuildTarget.StandaloneWindows;
buildPlayerOptions.options = BuildOptions.None;
BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions);
BuildSummary summary = report.summary;
if (summary.result == BuildResult.Succeeded)
{
Debug.Log("Build succeeded: " + summary.totalSize + " bytes");
}
if (summary.result == BuildResult.Failed)
{
Debug.Log("Build failed");
}
BuildPlayerOptions buildPlayerOptions1 = new BuildPlayerOptions();
buildPlayerOptions1.scenes = new[] { "Assets/Project/Scenes/Server.unity" };
buildPlayerOptions1.locationPathName = "Build/Serveur/Server.exe";
buildPlayerOptions1.target = BuildTarget.StandaloneWindows;
buildPlayerOptions1.options = BuildOptions.None;
BuildReport report1 = BuildPipeline.BuildPlayer(buildPlayerOptions1);
BuildSummary summary1 = report1.summary;
if (summary1.result == BuildResult.Succeeded)
{
Debug.Log("Build succeeded: " + summary1.totalSize + " bytes");
}
if (summary1.result == BuildResult.Failed)
{
Debug.Log("Build failed");
}
}
private static void DoBuildApk()
{
if (EditorUserBuildSettings.activeBuildTarget != BuildTarget.Android)
{
return;
}
if (!EditorUtility.DisplayDialog(
"Confirm", "Ready to make Apk?", "OK", "Cancel"))
{
return;
}
DoBuildAssetBundles();
var scenes = new List <string>();
foreach (EditorBuildSettingsScene scene in EditorBuildSettings.scenes)
{
if (scene.enabled)
{
scenes.Add(scene.path);
}
}
var outputDir = Application.dataPath + "/../Output";
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
var playerOptions = new BuildPlayerOptions();
playerOptions.scenes = scenes.ToArray();
playerOptions.locationPathName = outputDir + "/Game.apk";
playerOptions.target = EditorUserBuildSettings.activeBuildTarget;
playerOptions.options = BuildOptions.Development | BuildOptions.ConnectWithProfiler;
BuildPipeline.BuildPlayer(playerOptions);
}
private void PrepareBuildOptions()
{
//准备BuildOptions
BuildOptions buildOptions =
(Module.ModuleStateConfig.Json.DevelopmentBuild ? BuildOptions.Development : BuildOptions.None) |
(Module.ModuleStateConfig.Json.ConnectWithProfiler ? BuildOptions.ConnectWithProfiler : BuildOptions.None) |
(Module.ModuleStateConfig.Json.AllowDebugging ? BuildOptions.AllowDebugging : BuildOptions.None) |
(Module.UserConfig.Json.BuildSettings.CompressionMethod == UserConfig.BuildSettings.CompressionMethodEnum.LZ4 ? BuildOptions.CompressWithLz4 : BuildOptions.None) |
(Module.UserConfig.Json.BuildSettings.CompressionMethod == UserConfig.BuildSettings.CompressionMethodEnum.LZ4HC ? BuildOptions.CompressWithLz4HC : BuildOptions.None);
//设置路径和文件名
string tagsPath = Path.Combine(Module.ModuleConfig.WorkPath, EBPUtility.GetTagStr(Module.ModuleStateConfig.Json.CurrentTag));
string locationPath;
string versionInfo = string.Format("{0}_{1}.{2}", PlayerSettings.productName, PlayerSettings.bundleVersion, PlayerSettings.Android.bundleVersionCode);
switch (EditorUserBuildSettings.activeBuildTarget)
{
case BuildTarget.Android:
locationPath = Path.Combine(tagsPath, versionInfo + ".apk");
break;
case BuildTarget.iOS:
locationPath = Path.Combine(tagsPath, "Project");
break;
default:
throw new EBPException("意外的平台：" + EditorUserBuildSettings.activeBuildTarget);
}
//获取场景
string[] scenes = EditorBuildSettingsScene.GetActiveSceneList(EditorBuildSettings.scenes).Take(2).ToArray(); //Hack: 只获取头两个场景
//构成BuildPlayerOptions
BuildPlayerOptions = new BuildPlayerOptions
{
scenes = scenes,
locationPathName = locationPath,
target = EditorUserBuildSettings.activeBuildTarget,
options = buildOptions
};
}
public static void BuildPackage()
{
//先配置资产，然后再打包
ConfigAsset();
#if UNITY_ANDROID
BuildAssetNameSetting(assetPath);
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions();
var buildScenes = EditorBuildSettings.scenes;
List <string> scenePath = new List <string>();
for (int i = 0; i < buildScenes.Length; i++)
{
if (buildScenes[i].enabled)
{
scenePath.Add(buildScenes[i].path);
DebugConsole.Log("build scene: " + buildScenes[i].path);
}
}
buildPlayerOptions.scenes = scenePath.ToArray();
buildPlayerOptions.locationPathName = string.Format(@"..\Output\Android_{0}.apk", System.DateTime.Now.ToString("MMddHHmmss"));
buildPlayerOptions.target = BuildTarget.Android;
buildPlayerOptions.options = BuildOptions.None;
BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions);
BuildSummary summary = report.summary;
if (summary.result == BuildResult.Succeeded)
{
Debug.Log("Build succeeded: " + summary.totalSize + " bytes");
}
if (summary.result == BuildResult.Failed)
{
Debug.Log("Build failed");
}
System.Diagnostics.Process.Start(@"..\Output");
#endif
}
/// <summary>
/// <para>Builds a player.</para>
/// </summary>
/// <param name="buildPlayerOptions">Provide various options to control the behavior of BuildPipeline.BuildPlayer.</param>
/// <returns>
/// <para>An error message if an error occurred.</para>
/// </returns>
public static string BuildPlayer(BuildPlayerOptions buildPlayerOptions)
{
return BuildPlayer(buildPlayerOptions.scenes, buildPlayerOptions.locationPathName, buildPlayerOptions.assetBundleManifestPath, buildPlayerOptions.target, buildPlayerOptions.options);
}
/// <summary>
/// <para>Builds a player. These overloads are still supported, but will be replaces by BuildPlayer (BuildPlayerOptions). Please use it instead.</para>
/// </summary>
/// <param name="levels">The scenes to be included in the build. If empty, the currently open scene will be built. Paths are relative to the project folder (AssetsMyLevelsMyScene.unity).</param>
/// <param name="locationPathName">The path where the application will be built.</param>
/// <param name="target">The BuildTarget to build.</param>
/// <param name="options">Additional BuildOptions, like whether to run the built player.</param>
/// <returns>
/// <para>An error message if an error occurred.</para>
/// </returns>
public static string BuildPlayer(string[] levels, string locationPathName, BuildTarget target, BuildOptions options)
{
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions {
scenes = levels,
locationPathName = locationPathName,
target = target,
options = options
};
return BuildPlayer(buildPlayerOptions);
}
/// <summary>
/// <para>Builds a player. These overloads are still supported, but will be replaces by BuildPlayer (BuildPlayerOptions). Please use it instead.</para>
/// </summary>
/// <param name="levels">The scenes to be included in the build. If empty, the currently open scene will be built. Paths are relative to the project folder (AssetsMyLevelsMyScene.unity).</param>
/// <param name="locationPathName">The path where the application will be built.</param>
/// <param name="target">The BuildTarget to build.</param>
/// <param name="options">Additional BuildOptions, like whether to run the built player.</param>
/// <returns>
/// <para>An error message if an error occurred.</para>
/// </returns>
public static string BuildPlayer(EditorBuildSettingsScene[] levels, string locationPathName, BuildTarget target, BuildOptions options)
{
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions {
scenes = EditorBuildSettingsScene.GetActiveSceneList(levels),
locationPathName = locationPathName,
target = target,
options = options
};
return BuildPlayer(buildPlayerOptions);
}
