public void RunBuild(BuildReport buildReport)
{
buildReport.BuildDefinitionName = Name;
buildReport.StartedAt = DateTime.UtcNow;
foreach (var step in Steps)
{
var stepReport = new StepReport();
try
{
step.Execute(stepReport);
if(string.IsNullOrWhiteSpace(step.Summary) == false)
stepReport.Summary = this.CreateReport(step.Summary, stepReport.Report);
}
catch (Exception exception)
{
stepReport.Error = exception;
}
stepReport.FinishedAt = DateTime.UtcNow;
buildReport.AddStepReport(stepReport);
}
buildReport.FinishedAt = DateTime.UtcNow;
}
public void Save(BuildReport buildReport)
{
using(var session = store.OpenSession())
{
session.Store(buildReport);
session.SaveChanges();
}
}
public void StartBuildSequence()
{
var buildReport = new BuildReport(orderedAt, TriggerName);
try
{
buildDefinition.RunBuild(buildReport);
}
catch (Exception exception)
{
buildReport.UnhandledException = exception;
}
buildReport.FinishedAt = DateTime.UtcNow;
this.OnBuildFinished(new BuildFinishedEventArgs(buildReport));
}
public void OnPreprocessBuild(BuildReport report)
public void OnPreprocessBuild(BuildReport report)
{
GetAllValidHDRPAssets();
}
public void OnPostprocessBuild(BuildReport report)
{
Profiler.enabled = false;
}
//BUILD
/// <summary>Builds an application using the passed in parameters.</summary>
/// <param name="targetPlatform">BuildTarget.StandaloneWindows64, StandaloneLinux64, StandaloneOSX</param>
/// <param name="buildType">NetworkType.Server - Client - HostAndPlay</param>
/// <param name="headless">Build in headless mode? (console application)</param>
public static void Build(BuildTarget targetPlatform, NetworkType buildType, bool headless = false)
{
ChangeBuildMenu.SetBuildType(buildType, headless); //ACTIVATE CHANGE BUILD MENU
FileExtension buildFileExtension = FileExtension.exe;
switch (targetPlatform)
{
//STANDALONE
case BuildTarget.StandaloneWindows64: buildFileExtension = FileExtension.exe; break;
case BuildTarget.StandaloneWindows: buildFileExtension = FileExtension.exe; break;
case BuildTarget.StandaloneLinux64: buildFileExtension = FileExtension.x86_64; break;
case BuildTarget.StandaloneOSX: buildFileExtension = FileExtension.app; break;
/*TODO*/
//MOBILE
//case BuildTarget.iOS: break;
//case BuildTarget.Android: break;
//CONSOLE
//case BuildTarget.PS4: break;
//case BuildTarget.XboxOne: break;
//case BuildTarget.Switch: break;
//WEB
//case BuildTarget.WebGL: buildFileExtension = FileExtension.exe; break;
/* //OTHER
* case BuildTarget.WSAPlayer: break;
* case BuildTarget.tvOS: break;
* case BuildTarget.Lumin: break;
* case BuildTarget.Stadia: break;
* case BuildTarget.NoTarget: break;
*/
}
//SETUP BUILD OPTIONS
BuildPlayerOptions buildPlayerOptions = new BuildPlayerOptions();
buildPlayerOptions.scenes = GetScenesFromBuild();
buildPlayerOptions.locationPathName = "_BUILD" + "/" + buildType.ToString().ToUpper() + "/" + targetPlatform + "/" + buildType.ToString().ToLower() + "." + buildFileExtension;
buildPlayerOptions.target = targetPlatform;
buildPlayerOptions.options = (headless) ? (BuildOptions.EnableHeadlessMode) : (BuildOptions.None);
#region BUILD REPORT - header
#if !SKIP_BUILD_REPORT
buildLog.AppendLine("<b>[BUILD] " + targetPlatform + " - " + ((headless) ? "(headless) " : "") + buildType + "</b>"
+ "\n" + buildPlayerOptions.locationPathName);
foreach (string scenePath in buildPlayerOptions.scenes)
{
buildLog.AppendLine(scenePath);
}
#endif
#endregion
//BUILD REPORTING
BuildReport report = BuildPipeline.BuildPlayer(buildPlayerOptions);
BuildSummary summary = report.summary;
//SUCCESS
if (summary.result == BuildResult.Succeeded)
{
#region BUILD REPORT - success
#if !SKIP_BUILD_REPORT
float sizeInMegabytes = (summary.totalSize / 1024f / 1024f);
sizeInMegabytes -= sizeInMegabytes % 0.0001f;
float durationInSeconds = (float)((summary.buildEndedAt - summary.buildStartedAt).TotalSeconds);
durationInSeconds -= durationInSeconds % 0.01f;
buildLog.AppendLine("<color=green><b>" + targetPlatform + " " + buildType + " build succeeded..." + "</b></color>"
+ ((summary.totalSize > 0) ? ("\nBuild size: " + sizeInMegabytes + " MB") : (""))
+ "\nBuild duration: " + durationInSeconds + "s");
#endif
#endregion
}
//FAILURE
if (summary.result == BuildResult.Failed)
{
#region BUILD REPORT - failure
#if !SKIP_BUILD_REPORT
buildLog.AppendLine("<color=red><b>" + targetPlatform + " " + buildType + " build failed...</b></color>"
+ "\n" + report.ToString());
#endif
#endregion
}
}
public void OnPreprocessBuild(BuildReport report)
{
BuildTargetChanged();
}
public void OnPostprocessBuild(BuildReport report)
{
this.OnPostprocessBuild(report.summary.platform, report.summary.outputPath);
}
public static void RunManagedProgram(string exe, string args, CompilerOutputParserBase parser, BuildReport report)
{
RunManagedProgram(exe, args, Application.dataPath + "/..", parser, report);
}
private void OnPostBuildPlayerScriptDLLsImpl(BuildReport report)
{
var aotSettingsForTarget = BurstPlatformAotSettings.GetOrCreateSettings(report.summary.platform);
// Early exit if burst is not activated or the platform is not supported
if (aotSettingsForTarget.DisableBurstCompilation || !IsSupportedPlatform(report.summary.platform))
{
return;
}
var commonOptions = new List <string>();
var stagingFolder = Path.GetFullPath(TempStagingManaged);
var playerAssemblies = GetPlayerAssemblies(report);
// grab the location of the root of the player folder - for handling nda platforms that require keys
var keyFolder = BuildPipeline.GetPlaybackEngineDirectory(report.summary.platform, BuildOptions.None);
commonOptions.Add(GetOption(OptionAotKeyFolder, keyFolder));
// Extract the TargetPlatform and Cpu from the current build settings
TargetCpu targetCpu;
var targetPlatform = GetTargetPlatformAndDefaultCpu(report.summary.platform, out targetCpu);
commonOptions.Add(GetOption(OptionPlatform, targetPlatform));
// --------------------------------------------------------------------------------------------------------
// 1) Calculate AssemblyFolders
// These are the folders to look for assembly resolution
// --------------------------------------------------------------------------------------------------------
var assemblyFolders = new List <string> {
stagingFolder
};
if (report.summary.platform == BuildTarget.WSAPlayer)
{
// On UWP, not all assemblies are copied to StagingArea, so we want to
// find all directories that we can reference assemblies from
// If we don't do this, we will crash with AssemblyResolutionException
// when following type references.
foreach (var assembly in playerAssemblies)
{
foreach (var assemblyRef in assembly.compiledAssemblyReferences)
{
// Exclude folders with assemblies already compiled in the `folder`
var assemblyName = Path.GetFileName(assemblyRef);
if (assemblyName != null && File.Exists(Path.Combine(stagingFolder, assemblyName)))
{
continue;
}
var directory = Path.GetDirectoryName(assemblyRef);
if (directory != null)
{
var fullPath = Path.GetFullPath(directory);
if (IsMonoReferenceAssemblyDirectory(fullPath) || IsDotNetStandardAssemblyDirectory(fullPath))
{
// Don't pass reference assemblies to burst because they contain methods without implementation
// If burst accidentally resolves them, it will emit calls to burst_abort.
fullPath = Path.Combine(EditorApplication.applicationContentsPath, "MonoBleedingEdge/lib/mono/unityaot");
fullPath = Path.GetFullPath(fullPath); // GetFullPath will normalize path separators to OS native format
if (!assemblyFolders.Contains(fullPath))
{
assemblyFolders.Add(fullPath);
}
fullPath = Path.Combine(fullPath, "Facades");
if (!assemblyFolders.Contains(fullPath))
{
assemblyFolders.Add(fullPath);
}
}
else if (!assemblyFolders.Contains(fullPath))
{
assemblyFolders.Add(fullPath);
}
}
}
}
}
// Copy assembly used during staging to have a trace
if (BurstLoader.IsDebugging)
{
try
{
var copyAssemblyFolder = Path.Combine(Environment.CurrentDirectory, "Logs", "StagingAssemblies");
try
{
if (Directory.Exists(copyAssemblyFolder))
{
Directory.Delete(copyAssemblyFolder);
}
}
catch
{
}
if (!Directory.Exists(copyAssemblyFolder))
{
Directory.CreateDirectory(copyAssemblyFolder);
}
foreach (var file in Directory.EnumerateFiles(stagingFolder))
{
File.Copy(file, Path.Combine(copyAssemblyFolder, Path.GetFileName(file)));
}
}
catch
{
}
}
// --------------------------------------------------------------------------------------------------------
// 2) Calculate root assemblies
// These are the assemblies that the compiler will look for methods to compile
// This list doesn't typically include .NET runtime assemblies but only assemblies compiled as part
// of the current Unity project
// --------------------------------------------------------------------------------------------------------
var rootAssemblies = new List <string>();
foreach (var playerAssembly in playerAssemblies)
{
// the file at path `playerAssembly.outputPath` is actually not on the disk
// while it is in the staging folder because OnPostBuildPlayerScriptDLLs is being called once the files are already
// transferred to the staging folder, so we are going to work from it but we are reusing the file names that we got earlier
var playerAssemblyPathToStaging = Path.Combine(stagingFolder, Path.GetFileName(playerAssembly.outputPath));
if (!File.Exists(playerAssemblyPathToStaging))
{
Debug.LogWarning($"Unable to find player assembly: {playerAssemblyPathToStaging}");
}
else
{
rootAssemblies.Add(playerAssemblyPathToStaging);
}
}
commonOptions.AddRange(assemblyFolders.Select(folder => GetOption(OptionAotAssemblyFolder, folder)));
// --------------------------------------------------------------------------------------------------------
// 3) Calculate the different target CPU combinations for the specified OS
//
// Typically, on some platforms like iOS we can be asked to compile a ARM32 and ARM64 CPU version
// --------------------------------------------------------------------------------------------------------
var combinations = CollectCombinations(targetPlatform, targetCpu, report);
// --------------------------------------------------------------------------------------------------------
// 4) Compile each combination
//
// Here bcl.exe is called for each target CPU combination
// --------------------------------------------------------------------------------------------------------
string debugLogFile = null;
if (BurstLoader.IsDebugging)
{
// Reset log files
try
{
var logDir = Path.Combine(Environment.CurrentDirectory, "Logs");
debugLogFile = Path.Combine(logDir, "burst_bcl_editor.log");
if (!Directory.Exists(logDir))
{
Directory.CreateDirectory(logDir);
}
File.WriteAllText(debugLogFile, string.Empty);
}
catch
{
debugLogFile = null;
}
}
// Log the targets generated by BurstReflection.FindExecuteMethods
foreach (var combination in combinations)
{
// Gets the output folder
var stagingOutputFolder = Path.GetFullPath(Path.Combine(TempStaging, combination.OutputPath));
var outputFilePrefix = Path.Combine(stagingOutputFolder, combination.LibraryName);
var options = new List <string>(commonOptions)
{
GetOption(OptionAotOutputPath, outputFilePrefix),
GetOption(OptionTarget, combination.TargetCpu)
};
if (targetPlatform == TargetPlatform.iOS)
{
options.Add(GetOption(OptionStaticLinkage));
}
// finally add method group options
options.AddRange(rootAssemblies.Select(path => GetOption(OptionRootAssembly, path)));
// Log the targets generated by BurstReflection.FindExecuteMethods
if (BurstLoader.IsDebugging && debugLogFile != null)
{
try
{
var writer = new StringWriter();
writer.WriteLine("-----------------------------------------------------------");
writer.WriteLine("Combination: " + combination);
writer.WriteLine("-----------------------------------------------------------");
foreach (var option in options)
{
writer.WriteLine(option);
}
writer.WriteLine("Assemblies in AssemblyFolders:");
foreach (var assemblyFolder in assemblyFolders)
{
writer.WriteLine("|- Folder: " + assemblyFolder);
foreach (var assemblyOrDll in Directory.EnumerateFiles(assemblyFolder, "*.dll"))
{
var fileInfo = new FileInfo(assemblyOrDll);
writer.WriteLine(" |- " + assemblyOrDll + " Size: " + fileInfo.Length + " Date: " + fileInfo.LastWriteTime);
}
}
File.AppendAllText(debugLogFile, writer.ToString());
}
catch
{
// ignored
}
}
// Write current options to the response file
var responseFile = Path.GetTempFileName();
File.WriteAllLines(responseFile, options);
if (BurstLoader.IsDebugging)
{
Debug.Log($"bcl @{responseFile}\n\nResponse File:\n" + string.Join("\n", options));
}
try
{
string generatedDebugInformationInOutput = "";
if ((report.summary.options & BuildOptions.Development) != 0)
{
// Workaround for clang >6 development issue (due to latest being 7.0.0) - IOS & newer PS4 SDKS are affected because its a source level IR compatability issue
if ((targetPlatform != TargetPlatform.iOS) && (targetPlatform != TargetPlatform.PS4))
{
generatedDebugInformationInOutput = GetOption(OptionDebug);
}
}
BclRunner.RunManagedProgram(Path.Combine(BurstLoader.RuntimePath, BurstAotCompilerExecutable),
$"{generatedDebugInformationInOutput} @{responseFile}",
new BclOutputErrorParser(),
report);
}
catch (BuildFailedException)
{
throw;
}
catch (Exception e)
{
throw new BuildFailedException(e);
}
}
}
/// <summary>
/// Collect CPU combinations for the specified TargetPlatform and TargetCPU
/// </summary>
/// <param name="targetPlatform">The target platform (e.g Windows)</param>
/// <param name="targetCpu">The target CPU (e.g X64_SSE4)</param>
/// <param name="report">Error reporting</param>
/// <returns>The list of CPU combinations</returns>
private static List <BurstOutputCombination> CollectCombinations(TargetPlatform targetPlatform, TargetCpu targetCpu, BuildReport report)
{
var combinations = new List <BurstOutputCombination>();
if (targetPlatform == TargetPlatform.macOS)
{
// NOTE: OSX has a special folder for the plugin
// Declared in GetStagingAreaPluginsFolder
// PlatformDependent\OSXPlayer\Extensions\Managed\OSXDesktopStandalonePostProcessor.cs
#if UNITY_2019_3_OR_NEWER
combinations.Add(new BurstOutputCombination(Path.Combine(Path.GetFileName(report.summary.outputPath), "Contents", "Plugins"), targetCpu));
#else
combinations.Add(new BurstOutputCombination("UnityPlayer.app/Contents/Plugins", targetCpu));
#endif
}
else if (targetPlatform == TargetPlatform.iOS)
{
if (Application.platform != RuntimePlatform.OSXEditor)
{
Debug.LogWarning("Burst Cross Compilation to iOS for standalone player, is only supported on OSX Editor at this time, burst is disabled for this build.");
}
else
{
var targetArchitecture = (IOSArchitecture)UnityEditor.PlayerSettings.GetArchitecture(report.summary.platformGroup);
if (targetArchitecture == IOSArchitecture.ARMv7 || targetArchitecture == IOSArchitecture.Universal)
{
// PlatformDependent\iPhonePlayer\Extensions\Common\BuildPostProcessor.cs
combinations.Add(new BurstOutputCombination("StaticLibraries", TargetCpu.ARMV7A_NEON32, DefaultLibraryName + "32"));
}
if (targetArchitecture == IOSArchitecture.ARM64 || targetArchitecture == IOSArchitecture.Universal)
{
// PlatformDependent\iPhonePlayer\Extensions\Common\BuildPostProcessor.cs
combinations.Add(new BurstOutputCombination("StaticLibraries", TargetCpu.ARMV8A_AARCH64, DefaultLibraryName + "64"));
}
}
}
else if (targetPlatform == TargetPlatform.Android)
{
//TODO: would be better to query AndroidNdkRoot (but thats not exposed from unity)
string ndkRoot = null;
// 2019.1 now has an embedded ndk
#if UNITY_2019_1_OR_NEWER
if (EditorPrefs.HasKey("NdkUseEmbedded"))
{
if (EditorPrefs.GetBool("NdkUseEmbedded"))
{
ndkRoot = Path.Combine(BuildPipeline.GetPlaybackEngineDirectory(BuildTarget.Android, BuildOptions.None), "NDK");
}
else
{
ndkRoot = EditorPrefs.GetString("AndroidNdkRootR16b");
}
}
#endif
// If we still don't have a valid root, try the old key
if (string.IsNullOrEmpty(ndkRoot))
{
ndkRoot = EditorPrefs.GetString("AndroidNdkRoot");
}
// Verify the directory at least exists, if not we fall back to ANDROID_NDK_ROOT current setting
if (!string.IsNullOrEmpty(ndkRoot) && !Directory.Exists(ndkRoot))
{
ndkRoot = null;
}
// Always set the ANDROID_NDK_ROOT (if we got a valid result from above), so BCL knows where to find the Android toolchain and its the one the user expects
if (!string.IsNullOrEmpty(ndkRoot))
{
Environment.SetEnvironmentVariable("ANDROID_NDK_ROOT", ndkRoot);
}
var androidTargetArch = UnityEditor.PlayerSettings.Android.targetArchitectures;
if ((androidTargetArch & AndroidArchitecture.ARMv7) != 0)
{
combinations.Add(new BurstOutputCombination("libs/armeabi-v7a", TargetCpu.ARMV7A_NEON32));
}
if ((androidTargetArch & AndroidArchitecture.ARM64) != 0)
{
combinations.Add(new BurstOutputCombination("libs/arm64-v8a", TargetCpu.ARMV8A_AARCH64));
}
#if !UNITY_2019_2_OR_NEWER
if ((androidTargetArch & AndroidArchitecture.X86) != 0)
{
combinations.Add(new BurstOutputCombination("libs/x86", TargetCpu.X86_SSE2));
}
#endif
}
else if (targetPlatform == TargetPlatform.UWP)
{
// TODO: Make it configurable for x86 (sse2, sse4)
combinations.Add(new BurstOutputCombination("Plugins/x64", TargetCpu.X64_SSE4));
combinations.Add(new BurstOutputCombination("Plugins/x86", TargetCpu.X86_SSE2));
combinations.Add(new BurstOutputCombination("Plugins/ARM", TargetCpu.THUMB2_NEON32));
combinations.Add(new BurstOutputCombination("Plugins/ARM64", TargetCpu.ARMV8A_AARCH64));
}
else if (targetPlatform == TargetPlatform.Lumin)
{
// Set the LUMINSDK_UNITY so bcl.exe will be able to find the SDK
if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("LUMINSDK_UNITY")))
{
var sdkRoot = EditorPrefs.GetString("LuminSDKRoot");
if (!string.IsNullOrEmpty(sdkRoot))
{
Environment.SetEnvironmentVariable("LUMINSDK_UNITY", sdkRoot);
}
}
combinations.Add(new BurstOutputCombination("Data/Plugins/", targetCpu));
}
else
{
combinations.Add(new BurstOutputCombination("Data/Plugins/", targetCpu));
}
return(combinations);
}
public void OnPreprocessBuild(BuildReport report)
{
EditorPrefs.DeleteKey("Models checked");
CheckModels();
}
public static void BuildUwpPlayer(BuildInfo buildInfo)
{
BuildTargetGroup buildTargetGroup = GetGroup(buildInfo.BuildTarget);
string oldBuildSymbols = PlayerSettings.GetScriptingDefineSymbolsForGroup(buildTargetGroup);
if (!string.IsNullOrEmpty(oldBuildSymbols))
{
if (buildInfo.HasConfigurationSymbol())
{
buildInfo.AppendSymbols(BuildInfo.RemoveConfigurationSymbols(oldBuildSymbols));
}
else
{
buildInfo.AppendSymbols(oldBuildSymbols.Split(';'));
}
}
if ((buildInfo.BuildOptions & BuildOptions.Development) == BuildOptions.Development)
{
if (!buildInfo.HasConfigurationSymbol())
{
buildInfo.AppendSymbols(BuildSymbolDebug);
}
}
if (buildInfo.HasAnySymbols(BuildSymbolDebug))
{
buildInfo.BuildOptions |= BuildOptions.Development | BuildOptions.AllowDebugging;
}
if (buildInfo.HasAnySymbols(BuildSymbolRelease))
{
// Unity automatically adds the DEBUG symbol if the BuildOptions.Development flag is
// specified. In order to have debug symbols and the RELEASE symbols we have to
// inject the symbol Unity relies on to enable the /debug+ flag of csc.exe which is "DEVELOPMENT_BUILD"
buildInfo.AppendSymbols("DEVELOPMENT_BUILD");
}
BuildTarget oldBuildTarget = EditorUserBuildSettings.activeBuildTarget;
BuildTargetGroup oldBuildTargetGroup = GetGroup(oldBuildTarget);
EditorUserBuildSettings.SwitchActiveBuildTarget(buildTargetGroup, buildInfo.BuildTarget);
WSAUWPBuildType?oldWSAUWPBuildType = EditorUserBuildSettings.wsaUWPBuildType;
if (buildInfo.WSAUWPBuildType.HasValue)
{
EditorUserBuildSettings.wsaUWPBuildType = buildInfo.WSAUWPBuildType.Value;
}
var oldWSAGenerateReferenceProjects = EditorUserBuildSettings.wsaGenerateReferenceProjects;
if (buildInfo.WSAGenerateReferenceProjects.HasValue)
{
EditorUserBuildSettings.wsaGenerateReferenceProjects = buildInfo.WSAGenerateReferenceProjects.Value;
}
var oldColorSpace = PlayerSettings.colorSpace;
if (buildInfo.ColorSpace.HasValue)
{
PlayerSettings.colorSpace = buildInfo.ColorSpace.Value;
}
if (buildInfo.BuildSymbols != null)
{
PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, buildInfo.BuildSymbols);
}
// For the WSA player, Unity builds into a target directory.
// For other players, the OutputPath parameter indicates the
// path to the target executable to build.
if (buildInfo.BuildTarget == BuildTarget.WSAPlayer)
{
Directory.CreateDirectory(buildInfo.OutputDirectory);
}
OnPreProcessBuild(buildInfo);
EditorUtility.DisplayProgressBar("Build Pipeline", "Gathering Build Data...", 0.25f);
BuildReport buildReport = default(BuildReport);
try
{
buildReport = BuildPipeline.BuildPlayer(
buildInfo.Scenes.ToArray(),
buildInfo.OutputDirectory,
buildInfo.BuildTarget,
buildInfo.BuildOptions);
if (buildReport.summary.result != BuildResult.Succeeded)
{
throw new Exception($"Build Result: {buildReport.summary.result.ToString()}");
}
}
finally
{
OnPostProcessBuild(buildInfo, buildReport);
if (buildInfo.BuildTarget == BuildTarget.WSAPlayer && EditorUserBuildSettings.wsaGenerateReferenceProjects)
{
UwpProjectPostProcess.Execute(buildInfo.OutputDirectory);
}
PlayerSettings.colorSpace = oldColorSpace;
PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, oldBuildSymbols);
EditorUserBuildSettings.wsaUWPBuildType = oldWSAUWPBuildType.Value;
EditorUserBuildSettings.wsaGenerateReferenceProjects = oldWSAGenerateReferenceProjects;
EditorUserBuildSettings.SwitchActiveBuildTarget(oldBuildTargetGroup, oldBuildTarget);
}
}
private static async void OnPostProcessBuild(BuildInfo buildInfo, BuildReport buildReport)
{
if (buildReport.summary.result == BuildResult.Succeeded)
public void Execute(BuildTargetGroup buildTargetGroup, BuildTarget buildTarget)
{
Config(buildTargetGroup, buildTarget);
if (configButDontBuild)
{
return;
}
if (bundleBuilder != null)
{
bundleBuilder.Execute(buildTarget);
}
BuildPlayerOptions options = new BuildPlayerOptions();
string[] scenePaths = new string[scenes.Length];
for (int i = 0; i < scenePaths.Length; i++)
{
scenePaths[i] = AssetDatabase.GetAssetPath(scenes[i]);
}
options.scenes = scenePaths;
if (string.IsNullOrEmpty(locationPathName))
{
locationPathName = EditorUtility.SaveFolderPanel("Choose Output Folder", "", "");
if (string.IsNullOrEmpty(locationPathName))
{
return;
}
}
string path = locationPathName
.Replace(Wildcard_BuildTarget, buildTarget.ToString())
.Replace(Wildcard_BuildNumber, buildNumber.ToString())
.Replace(Wildcard_BundleIdentifier, bundleIdentifier)
.Replace(Wildcard_BundleVersion, bundleVersion)
.Replace(Wildcard_CompanyName, companyName)
.Replace(Wildcard_Date, DateTime.Now.ToString("yyyyMMdd"))
.Replace(Wildcard_ProductName, productName)
.Replace(Wildcard_Time, DateTime.Now.ToString("HHmmss"));
switch (buildTarget)
{
case BuildTarget.StandaloneWindows:
options.locationPathName = string.Format("{0}/{1}.exe", path, PlayerSettings.productName);
break;
case BuildTarget.StandaloneWindows64:
options.locationPathName = string.Format("{0}/{1}.exe", path, PlayerSettings.productName);
break;
case BuildTarget.Android:
options.locationPathName = string.Format("{0}.apk", path);
break;
default:
options.locationPathName = path;
break;
}
options.target = buildTarget;
options.options = BuildOptions.ShowBuiltPlayer;
#if UNITY_2018_1_OR_NEWER
BuildReport report = BuildPipeline.BuildPlayer(options);
var summary = report.summary;
switch (summary.result)
{
case BuildResult.Failed:
Debug.LogError("Build Failed");
break;
case BuildResult.Succeeded:
Debug.Log("Build Succeeded");
copyList.CopyFiles(path);
break;
}
#else
Debug.Log(BuildPipeline.BuildPlayer(options));
copyList.CopyFiles(path);
#endif
}
void IPreprocessBuildWithReport.OnPreprocessBuild(BuildReport report)
{
ConfigureImportSettings();
}
private static void RunProgram(
Program p,
string exe,
string args,
string workingDirectory,
CompilerOutputParserBase parser,
BuildReport report)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
using (p)
{
p.GetProcessStartInfo().WorkingDirectory = workingDirectory;
p.Start();
p.WaitForExit();
stopwatch.Stop();
Console.WriteLine("{0} exited after {1} ms.", (object)exe, (object)stopwatch.ElapsedMilliseconds);
IEnumerable <UnityEditor.Scripting.Compilers.CompilerMessage> compilerMessages = null;
string[] errorOutput = p.GetErrorOutput();
string[] standardOutput = p.GetStandardOutput();
if (parser != null)
{
compilerMessages = parser.Parse(errorOutput, standardOutput, true, "n/a (burst)");
}
var errorMessageBuilder = new StringBuilder();
if (p.ExitCode != 0)
{
if (compilerMessages != null)
{
foreach (UnityEditor.Scripting.Compilers.CompilerMessage compilerMessage in compilerMessages)
{
Debug.LogPlayerBuildError(compilerMessage.message, compilerMessage.file, compilerMessage.line, compilerMessage.column);
}
}
// We try to output the version in the heading error if we can
var matchVersion = MatchVersion.Match(exe);
errorMessageBuilder.Append(matchVersion.Success ?
"Burst compiler (" + matchVersion.Groups[1].Value + ") failed running" :
"Burst compiler failed running");
errorMessageBuilder.AppendLine();
errorMessageBuilder.AppendLine();
// Don't output the path if we are not burst-debugging or the exe exist
if (BurstLoader.IsDebugging || !File.Exists(exe))
{
errorMessageBuilder.Append(exe).Append(" ").Append(args);
errorMessageBuilder.AppendLine();
errorMessageBuilder.AppendLine();
}
errorMessageBuilder.AppendLine("stdout:");
foreach (string str in standardOutput)
{
errorMessageBuilder.AppendLine(str);
}
errorMessageBuilder.AppendLine("stderr:");
foreach (string str in errorOutput)
{
errorMessageBuilder.AppendLine(str);
}
throw new BuildFailedException(errorMessageBuilder.ToString());
}
Console.WriteLine(p.GetAllOutput());
}
}
public void OnPreprocessBuild(BuildReport report)
{
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
byte[] bytes = AssetManifest.Export();
File.WriteAllBytes($"{report.summary.outputPath}/AssetManifest", bytes);
}
public void OnPreprocessBuild(BuildReport report)
{
string manifestPath = Path.Combine(
Application.dataPath, "Plugins/Android/AndroidManifest.xml");
XDocument manifest = null;
try
{
manifest = XDocument.Load(manifestPath);
}
#pragma warning disable 0168
catch (IOException e)
#pragma warning restore 0168
{
Debug.LogError("AndroidManifest.xml is missing. Try re-importing the plugin.");
}
XElement elemManifest = manifest.Element("manifest");
if (elemManifest == null)
{
Debug.LogError("AndroidManifest.xml is not valid. Try re-importing the plugin.");
}
XElement elemApplication = elemManifest.Element("application");
if (elemApplication == null)
{
Debug.LogError("AndroidManifest.xml is not valid. Try re-importing the plugin.");
}
IEnumerable <XElement> metas = elemApplication.Descendants()
.Where(elem => elem.Name.LocalName.Equals("meta-data"));
if (FrameworkGlobalConfig.Instance != null && FrameworkGlobalConfig.Instance.AdsConfig != null)
{
XElement elemAdMobEnabled = GetMetaElement(metas, META_APPLICATION_ID);
if (!string.IsNullOrEmpty(FrameworkGlobalConfig.Instance.AdsConfig.Platform.AppId))
{
string appId = FrameworkGlobalConfig.Instance.AdsConfig.Platform.AppId;
if (appId.Length == 0)
{
Debug.LogError(
"Android AdMob app ID is empty. Please enter a valid app ID to run ads properly.");
}
if (elemAdMobEnabled == null)
{
elemApplication.Add(CreateMetaElement(META_APPLICATION_ID, appId));
}
else
{
elemAdMobEnabled.SetAttributeValue(ns + "value", appId);
}
}
else
{
if (elemAdMobEnabled != null)
{
elemAdMobEnabled.Remove();
}
}
#if USE_ADMOB
XElement elemApplovinEnabled = GetMetaElement(metas, META_APPLOVIN_KEY);
if (!string.IsNullOrEmpty(FrameworkGlobalConfig.Instance.AdsConfig.Platform.ApplovingSDKKey))
{
string applovinSDKKey = FrameworkGlobalConfig.Instance.AdsConfig.Platform.ApplovingSDKKey;
if (applovinSDKKey.Length == 0)
{
Debug.LogError(
"Android Applovin SDK Key is empty. Please enter a valid SDK Key to run ads properly.");
}
if (elemApplovinEnabled == null)
{
elemApplication.Add(CreateMetaElement(META_APPLOVIN_KEY, applovinSDKKey));
}
else
{
elemApplovinEnabled.SetAttributeValue(ns + "value", applovinSDKKey);
}
}
else
{
if (elemApplovinEnabled != null)
{
elemApplovinEnabled.Remove();
}
}
#endif
}
elemManifest.Save(manifestPath);
}
public void OnPostprocessBuild(BuildReport report)
{
OnPostprocessBuildiOS(report);
}
static void BuildChannelApk(BuildConfig buildConfig)
{
// 公司名
PlayerSettings.companyName = buildConfig.companyName;
// 产品名
PlayerSettings.productName = buildConfig.productName;
// 包名
PlayerSettings.applicationIdentifier = buildConfig.bundleIdentifier;
PlayerSettings.bundleVersion = buildConfig.bundleVersion;
PlayerSettings.Android.bundleVersionCode = int.Parse(buildConfig.bundleVersionCode);
PlayerSettings.strippingLevel = StrippingLevel.StripByteCode;
PlayerSettings.SetApiCompatibilityLevel(BuildTargetGroup.Android, ApiCompatibilityLevel.NET_2_0_Subset);
// keystore 路径, G:\keystore\one.keystore
PlayerSettings.Android.keystoreName = buildConfig.keystorePath;
// one.keystore 密码
PlayerSettings.Android.keystorePass = buildConfig.keystorePass;
// one.keystore 别名
PlayerSettings.Android.keyaliasName = buildConfig.keyaliasName;
// 别名密码
PlayerSettings.Android.keyaliasPass = buildConfig.keyaliasPass;
BuildTargetGroup buildTargetGroup = BuildTargetGroup.Android;
// 设置宏定义
PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, "ASYNC_MODE"); // 宏定义
List <string> levels = new List <string>();
foreach (EditorBuildSettingsScene scene in EditorBuildSettings.scenes)
{
if (!scene.enabled)
{
continue;
}
// 获取有效的 Scene
levels.Add(scene.path);
}
// 切换到 Android 平台
EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.Android, BuildTarget.Android);
// 打包出 APK 名
string apkName = string.Format("APK/{0}.apk", buildConfig.apkName);
// 执行打包
BuildReport report = BuildPipeline.BuildPlayer(levels.ToArray(), apkName, BuildTarget.Android, BuildOptions.None);
BuildSummary summary = report.summary;
if (summary.result == BuildResult.Succeeded)
{
Debug.Log("Build succeeded" + apkName);
}
if (summary.result == BuildResult.Failed)
{
Debug.Log("构建失败");
}
AssetDatabase.Refresh();
}
public void OnPreprocessBuild(BuildReport report)
{
Preprocess(report.summary.platform);
}
public abstract void Execute(IUniBuilderConfiguration configuration, BuildReport buildReport = null);
public void OnPostprocessBuild(BuildReport report)
{
// Always remember to cleanup preloaded assets after build to make sure we don't
// dirty later builds with assets that may not be needed or are out of date.
CleanOldSettings();
}
private bool IsCurrentBuildTargetVaild(BuildReport report)
{
return(report.summary.platformGroup == BuildTargetGroup.WSA ||
(report.summary.platformGroup == BuildTargetGroup.Standalone && s_ValidBuildTargets.Contains(report.summary.platform)));
}
public static void Build()
{
if (UnityEditor.BuildPipeline.isBuildingPlayer)
{
return;
}
settings = BuildPipelineWebGLSettings.Instance;
string path;
if (string.IsNullOrEmpty(settings.buildPath))
{
path = OpenBuildSavePanel(settings.buildPath);
}
else
{
path = settings.buildPath;
}
var scenes = new List <EditorBuildSettingsScene>(EditorBuildSettings.scenes);
for (int i = 0; i < scenes.Count; i++)
{
if (!scenes[i].enabled)
{
scenes.RemoveAt(i--);
}
}
if (!(scenes.Count > 0))
{
return;
}
string buildPath;
if (settings.createNewFolder)
{
buildPath = Path.Combine(path, settings.GetFolderName());
}
else
{
buildPath = path;
}
PlayerSettings.WebGL.linkerTarget = settings.linkerTarget;
PlayerSettings.WebGL.memorySize = settings.memorySize;
PlayerSettings.WebGL.compressionFormat = settings.compressionFormat;
PlayerSettings.WebGL.wasmStreaming = settings.wasmStreaming;
BuildReport report = UnityEditor.BuildPipeline.BuildPlayer(scenes.ToArray(), buildPath, BuildTarget.WebGL, settings.buildOptions);
BuildSummary summary = report.summary;
if (summary.result == BuildResult.Succeeded)
{
Debug.Log($"Build succeeded at '{buildPath}' using {summary.totalTime.TotalSeconds.ToString("N2")} seconds with size of {summary.totalSize} bytes.");
#if UNITY_EDITOR_OSX
Application.OpenURL("file:/" + buildPath);
#else
Application.OpenURL(buildPath);
#endif
}
if (summary.result == BuildResult.Failed)
{
Debug.LogError($"Build failed...");
}
}
/// <summary>OnPreprocessBuild override to provide XR Plugin specific build actions.</summary>
/// <param name="report">The build report.</param>
public override void OnPreprocessBuild(BuildReport report)
{
if (IsCurrentBuildTargetVaild(report) && HasLoaderEnabledForTarget(report.summary.platformGroup))
{
base.OnPreprocessBuild(report);
BootConfig bootConfig = new BootConfig(report);
bootConfig.ReadBootConfg();
bootConfig.SetValueForKey(k_VrEnabled, "1", true);
bootConfig.SetValueForKey(k_WmrLibrary, k_WmrLibraryName, true);
if (report.summary.platformGroup == BuildTargetGroup.WSA)
{
bootConfig.SetValueForKey(k_EarlyBootHolographic, "1", true);
bool usePrimaryWindow = true;
WindowsMRBuildSettings buildSettings = BuildSettingsForBuildTargetGroup(report.summary.platformGroup);
if (buildSettings != null)
{
usePrimaryWindow = buildSettings.UsePrimaryWindowForDisplay;
}
bootConfig.SetValueForKey(k_ForcePrimaryWindowHolographic, usePrimaryWindow ? "1" : "0", true);
}
bootConfig.WriteBootConfig();
}
var allPlugins = PluginImporter.GetAllImporters();
foreach (var plugin in allPlugins)
{
if (plugin.isNativePlugin)
{
foreach (var pluginName in remotingPluginNames)
{
if (plugin.assetPath.Contains(pluginName))
{
plugin.SetIncludeInBuildDelegate((path) => { return(ShouldIncludeRemotingPluginsInBuild(path, report.summary.platformGroup)); });
break;
}
}
foreach (var pluginName in runtimePluginNames)
{
if (plugin.assetPath.Contains(pluginName))
{
plugin.SetIncludeInBuildDelegate((path) => { return(ShouldIncludeRuntimePluginsInBuild(path, report.summary.platformGroup)); });
break;
}
}
if (plugin.assetPath.Contains(spatializerPluginName))
{
plugin.SetIncludeInBuildDelegate(ShouldIncludeSpatializerPluginsInBuild);
}
}
}
}
public void OnProcessScene(SceneManagement.Scene scene, BuildReport report)
public BootConfig(BuildReport report)
{
buildReport = report;
}
/// <summary>
/// Starts the build process
/// </summary>
/// <param name="buildInfo"></param>
/// <returns>The <see cref="BuildReport"/> from Unity's <see cref="BuildPipeline"/></returns>
public static BuildReport BuildUnityPlayer(IBuildInfo buildInfo)
{
EditorUtility.DisplayProgressBar("Build Pipeline", "Gathering Build Data...", 0.25f);
// Call the pre-build action, if any
buildInfo.PreBuildAction?.Invoke(buildInfo);
var buildTargetGroup = buildInfo.BuildTarget.GetGroup();
var playerBuildSymbols = PlayerSettings.GetScriptingDefineSymbolsForGroup(buildTargetGroup);
if (!string.IsNullOrEmpty(playerBuildSymbols))
{
if (buildInfo.HasConfigurationSymbol())
{
buildInfo.AppendWithoutConfigurationSymbols(playerBuildSymbols);
}
else
{
buildInfo.AppendSymbols(playerBuildSymbols.Split(';'));
}
}
if (!string.IsNullOrEmpty(buildInfo.BuildSymbols))
{
PlayerSettings.SetScriptingDefineSymbolsForGroup(buildTargetGroup, buildInfo.BuildSymbols);
}
if ((buildInfo.BuildOptions & BuildOptions.Development) == BuildOptions.Development &&
!buildInfo.HasConfigurationSymbol())
{
buildInfo.AppendSymbols(BuildSymbolDebug);
}
if (buildInfo.HasAnySymbols(BuildSymbolDebug))
{
buildInfo.BuildOptions |= BuildOptions.Development | BuildOptions.AllowDebugging;
}
if (buildInfo.HasAnySymbols(BuildSymbolRelease))
{
// Unity automatically adds the DEBUG symbol if the BuildOptions.Development flag is
// specified. In order to have debug symbols and the RELEASE symbols we have to
// inject the symbol Unity relies on to enable the /debug+ flag of csc.exe which is "DEVELOPMENT_BUILD"
buildInfo.AppendSymbols("DEVELOPMENT_BUILD");
}
var oldColorSpace = PlayerSettings.colorSpace;
if (buildInfo.ColorSpace.HasValue)
{
PlayerSettings.colorSpace = buildInfo.ColorSpace.Value;
}
var oldBuildTarget = EditorUserBuildSettings.activeBuildTarget;
var oldBuildTargetGroup = oldBuildTarget.GetGroup();
if (EditorUserBuildSettings.activeBuildTarget != buildInfo.BuildTarget)
{
EditorUserBuildSettings.SwitchActiveBuildTarget(buildTargetGroup, buildInfo.BuildTarget);
}
buildInfo.OutputDirectory = $"{buildInfo.OutputDirectory}/{PlayerSettings.productName}";
switch (buildInfo.BuildTarget)
{
case BuildTarget.Lumin:
buildInfo.OutputDirectory += ".mpk";
break;
case BuildTarget.Android:
buildInfo.OutputDirectory += ".apk";
break;
case BuildTarget.StandaloneWindows:
case BuildTarget.StandaloneWindows64:
buildInfo.OutputDirectory += ".exe";
break;
}
BuildReport buildReport = default;
if (Application.isBatchMode)
{
foreach (var scene in buildInfo.Scenes)
{
Debug.Log($"BuildScene->{scene.path}");
}
}
try
{
buildReport = BuildPipeline.BuildPlayer(
buildInfo.Scenes.ToArray(),
buildInfo.OutputDirectory,
buildInfo.BuildTarget,
buildInfo.BuildOptions);
}
catch (Exception e)
{
Debug.LogError($"{e.Message}\n{e.StackTrace}");
}
PlayerSettings.colorSpace = oldColorSpace;
if (EditorUserBuildSettings.activeBuildTarget != oldBuildTarget)
{
EditorUserBuildSettings.SwitchActiveBuildTarget(oldBuildTargetGroup, oldBuildTarget);
}
// Call the post-build action, if any
buildInfo.PostBuildAction?.Invoke(buildInfo, buildReport);
return(buildReport);
}
/// <summary>
/// A callback received before the build is started.</para>
/// </summary>
/// <param name="report">
/// A report containing information about the build,
/// such as its target platform and output path.
/// </param>
public void OnPreprocessBuild(BuildReport report)
{
EditorBuildSettingsScene enabledBuildScene = null;
int enabledSceneCount = 0;
foreach (var buildScene in EditorBuildSettings.scenes)
{
if (!buildScene.enabled)
{
continue;
}
enabledBuildScene = buildScene;
enabledSceneCount++;
}
if (enabledSceneCount != 1 || enabledBuildScene.guid.ToString() != _sceneGuid)
{
return;
}
// update application icon.
if (report.summary.platform == BuildTarget.Android)
{
Texture2D background = AssetDatabase.LoadAssetAtPath <Texture2D>(
AssetDatabase.GUIDToAssetPath(_iconBackgroundGuid));
Texture2D foreground = AssetDatabase.LoadAssetAtPath <Texture2D>(
AssetDatabase.GUIDToAssetPath(_iconForegroundGuid));
PlatformIcon[] platformIcons =
PlayerSettings.GetPlatformIcons(BuildTargetGroup.Android,
UnityEditor.Android.AndroidPlatformIconKind.Adaptive);
foreach (var platformIcon in platformIcons)
{
if (platformIcon.GetTexture() != null &&
platformIcon.GetTexture() != background &&
platformIcon.GetTexture() != foreground)
{
// Keep the custom icons.
return;
}
else
{
platformIcon.SetTexture(background, 0);
platformIcon.SetTexture(foreground, 1);
}
}
PlayerSettings.SetPlatformIcons(BuildTargetGroup.Android,
UnityEditor.Android.AndroidPlatformIconKind.Adaptive, platformIcons);
}
else if (report.summary.platform == BuildTarget.iOS)
{
Texture2D icon = AssetDatabase.LoadAssetAtPath <Texture2D>(
AssetDatabase.GUIDToAssetPath(_iconGuid));
PlatformIcon[] platformIcons =
PlayerSettings.GetPlatformIcons(BuildTargetGroup.iOS,
UnityEditor.iOS.iOSPlatformIconKind.Application);
foreach (var platformIcon in platformIcons)
{
if (platformIcon.GetTexture() != null &&
platformIcon.GetTexture() != icon)
{
// Keep the custom icons.
return;
}
else
{
platformIcon.SetTexture(icon);
}
}
PlayerSettings.SetPlatformIcons(BuildTargetGroup.iOS,
UnityEditor.iOS.iOSPlatformIconKind.Application, platformIcons);
}
}
public BuildFinishedEventArgs(BuildReport buildReport)
{
BuildReport = buildReport;
}
/// <summary>
/// [EDITOR_ONLY] Called by Unity Editor on postprocess build.
/// </summary>
/// <param name="report"></param>
public void OnPostprocessBuild(BuildReport report)
{
Debug.Log("VersionAndControlForBuild::OnPostprocessBuild");
/*
* Due to the fact that all the loaded object instances are destroyed before building a project, on postprocess build, it has to load an asset from a 'known(hard-coded)' asset path. This is the reason why the asset name and path should not be changed.
*/
VersionControlForBuild target = AssetDatabase.LoadAssetAtPath <VersionControlForBuild>(ASSET_PATH);
if (target == null)
{
Debug.LogWarning("[VersionControlForBuild] Version control asset for build was not found! Incrementing build number is disabled. Have you moved the Assets/_VersionControlForBuild.asset file?");
}
else
{
target.IncrementBuildNumber();
string outputPath = report.summary.outputPath;
// Debug.Log("outputPath : " + outputPath);
// pathToBuiltProject : path/to/built/project/BuiltFileName.extension (standalone)
//TODO check path for iOS
string pathToBuiltProjectFolder = outputPath.Substring(0, outputPath.LastIndexOf('/'));
// Release Note
if (target._releaseNote != null)
{
// Debug.Log("Build complete. builtProject folder : " + pathToBuiltProjectFolder);
// Application.dataPath : ~/Assets
// AssetDatabase.GetAssetPath(object) : Assets/path/to/file/FileName.extension
string releaseNoteFullPath = Application.dataPath.Substring(0, Application.dataPath.LastIndexOf('/')) + "/" + AssetDatabase.GetAssetPath(target._releaseNote);
string releaseNoteExtension = Path.GetExtension(releaseNoteFullPath);
string releaseNoteDestination = pathToBuiltProjectFolder + "/" + target._releaseNote.name + (target._additionalTagPosition == AdditionalTagPosition.NEXT_TO_PRODUCTNAME ? target._additionalTag : "")
+ "_v" + target.CurrentVersion + (target._additionalTagPosition == AdditionalTagPosition.NEXT_TO_BUILDNUMBER ? target._additionalTag : "")
+ "_" + target.GetCurrentDateYYMMDD() + releaseNoteExtension;
FileAttributes attr = File.GetAttributes(releaseNoteFullPath);
if ((attr & FileAttributes.Directory) == FileAttributes.Directory)
{
// Debug.Log("Directory!");
// Directory. check if the directory exists
if (Directory.Exists(releaseNoteDestination))
{
Debug.Log("Replacing Release Note Directory.");
FileUtil.ReplaceDirectory(releaseNoteFullPath, releaseNoteDestination);
}
else
{
Debug.Log("Copying Release Note directory.");
FileUtil.CopyFileOrDirectory(releaseNoteFullPath, releaseNoteDestination);
}
}
else
{
// Debug.Log("File!");
// File. Check if the file exists
if (File.Exists(releaseNoteDestination))
{
Debug.Log("Replacing Release Note file.");
FileUtil.ReplaceFile(releaseNoteFullPath, releaseNoteDestination);
}
else
{
Debug.Log("Copying Release Note file.");
FileUtil.CopyFileOrDirectory(releaseNoteFullPath, releaseNoteDestination);
}
}
}
// Additional objects to be copied to output folder.
for (int i = 0; i < target._additionalObjectsToBeCopied.Length; i++)
{
if (target._additionalObjectsToBeCopied[i] != null)
{
string objFullPath = Application.dataPath.Substring(0, Application.dataPath.LastIndexOf('/'))
+ "/" + AssetDatabase.GetAssetPath(target._additionalObjectsToBeCopied[i]);
string objExtension = Path.GetExtension(objFullPath);
string objDestination = pathToBuiltProjectFolder + "/" + target._additionalObjectsToBeCopied[i].name + objExtension;
FileAttributes attr = File.GetAttributes(objFullPath);
if ((attr & FileAttributes.Directory) == FileAttributes.Directory)
{
// Directory
if (Directory.Exists(objDestination))
{
Debug.Log("Replacing " + objFullPath + " to " + objDestination);
FileUtil.ReplaceDirectory(objFullPath, objDestination);
}
else
{
Debug.Log("Copying " + objFullPath + " to " + objDestination);
FileUtil.CopyFileOrDirectory(objFullPath, objDestination);
}
}
else
{
// File
if (File.Exists(objDestination))
{
Debug.Log("Replacing " + objFullPath + " to " + objDestination);
FileUtil.ReplaceFile(objFullPath, objDestination);
}
else
{
Debug.Log("Copying " + objFullPath + " to " + objDestination);
FileUtil.CopyFileOrDirectory(objFullPath, objDestination);
}
}
}
}
// Export to Zip
if (_exportToZip)
{
//NOT IMPLEMENTED YET
}
}
}
