| private BuildPlayerInternalNoCheck ( string levels, string locationPathName, string assetBundleManifestPath, BuildTarget target, BuildOptions options, bool delayToAfterScriptReload ) : BuildReport | ||
| levels | string | |
| locationPathName | string | |
| assetBundleManifestPath | string | |
| target | BuildTarget | |
| options | BuildOptions | |
| delayToAfterScriptReload | bool | |
| 리턴 | BuildReport | |
private static BuildReport BuildPlayerInternal(string[] levels, string locationPathName, string assetBundleManifestPath, BuildTargetGroup buildTargetGroup, BuildTarget target, BuildOptions options)
{
if ((BuildOptions.EnableHeadlessMode & options) != BuildOptions.None && (BuildOptions.Development & options) != BuildOptions.None)
{
throw new Exception("Unsupported build setting: cannot build headless development player");
}
return(BuildPipeline.BuildPlayerInternalNoCheck(levels, locationPathName, assetBundleManifestPath, buildTargetGroup, target, options, false));
}
private static BuildReport BuildPlayerInternal(string[] levels, string locationPathName, BuildTarget target, BuildOptions options)
{
if ((BuildOptions.EnableHeadlessMode & options) != BuildOptions.None && (BuildOptions.Development & options) != BuildOptions.None)
{
throw new Exception("Unsupported build setting: cannot build headless development player");
}
if (target == BuildTarget.WSAPlayer && EditorUserBuildSettings.wsaSDK == WSASDK.SDK80)
{
throw new Exception("Windows SDK 8.0 is no longer supported, please switch to Windows SDK 8.1");
}
return(BuildPipeline.BuildPlayerInternalNoCheck(levels, locationPathName, target, options, false));
}
private static string BuildPlayerInternal(string[] levels, string locationPathName, BuildTarget target, BuildOptions options, out uint crc)
{
crc = 0u;
if (!InternalEditorUtility.HasProFeaturesEnabled())
{
Debug.LogError("Building Player from editor scripts requires Unity PRO");
return("Building Player from editor scripts requires Unity PRO");
}
if ((BuildOptions.EnableHeadlessMode & options) != BuildOptions.None && (BuildOptions.Development & options) != BuildOptions.None)
{
return("Unsupported build setting: cannot build headless development player");
}
return(BuildPipeline.BuildPlayerInternalNoCheck(levels, locationPathName, target, options, false, out crc));
}
/// <summary>
/// Default implementation of the build player method.
/// </summary>
/// <param name="options"></param>
public static void BuildPlayer(BuildPlayerOptions options)
{
if (!UnityConnect.instance.canBuildWithUPID)
{
if (!EditorUtility.DisplayDialog("Missing Project ID", "Because you are not a member of this project this build will not access Unity services.\nDo you want to continue?", "Yes", "No"))
{
throw new BuildMethodException();
}
}
if (!BuildPipeline.IsBuildTargetSupported(options.targetGroup, options.target))
{
throw new BuildMethodException("Build target is not supported.");
}
string module = ModuleManager.GetTargetStringFrom(EditorUserBuildSettings.selectedBuildTargetGroup, options.target);
IBuildWindowExtension buildWindowExtension = ModuleManager.GetBuildWindowExtension(module);
if (buildWindowExtension != null && (options.options & BuildOptions.AutoRunPlayer) != 0 && !buildWindowExtension.EnabledBuildAndRunButton())
{
throw new BuildMethodException();
}
if (Unsupported.IsBleedingEdgeBuild())
{
var sb = new System.Text.StringBuilder();
sb.AppendLine("This version of Unity is a BleedingEdge build that has not seen any manual testing.");
sb.AppendLine("You should consider this build unstable.");
sb.AppendLine("We strongly recommend that you use a normal version of Unity instead.");
if (EditorUtility.DisplayDialog("BleedingEdge Build", sb.ToString(), "Cancel", "OK"))
{
throw new BuildMethodException();
}
}
// See if we need to switch platforms and delay the build. We do this whenever
// we're trying to build for a target different from the active one so as to ensure
// that the compiled script code we have loaded is built for the same platform we
// are building for. As we can't reload while our editor stuff is still executing,
// we need to defer to after the next script reload then.
bool delayToAfterScriptReload = false;
if (EditorUserBuildSettings.activeBuildTarget != options.target ||
EditorUserBuildSettings.activeBuildTargetGroup != options.targetGroup)
{
if (!EditorUserBuildSettings.SwitchActiveBuildTargetAsync(options.targetGroup, options.target))
{
// Switching the build target failed. No point in trying to continue
// with a build.
var errStr = string.Format("Could not switch to build target '{0}', '{1}'.",
BuildPipeline.GetBuildTargetGroupDisplayName(options.targetGroup),
BuildPlatforms.instance.GetBuildTargetDisplayName(options.targetGroup, options.target));
throw new BuildMethodException(errStr);
}
if (EditorApplication.isCompiling)
{
delayToAfterScriptReload = true;
}
}
// Trigger build.
// Note: report will be null, if delayToAfterScriptReload = true
var report = BuildPipeline.BuildPlayerInternalNoCheck(options.scenes, options.locationPathName, null, options.targetGroup, options.target, options.options, delayToAfterScriptReload);
if (report != null)
{
var resultStr = String.Format("Build completed with a result of '{0}'", report.summary.result.ToString("g"));
switch (report.summary.result)
{
case Build.Reporting.BuildResult.Unknown:
Debug.LogWarning(resultStr);
break;
case Build.Reporting.BuildResult.Failed:
DeleteBuildFolderIfEmpty(report.summary.outputPath);
Debug.LogError(resultStr);
throw new BuildMethodException(report.SummarizeErrors());
default:
Debug.Log(resultStr);
break;
}
buildCompletionHandler?.Invoke(report);
}
}