bool CheckAssetDirty(BuildDataInputFile file) { NPath path = file.path; if (!path.Exists()) { Console.WriteLine($"Rebuilding Data files because {path} is dirty (deleted)"); return(true); } string contentHash = ""; if (path.Extension == "cs") { var monoScript = AssetDatabase.LoadAssetAtPath <MonoScript>(path.ToString()); if (monoScript != null) { contentHash = monoScript.GetPropertiesHashString(buildOptions.HasFlag(BuildOptions.Development)); } } else { contentHash = AssetDatabase.GetAssetDependencyHash(file.path).ToString(); } if (contentHash != file.contentHash) { Console.WriteLine($"Rebuilding Data files because {path} is dirty (hash)"); return(true); } return(false); }
/// <summary> /// The Start implementation. /// </summary> protected override RunningProgram StartImpl(string workingDirectory, string[] arguments, Dictionary <string, string> envVars) { var executable = new NPath(Executable).MakeAbsolute(); if (!executable.Exists()) { executable = Executable; // fallback to system path } var psi = new ProcessStartInfo() { UseShellExecute = false, FileName = executable.ToString(SlashMode.Native), Arguments = AlwaysArguments.Concat(arguments).SeparateWithSpace(), CreateNoWindow = true, RedirectStandardError = !StdOutMode.HasFlag(StdOutMode.Stream), RedirectStandardOutput = !StdOutMode.HasFlag(StdOutMode.Stream), RedirectStandardInput = true, WorkingDirectory = workingDirectory, }; foreach (var kvp in AlwaysEnvironmentVariables) { psi.EnvironmentVariables[kvp.Key] = kvp.Value; } if (envVars != null) { foreach (var kvp in envVars) { psi.EnvironmentVariables[kvp.Key] = kvp.Value; } } return(new SystemProcessRunningProgram(StdOutMode, psi)); }
private static List <FileInfo> CollectGeneratedFileInfo(NPath outputDirectory) { if (!outputDirectory.Exists("")) { return(new List <FileInfo>()); } if (< > f__mg$cache0 == null) {
public static TempFile CreateRandom() { string[] append = new string[] { System.IO.Path.GetRandomFileName() }; NPath path = TempDir.Il2CppTemporaryDirectoryRoot.Combine(append); while (path.Exists("")) { string[] textArray2 = new string[] { System.IO.Path.GetRandomFileName() }; path = TempDir.Il2CppTemporaryDirectoryRoot.Combine(textArray2); } return(new TempFile(path)); }
private static void RecreateDagDirectoryIfNeeded(NPath dagDirectory) { var beeBackendInfoPath = dagDirectory.Combine("bee_backend.info"); var currentInfo = new BeeBackendInfo() { BeeBackendHash = BeeBackendHash, UnityVersion = Application.unityVersion }; var diskInfo = new BeeBackendInfo(); // Clear dag directory if it was produced with a different bee_backend, to avoid problem where bee_backend sometimes looses track of files. if (dagDirectory.Exists()) { if (beeBackendInfoPath.Exists()) { var contents = beeBackendInfoPath.ReadAllText(); EditorJsonUtility.FromJsonOverwrite(contents, diskInfo); // Note: We're clearing dag directory only when bee backend hash has changed, it's fine for Unity version to be different. // Unity version is used here for informational purposes, so we can clearly see from which Unity version the user was upgrading if (string.IsNullOrEmpty(diskInfo.BeeBackendHash) || !diskInfo.BeeBackendHash.Equals(currentInfo.BeeBackendHash)) { Console.WriteLine($"Clearing Bee directory '{dagDirectory}', since bee backend hash ('{beeBackendInfoPath}') is different, previous hash was {diskInfo.BeeBackendHash} (Unity version: {diskInfo.UnityVersion}), current hash is {currentInfo.BeeBackendHash} (Unity version: {currentInfo.UnityVersion})."); dagDirectory.Delete(); } } else { Console.WriteLine($"Clearing Bee directory '{dagDirectory}', since bee backend information ('{beeBackendInfoPath}') is missing."); dagDirectory.Delete(); } } dagDirectory.CreateDirectory(); // Update info, if at least of one the fields is different if (string.IsNullOrEmpty(diskInfo.BeeBackendHash) || string.IsNullOrEmpty(diskInfo.UnityVersion) || !diskInfo.BeeBackendHash.Equals(currentInfo.BeeBackendHash) || !diskInfo.UnityVersion.Equals(currentInfo.UnityVersion)) { beeBackendInfoPath.WriteAllText(EditorJsonUtility.ToJson(currentInfo, true)); } }
public static bool ForgivingCleanDirectory(NPath directory) { try { if (directory.Exists("")) { directory.Delete(DeleteMode.Normal); } return(true); } catch (Exception) { if (!directory.Files(true).Any <NPath>()) { return(true); } } return(false); }
public override Shell.ExecuteResult RunAndMakeExecuteResult(string executable) { bool flag; Shell.ExecuteResult result; string[] append = new string[] { "AppxManifest.xml" }; NPath path = new NPath(Path.GetDirectoryName(executable)).Combine(append); if (!File.Exists(executable)) { throw new ArgumentException($"Specified executable (" { executable } ") does not exist!"); } if (!path.Exists("")) { throw new ArgumentException($"AppX manifest was not found next to the executable at " { path } "!"); } WinRTManifest.AddActivatableClasses(path); using (Mutex mutex = new Mutex(true, @"Global\WinRTRunnerBuild", out flag)) { if (!flag) { mutex.WaitOne(); } try { MakeSureRunnerIsBuilt(); Shell.ExecuteArgs executeArgs = new Shell.ExecuteArgs { Executable = WinRTRunnerExecutablePath.ToString(), Arguments = path.InQuotes(), WorkingDirectory = WinRTRunnerExecutablePath.Parent.ToString() }; using (TinyProfiler.Section("Run WinRT Application", "")) { result = Shell.Execute(executeArgs, null); } } finally { mutex.ReleaseMutex(); } } return(result); }
public AndroidNDKUtilities(NPath ndkRootPath, Unity.IL2CPP.Building.Architecture architecture) { if (!ndkRootPath.Exists("")) { throw new ArgumentException("Android NDK path does not exist: " + ndkRootPath); } this.AndroidNdkRootDir = ndkRootPath; if (architecture is ARMv7Architecture) { this._architectureSettings = new ARMv7Settings(); } else { if (!(architecture is x86Architecture)) { throw new NotSupportedException("Unknown architecture: " + architecture); } this._architectureSettings = new X86Settings(); } }
internal static void InstallStreamingAssets(string stagingAreaDataPath, string streamingAssetsFolderName, BuildReport report) { if (Directory.Exists(StreamingAssets)) { var outputPath = Path.Combine(stagingAreaDataPath, streamingAssetsFolderName); FileUtil.CopyDirectoryRecursiveForPostprocess(StreamingAssets, outputPath, true); report?.RecordFilesAddedRecursive(outputPath, CommonRoles.streamingAsset); } foreach (var(dst, src) in BuildPlayerContext.ActiveInstance.StreamingAssets) { NPath targetPlayerPath = $"{stagingAreaDataPath}/{streamingAssetsFolderName}/{dst}"; if (targetPlayerPath.Exists()) { var errorMessage = "error: Callback provided streaming assets file conflicts with file already present in project." + $" Project file 'StreamingAssets/{dst}'. Callback provided file '{src}'."; Debug.LogError(errorMessage); throw new BuildFailedException(errorMessage); } FileUtil.UnityFileCopy(src.ToString(), targetPlayerPath.EnsureParentDirectoryExists().ToString()); report?.RecordFileAdded(targetPlayerPath.ToString(SlashMode.Native), CommonRoles.streamingAsset); } }
private static JObject ParseBuildSettingsFile() { var buildSettingsFile = new NPath("buildsettings.json"); return(buildSettingsFile.Exists() ? JObject.Parse(buildSettingsFile.MakeAbsolute().ReadAllText()) : null); }
public static Dictionary <string, List <DotsRuntimeCSharpProgramConfiguration> > MakeConfigs() { var platformList = DotsBuildSystemTargets; var settingsDir = new NPath("settings"); if (settingsDir.Exists()) { foreach (var settingsRelative in settingsDir.Files("*.json")) { var settingsFile = settingsRelative.MakeAbsolute(); if (settingsFile.Exists()) { Backend.Current.RegisterFileInfluencingGraph(settingsFile); var settingsObject = new FriendlyJObject { Content = JObject.Parse(settingsFile.ReadAllText()) }; if (settingsObject.GetInt("Version", 0) != AsmDefConfigFile.BuildSettingsFileVersion || AsmDefConfigFile.AsmDefDescriptionFor(settingsObject.GetString("RootAssembly")) == null) { Console.WriteLine($"Found old settings file '{settingsFile}', removing..."); settingsFile.Delete(); continue; } var id = settingsObject.GetString("PlatformTargetIdentifier"); var target = platformList.Single(t => t.Identifier == id); if (!target.ToolChain.CanBuild) { continue; } // Need to know this prior to determining need for burst var mdb = ShouldEnableDevelopmentOptionForSetting("EnableManagedDebugging", new[] { DotsConfiguration.Debug, DotsConfiguration.Develop }, settingsObject); if (!target.ValidateManagedDebugging(ref mdb)) { continue; } if (mdb && DotsConfigForSettings(settingsObject, out var codeGen) == DotsConfiguration.Debug && target.ScriptingBackend == ScriptingBackend.TinyIl2cpp) { Errors.PrintWarning("Debug builds with managed debugging are very slow. It's recommended to use the Develop configuration instead."); } var multithreading = settingsObject.GetBool("EnableMultithreading"); var targetUsesBurst = settingsObject.GetBool("EnableBurst"); if (!targetUsesBurst && multithreading) { // We currently do not support multithreaded debugging anywhere except .NET Framework and CoreCLR (so, Windows only) // or il2cpp full profile bool isFullIl2cpp = target.ScriptingBackend == ScriptingBackend.TinyIl2cpp && mdb; bool isWindows = target.ToolChain.Platform is WindowsPlatform; if (!(isFullIl2cpp || isWindows)) { Errors.PrintWarning($"BuildConfiguration '{settingsFile.FileNameWithoutExtension}' " + $"specified 'EnableBurst=False', but 'Multithreading=True'. Multithreading requires Burst, therefore enabling Burst."); targetUsesBurst = true; } } var dotsCfg = DotsConfigForSettings(settingsObject, out var codegen); var enableProfiler = ShouldEnableDevelopmentOptionForSetting("EnableProfiler", new [] { DotsConfiguration.Develop }, settingsObject); var enableUnityCollectionsChecks = ShouldEnableDevelopmentOptionForSetting("EnableSafetyChecks", new[] { DotsConfiguration.Debug, DotsConfiguration.Develop }, settingsObject); if (!target.CanUseBurst && targetUsesBurst) { Console.WriteLine($"Warning: BuildConfiguration '{settingsFile.FileNameWithoutExtension}' " + $"specified 'EnableBurst', but target ({target.Identifier}) does not support burst yet. Not using burst."); targetUsesBurst = false; } // Workaround to disable burst in web debug builds since it will fail to compile // https://unity3d.atlassian.net/browse/DOTSR-1886 if (targetUsesBurst && target is DotsWebTarget && codegen == CSharpCodeGen.Debug) { Console.WriteLine($"Warning: Web currently does not support building in debug configuration with Burst. Disabling burst...."); targetUsesBurst = false; } var waitForManagedDebugger = settingsObject.GetBool("WaitForManagedDebugger"); var rootAssembly = settingsObject.GetString("RootAssembly"); string finalOutputDir = null; if (settingsObject.Content.TryGetValue("FinalOutputDirectory", out var finalOutputToken)) { finalOutputDir = finalOutputToken.Value <string>(); } var defines = new List <string>(); if (settingsObject.Content.TryGetValue("ScriptingDefines", out var definesJToken)) { defines = ((JArray)definesJToken).Select(token => token.Value <string>()).ToList(); } if (!PerConfigBuildSettings.ContainsKey(rootAssembly)) { PerConfigBuildSettings[rootAssembly] = new List <DotsRuntimeCSharpProgramConfiguration>(); } var identifier = settingsFile.FileNameWithoutExtension; do { PerConfigBuildSettings[rootAssembly] .Add( target.CustomizeConfigForSettings(new DotsRuntimeCSharpProgramConfiguration( csharpCodegen: codegen, cppCodegen: codegen == CSharpCodeGen.Debug ? CodeGen.Debug : CodeGen.Release, nativeToolchain: target.ToolChain, scriptingBackend: target.ScriptingBackend, targetFramework: target.TargetFramework, identifier: identifier, enableUnityCollectionsChecks: enableUnityCollectionsChecks, enableManagedDebugging: mdb, waitForManagedDebugger: waitForManagedDebugger, multiThreadedJobs: multithreading, dotsConfiguration: dotsCfg, enableProfiler: enableProfiler, useBurst: targetUsesBurst, defines: defines, finalOutputDirectory: finalOutputDir), settingsObject)); //We have to introduce the concept of "complementary targets" to accommodate building "fat" binaries on Android, //for both armv7 and arm64 architectures. This means we have to build two copies of the final binaries, and then do one //packaging step to package both steps into a single apk. But also, since C# code is allowed to do #if UNITY_DOTSRUNTIME64 //(and indeed we need that ability for the static type registry to generate correct sizes of things), we need to compile //two sets of c# assemblies, one per architecture, and run il2cpp and burst on each one separately, in order to produce //these two sets of final binaries. //For that purpose, we associate a second DotsRuntimeCSharpProgramConfiguration (known as the complementary target) to //specify the build for the other architecture we wish to compile against, and we do all the building steps up to the final //packaging step for that config as well as the main one. We skip the final packaging step for the complementary config, //and make the packaging step for the main config consume both sets of binaries. //This is a crazy scheme, and we theorize and hope that when we adopt the incremental buildpipeline, we will be able //to use their concept of per-platform custom graph build steps to make this be more reasonable. target = target.ComplementaryTarget; //We use "identifier" as a directory name for all intermediate files. //For complementary target these files will be generated in "target.Identifier" subdirectory. //So for example in case of arm64 complemenary target a path would be //"{target.Identifiler}/android_complementary_arm64". if (target != null) { identifier += "/" + target.Identifier; } } while (target != null); } } } return(PerConfigBuildSettings); }
public static Dictionary <string, List <DotsRuntimeCSharpProgramConfiguration> > MakeConfigs() { var platformList = DotsBuildSystemTargets; var settingsDir = new NPath("settings"); if (settingsDir.Exists()) { foreach (var settingsRelative in settingsDir.Files("*.json")) { var settingsFile = settingsRelative.MakeAbsolute(); if (settingsFile.Exists()) { Backend.Current.RegisterFileInfluencingGraph(settingsFile); var settingsObject = new FriendlyJObject { Content = JObject.Parse(settingsFile.ReadAllText()) }; var id = settingsObject.GetString("PlatformTargetIdentifier"); var target = platformList.Single(t => t.Identifier == id); if (!target.ToolChain.CanBuild) { continue; } var targetShouldUseBurst = settingsObject.GetBool("UseBurst"); var dotsCfg = DotsConfigForSettings(settingsObject, out var codegen); var enableUnityCollectionsChecks = dotsCfg != DotsConfiguration.Release; if (!target.CanUseBurst && targetShouldUseBurst) { Console.WriteLine($"Warning: BuildConfiguration '{settingsFile.FileNameWithoutExtension}' " + $"specified 'UseBurst', but target ({target.Identifier}) does not support burst yet. Not using burst."); targetShouldUseBurst = false; } var mdb = ManagedDebuggingForSettings(settingsObject); if (target.Identifier == "asmjs" || target.Identifier == "wasm") { mdb = false; } var waitForManagedDebugger = settingsObject.GetBool("WaitForManagedDebugger"); var rootAssembly = settingsObject.GetString("RootAssembly"); string finalOutputDir = null; if (settingsObject.Content.TryGetValue("FinalOutputDirectory", out var finalOutputToken)) { finalOutputDir = finalOutputToken.Value <string>(); } var multithreading = settingsObject.GetBool("EnableMultiThreading"); var defines = new List <string>(); if (settingsObject.Content.TryGetValue("ScriptingDefines", out var definesJToken)) { defines = ((JArray)definesJToken).Select(token => token.Value <string>()).ToList(); } if (!PerConfigBuildSettings.ContainsKey(rootAssembly)) { PerConfigBuildSettings[rootAssembly] = new List <DotsRuntimeCSharpProgramConfiguration>(); } PerConfigBuildSettings[rootAssembly] .Add( new DotsRuntimeCSharpProgramConfiguration( csharpCodegen: codegen, cppCodegen: codegen == CSharpCodeGen.Debug ? CodeGen.Debug : CodeGen.Release, nativeToolchain: target.ToolChain, scriptingBackend: target.ScriptingBackend, targetFramework: target.TargetFramework, identifier: settingsFile.FileNameWithoutExtension, enableUnityCollectionsChecks: enableUnityCollectionsChecks, enableManagedDebugging: mdb, waitForManagedDebugger: waitForManagedDebugger, multiThreadedJobs: multithreading, dotsConfiguration: dotsCfg, useBurst: targetShouldUseBurst, executableFormat: target.CustomizeExecutableForSettings(settingsObject), defines: defines, finalOutputDirectory: finalOutputDir)); } } } return(PerConfigBuildSettings); }
public static Dictionary <string, List <DotsRuntimeCSharpProgramConfiguration> > MakeConfigs() { var platformList = DotsBuildSystemTargets; var settingsDir = new NPath("settings"); if (settingsDir.Exists()) { foreach (var settingsRelative in settingsDir.Files("*.json")) { var settingsFile = settingsRelative.MakeAbsolute(); if (settingsFile.Exists()) { Backend.Current.RegisterFileInfluencingGraph(settingsFile); var settingsObject = new FriendlyJObject { Content = JObject.Parse(settingsFile.ReadAllText()) }; var id = settingsObject.GetString("PlatformTargetIdentifier"); var target = platformList.Single(t => t.Identifier == id); if (!target.ToolChain.CanBuild) { continue; } var targetShouldUseBurst = settingsObject.GetBool("UseBurst"); var dotsCfg = DotsConfigForSettings(settingsObject, out var codegen); var enableUnityCollectionsChecks = dotsCfg != DotsConfiguration.Release; /* dotnet reorders struct layout when there are managed components in the job struct, * most notably DisposeSentinel. Mono does not. So disable burst on windows dotnet when * collections checks are enabled. */ var canUseBurst = target.CanUseBurst && !(target is DotsWindowsDotNetTarget && target.ScriptingBackend == ScriptingBackend.Dotnet && enableUnityCollectionsChecks); if (!canUseBurst && targetShouldUseBurst) { Console.WriteLine( "Warning: UseBurst specified, but target does not support burst yet. Not using burst."); targetShouldUseBurst = false; } var mdb = settingsObject.GetBool("EnableManagedDebugging"); var rootAssembly = settingsObject.GetString("RootAssembly"); string finalOutputDir = null; if (settingsObject.Content.TryGetValue("FinalOutputDirectory", out var finalOutputToken)) { finalOutputDir = finalOutputToken.Value <string>(); } var multithreading = settingsObject.GetBool("EnableMultiThreading"); var defines = new List <string>(); if (settingsObject.Content.TryGetValue("ScriptingDefines", out var definesJToken)) { defines = ((JArray)definesJToken).Select(token => token.Value <string>()).ToList(); } if (!PerConfigBuildSettings.ContainsKey(rootAssembly)) { PerConfigBuildSettings[rootAssembly] = new List <DotsRuntimeCSharpProgramConfiguration>(); } PerConfigBuildSettings[rootAssembly] .Add( new DotsRuntimeCSharpProgramConfiguration(codegen, codegen == CSharpCodeGen.Debug ? CodeGen.Debug : CodeGen.Release, target.ToolChain, target.ScriptingBackend, settingsFile.FileNameWithoutExtension, enableUnityCollectionsChecks, mdb, multithreading, dotsCfg, targetShouldUseBurst, target.CustomizeExecutableForSettings(settingsObject), defines, finalOutputDir)); } } } return(PerConfigBuildSettings); }