public override BuildResult Run(BuildContext context)
{
var target = context.GetValue <ClassicSharedData>().BuildTarget;
if (target == BuildTarget.NoTarget)
{
return(context.Failure($"Invalid build target '{target.ToString()}'."));
}
if (EditorUserBuildSettings.activeBuildTarget == target)
{
return(context.Success());
}
var group = UnityEditor.BuildPipeline.GetBuildTargetGroup(target);
if (EditorUserBuildSettings.SwitchActiveBuildTargetAsync(group, target))
{
return(context.Failure($"Editor's active Build Target needed to be switched to {target} (BuildTargetGroup {group}). Please wait for switch to complete and then build again."));
}
else
{
return(context.Failure($"Editor's active Build Target could not be switched to {target} (BuildTargetGroup {group}). Look in the console or the editor log for additional errors."));
}
}
public override BuildResult Run(BuildContext context)
{
var profile = context.GetComponentOrDefault <DotsRuntimeBuildProfile>();
var rootAssembly = context.GetComponentOrDefault <DotsRuntimeRootAssembly>();
var targetName = rootAssembly.MakeBeeTargetName(context.BuildConfigurationName);
var workingDir = DotsRuntimeRootAssembly.BeeRootDirectory;
var outputDir = new DirectoryInfo(BuildStepGenerateBeeFiles.GetFinalOutputDirectory(context, targetName));
var result = BeeTools.Run(targetName, workingDir, context.BuildProgress);
WorldExport.GetOrCreateLogDirectoryFrom(targetName).GetFile("BuildLog.txt").WriteAllText(result.Output);
workingDir.GetFile("runbuild" + ShellScriptExtension()).UpdateAllText(result.Command);
if (result.Failed)
{
return(context.Failure(result.Error));
}
if (!string.IsNullOrEmpty(rootAssembly.ProjectName))
{
var outputTargetFile = outputDir.GetFile(rootAssembly.ProjectName + profile.Target.ExecutableExtension);
context.SetBuildArtifact(new DotsRuntimeBuildArtifact {
OutputTargetFile = outputTargetFile
});
}
return(context.Success());
}
public override BuildResult Run(BuildContext context)
{
if (!EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo())
{
return(context.Failure($"All Scenes and Assets must be saved before a build can be started."));
}
return(context.Success());
}
BuildResult FindProperty(BuildContext context, SerializedObject serializedObject, string name, out SerializedProperty serializedProperty)
{
serializedProperty = serializedObject.FindProperty(name);
if (serializedProperty == null)
{
return(context.Failure($"Failed to find: {name}"));
}
return(context.Success());
}
public override BuildResult Run(BuildContext context)
{
var report = context.GetValue<BuildReport>();
if (report == null)
{
return context.Failure($"Could not retrieve {nameof(BuildReport)} from build context.");
}
var artifact = context.GetOrCreateBuildArtifact<WindowsArtifact>();
artifact.OutputTargetFile = new FileInfo(report.summary.outputPath);
return context.Success();
}
protected override BuildResult OnBuild(BuildContext context) => context.Failure(nameof(TestBuildPipelineBuildFails));
public override BuildResult Run(BuildContext context) => context.Failure(nameof(TestBuildStepFails));
public override BuildResult Run(BuildContext context)
{
var classicSharedData = context.GetValue <ClassicSharedData>();
var target = classicSharedData.BuildTarget;
if (target <= 0)
{
return(context.Failure($"Invalid build target '{target.ToString()}'."));
}
if (target != EditorUserBuildSettings.activeBuildTarget)
{
return(context.Failure($"{nameof(EditorUserBuildSettings.activeBuildTarget)} must be switched before {nameof(BuildPlayerStep)} step."));
}
var embeddedScenes = context.GetValue <EmbeddedScenesValue>().Scenes;
if (embeddedScenes.Length == 0)
{
return(context.Failure("There are no scenes to build."));
}
var outputPath = context.GetOutputBuildDirectory();
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
string locationPathName;
if (context.HasValue <LocationInfo>())
{
locationPathName = context.GetValue <LocationInfo>().Path;
}
else
{
var generalSettings = context.GetComponentOrDefault <GeneralSettings>();
locationPathName = Path.Combine(outputPath, generalSettings.ProductName + ClassicBuildProfile.GetExecutableExtension(target));
}
var buildPlayerOptions = new BuildPlayerOptions()
{
scenes = embeddedScenes,
target = target,
locationPathName = locationPathName,
targetGroup = UnityEditor.BuildPipeline.GetBuildTargetGroup(target),
};
buildPlayerOptions.options = BuildOptions.None;
foreach (var customizer in classicSharedData.Customizers)
{
buildPlayerOptions.options |= customizer.ProvideBuildOptions();
}
var extraScriptingDefines = classicSharedData.Customizers.SelectMany(c => c.ProvidePlayerScriptingDefines()).ToArray();
#if UNITY_2020_1_OR_NEWER
buildPlayerOptions.extraScriptingDefines = extraScriptingDefines;
#else
if (extraScriptingDefines.Length > 0)
{
return(context.Failure("Your build is using player scripting defines, this Unity version doesn't support them, please use Unity version 2020.1 or higher. Defines used:\n" +
string.Join("\n", extraScriptingDefines)));
}
#endif
var report = UnityEditor.BuildPipeline.BuildPlayer(buildPlayerOptions);
context.SetValue(report);
return(context.FromReport(report));
}
public override BuildResult Run(BuildContext context)
{
var classicSharedData = context.GetValue <ClassicSharedData>();
var target = classicSharedData.BuildTarget;
if (target <= 0)
{
return(context.Failure($"Invalid build target '{target.ToString()}'."));
}
if (target != EditorUserBuildSettings.activeBuildTarget)
{
return(context.Failure($"{nameof(EditorUserBuildSettings.activeBuildTarget)} must be switched before {nameof(BuildPlayerStep)} step."));
}
var embeddedScenes = context.GetValue <EmbeddedScenesValue>().Scenes;
if (embeddedScenes.Length == 0)
{
return(context.Failure("There are no scenes to build."));
}
var outputPath = context.GetOutputBuildDirectory();
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
string locationPathName;
if (context.HasValue <LocationInfo>())
{
locationPathName = context.GetValue <LocationInfo>().Path;
}
else
{
var generalSettings = context.GetComponentOrDefault <GeneralSettings>();
locationPathName = Path.Combine(outputPath, generalSettings.ProductName + ClassicBuildProfile.GetExecutableExtension(target));
}
var buildPlayerOptions = new BuildPlayerOptions()
{
scenes = embeddedScenes,
target = target,
locationPathName = locationPathName,
targetGroup = UnityEditor.BuildPipeline.GetBuildTargetGroup(target),
};
buildPlayerOptions.options = BuildOptions.None;
foreach (var customizer in classicSharedData.Customizers)
{
buildPlayerOptions.options |= customizer.ProvideBuildOptions();
}
var extraScriptingDefines = classicSharedData.Customizers.SelectMany(c => c.ProvidePlayerScriptingDefines()).ToArray();
buildPlayerOptions.extraScriptingDefines = extraScriptingDefines;
var report = UnityEditor.BuildPipeline.BuildPlayer(buildPlayerOptions);
context.SetValue(report);
return(report.summary.result == UnityEditor.Build.Reporting.BuildResult.Succeeded ?
context.Success() : context.Failure("See console log for more details."));
}
public override BuildResult Run(BuildContext context)
{
var manifest = context.BuildManifest;
var rootAssembly = context.GetComponentOrDefault <DotsRuntimeRootAssembly>();
var buildScenes = context.GetComponentOrDefault <SceneList>();
var targetName = rootAssembly.MakeBeeTargetName(context.BuildConfigurationName);
var scenePaths = buildScenes.GetScenePathsForBuild();
var buildConfigurationGuid = context.BuildConfigurationAssetGUID;
var dataDirectory = WorldExport.GetOrCreateDataDirectoryFrom(rootAssembly.StagingDirectory.Combine(targetName));
var logsDirectory = WorldExport.GetOrCreateLogDirectoryFrom(targetName);
var sceneGuids = scenePaths.SelectMany(scenePath =>
{
var guids = EditorEntityScenes.GetSubScenes(AssetDatabaseCompatibility.PathToGUID(scenePath)).ToList();
guids.Add(AssetDatabaseCompatibility.PathToGUID(scenePath));
return(guids);
}).Distinct().ToList();
//Save all unsaved scenes of the project first
foreach (var guid in sceneGuids)
{
string scenePath = AssetDatabase.GUIDToAssetPath(guid.ToString());
var scene = SceneManager.GetSceneByPath(scenePath);
EditorSceneManager.SaveScene(scene);
}
var requiresRefresh = false;
var sceneBuildConfigGuids = new NativeArray <GUID>(sceneGuids.Count, Allocator.TempJob);
for (int i = 0; i != sceneBuildConfigGuids.Length; i++)
{
sceneBuildConfigGuids[i] = SceneWithBuildConfigurationGUIDs.EnsureExistsFor(sceneGuids[i], new Hash128(buildConfigurationGuid), false, out var thisRequiresRefresh);
requiresRefresh |= thisRequiresRefresh;
}
if (requiresRefresh)
{
AssetDatabase.Refresh();
}
var artifactHashes = new NativeArray <UnityEngine.Hash128>(sceneGuids.Count, Allocator.TempJob);
AssetDatabaseCompatibility.ProduceArtifactsRefreshIfNecessary(sceneBuildConfigGuids, typeof(SubSceneImporter), artifactHashes);
bool succeeded = true;
for (int i = 0; i != sceneBuildConfigGuids.Length; i++)
{
var sceneGuid = sceneGuids[i];
var artifactHash = artifactHashes[i];
AssetDatabaseCompatibility.GetArtifactPaths(artifactHash, out var artifactPaths);
List <FileInfo> exportedFiles = new List <FileInfo>();
bool foundEntityHeader = false;
foreach (var artifactPath in artifactPaths)
{
var ext = Path.GetExtension(artifactPath).ToLower().Replace(".", "");
if (ext == EntityScenesPaths.GetExtension(EntityScenesPaths.PathType.EntitiesHeader))
{
foundEntityHeader = true;
var destinationFile = dataDirectory.FullName + Path.DirectorySeparatorChar + EntityScenesPaths.RelativePathFolderFor(sceneGuid, EntityScenesPaths.PathType.EntitiesHeader, -1);
new NPath(artifactPath).MakeAbsolute().Copy(new NPath(destinationFile).MakeAbsolute().EnsureParentDirectoryExists());
exportedFiles.Add(new FileInfo(destinationFile));
}
else if (ext == EntityScenesPaths.GetExtension(EntityScenesPaths.PathType.EntitiesBinary))
{
var destinationFile = dataDirectory.FullName + Path.DirectorySeparatorChar + EntityScenesPaths.RelativePathFolderFor(sceneGuid, EntityScenesPaths.PathType.EntitiesBinary, EntityScenesPaths.GetSectionIndexFromPath(artifactPath));
new NPath(artifactPath).MakeAbsolute().Copy(new NPath(destinationFile).MakeAbsolute().EnsureParentDirectoryExists());
exportedFiles.Add(new FileInfo(destinationFile));
}
else if (ext == EntityScenesPaths.GetExtension(EntityScenesPaths.PathType.EntitiesConversionLog))
{
var destinationFile = logsDirectory.FullName + Path.DirectorySeparatorChar + $"{sceneGuid}.{EntityScenesPaths.GetExtension(EntityScenesPaths.PathType.EntitiesConversionLog)}";
new NPath(artifactPath).MakeAbsolute().Copy(new NPath(destinationFile).MakeAbsolute().EnsureParentDirectoryExists());
var result = PrintConversionLogToUnityConsole(artifactPath);
if (result.HasError || result.HasException)
{
UnityEngine.Debug.LogError("Failed to export scene: " + Path.GetFileName(AssetDatabase.GUIDToAssetPath(sceneGuid.ToString())));
succeeded = false;
}
}
else if (new Hash128(ext).IsValid) //Asset files are exported as {artifactHash}.{assetguid}
{
var destinationFile = dataDirectory.FullName + Path.DirectorySeparatorChar + ext;
new NPath(artifactPath).MakeAbsolute().Copy(new NPath(destinationFile).MakeAbsolute().EnsureParentDirectoryExists());
exportedFiles.Add(new FileInfo(destinationFile));
}
}
if (!foundEntityHeader)
{
Debug.LogError($"Failed to build EntityScene for '{AssetDatabaseCompatibility.GuidToPath(sceneGuid)}'.");
succeeded = false;
}
//UpdateManifest
manifest.Add(new Guid(sceneGuid.ToString()), AssetDatabase.GUIDToAssetPath(sceneGuid.ToString()), exportedFiles);
}
var catalogPath = Path.Combine(dataDirectory.ToString(), SceneSystem.k_SceneInfoFileName);
WriteCatalogFile(catalogPath, buildScenes);
manifest.AddAdditionalFilesToDeploy(new FileInfo(catalogPath.ToString()));
sceneBuildConfigGuids.Dispose();
artifactHashes.Dispose();
if (succeeded)
{
return(context.Success());
}
return(context.Failure($"Failed to export scenes"));
}
public override BuildResult Run(BuildContext context)
{
var exportSettings = context.GetComponentOrDefault <AndroidExportSettings>();
var isAppBundle = exportSettings.TargetType == AndroidTargetType.AndroidAppBundle;
var classicData = context.GetValue <ClassicSharedData>();
var nonIncrementalClassicData = context.GetValue <NonIncrementalClassicSharedData>();
var gradleJarFile = GradleTools.GetGradleLauncherJar(classicData.BuildToolsDirectory);
var gradleTask = GradleTools.GetGradleTask(classicData.DevelopmentPlayer, isAppBundle);
var gradleOuputDirectory = Path.Combine(nonIncrementalClassicData.TemporaryDirectory, "gradleOut");
var gradleFile = Path.Combine(gradleOuputDirectory, "build.gradle");
#if UNITY_ANDROID
var jdkPath = AndroidExternalToolsSettings.jdkRootPath;
#else
var jdkPath = "";
#endif
var fileName = Path.Combine(jdkPath, "bin", "java" + (Application.platform == RuntimePlatform.WindowsEditor ? ".exe" : ""));
var args = string.Join(" ",
new[]
{
"-classpath",
$"\"{gradleJarFile}\"",
"org.gradle.launcher.GradleMain",
"-b",
$"\"{gradleFile}\"",
$"\"{gradleTask}\""
});
Process process = new Process();
process.StartInfo.FileName = fileName;
process.StartInfo.Arguments = args;
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.CreateNoWindow = true;
var output = new StringBuilder();
process.OutputDataReceived += new DataReceivedEventHandler((sender, e) =>
{
if (!string.IsNullOrEmpty(e.Data))
{
output.AppendLine(e.Data);
}
});
var error = new StringBuilder();
process.ErrorDataReceived += new DataReceivedEventHandler((sender, e) =>
{
if (!string.IsNullOrEmpty(e.Data))
{
error.AppendLine(e.Data);
}
});
process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();
process.WaitForExit();
BuildResult result;
if (process.ExitCode == 0)
{
var outputPath = Path.Combine(gradleOuputDirectory, GradleTools.GetGradleOutputPath(classicData.DevelopmentPlayer, isAppBundle));
var finalPath = Path.Combine(context.GetOutputBuildDirectory(), context.GetComponentOrDefault <GeneralSettings>().ProductName + Path.GetExtension(outputPath));
File.Copy(outputPath, finalPath, true);
var artifact = context.GetOrCreateBuildArtifact <AndroidArtifact>();
artifact.OutputTargetFile = new FileInfo(finalPath);
result = context.Success();
}
else
{
result = context.Failure(output.ToString() + error.ToString());
}
process.Close();
return(result);
}
