public static NativeProgram CreateBoehmGcProgram(NPath boehmGcRoot) { var program = new NativeProgram("boehm-gc"); program.Sources.Add($"{boehmGcRoot}/extra/gc.c"); program.PublicIncludeDirectories.Add($"{boehmGcRoot}/include"); program.IncludeDirectories.Add($"{boehmGcRoot}/libatomic_ops/src"); program.Defines.Add( "ALL_INTERIOR_POINTERS=1", "GC_GCJ_SUPPORT=1", "JAVA_FINALIZATION=1", "NO_EXECUTE_PERMISSION=1", "GC_NO_THREADS_DISCOVERY=1", "IGNORE_DYNAMIC_LOADING=1", "GC_DONT_REGISTER_MAIN_STATIC_DATA=1", "NO_DEBUGGING=1", "GC_VERSION_MAJOR=7", "GC_VERSION_MINOR=7", "GC_VERSION_MICRO=0", "HAVE_BDWGC_GC", "HAVE_BOEHM_GC", "DEFAULT_GC_NAME=\"BDWGC\"", "NO_CRT=1", "DONT_USE_ATEXIT=1", "NO_GETENV=1"); program.Defines.Add(c => !(c.Platform is WebGLPlatform), "GC_THREADS=1", "USE_MMAP=1", "USE_MUNMAP=1"); program.Defines.Add(c => c.ToolChain is VisualStudioToolchain, "NOMINMAX", "WIN32_THREADS"); //program.CompilerSettingsForMsvc().Add(l => l.WithCompilerRuntimeLibrary(CompilerRuntimeLibrary.None)); return(program); }
static void Main() { List <BuildCommand> commands = HostPlatform.IsOSX ? MacCommands() : WindowsCommands(); commands.AddRange(GetAndroidBuildCommands()); NativeProgram plugin = new NativeProgram("traceeventprofiler") { Sources = { "src" } }; plugin.CompilerSettingsForIosOrTvos().Add(s => s.WithEmbedBitcode(true)); plugin.DynamicLinkerSettingsForWindows().Add(s => s.WithDefinitionFile("src/ProfilerPlugin.def")); foreach (var command in commands) { var toolchain = command.ToolChain; plugin.OutputName.Set(c => DllNameForPlatform(c.ToolChain.Platform)); var config = new NativeProgramConfiguration(CodeGen.Release, toolchain, false); var builtProgram = plugin.SetupSpecificConfiguration(config, toolchain.DynamicLibraryFormat, targetDirectory: $"artifacts_preprocess/{toolchain.LegacyPlatformIdentifier}"); if (command.PostProcess != null) { builtProgram = command.PostProcess(builtProgram, toolchain, command.PluginSubFolder); } Backend.Current.AddAliasDependency(command.Alias, builtProgram); } }
protected virtual DotNetAssembly SetupNativeProgram(CSharpProgramConfiguration config, DotNetAssembly result) { var dotsConfig = (DotsRuntimeCSharpProgramConfiguration)config; var npc = dotsConfig.NativeProgramConfiguration; if (NativeProgram != null && NativeProgram.Sources.ForAny().Any()) { BuiltNativeProgram setupSpecificConfiguration = NativeProgram.SetupSpecificConfiguration(npc, npc.ToolChain.DynamicLibraryFormat ?? npc.ToolChain.StaticLibraryFormat); result = result.WithDeployables(setupSpecificConfiguration); } return(result); }
private static void ProcessProgram(NativeProgram plugin, string targetDir, List <BuildCommand> commands) { foreach (var command in commands) { var toolchain = command.ToolChain; var config = new NativeProgramConfiguration(CodeGen.Release, toolchain, false); var builtProgram = plugin.SetupSpecificConfiguration(config, toolchain.DynamicLibraryFormat); var artefact = builtProgram.Path; if (command.PostProcess != null) { artefact = command.PostProcess(artefact, toolchain, targetDir, command.PluginSubFolder); } Backend.Current.AddAliasDependency(command.Alias, artefact); } }
private static void BuildStarterKitPlugin() { var np = new NativeProgram("MARSXRSubsystem"); np.Sources.Add("Source"); np.IncludeDirectories.Add("External/Unity"); var toolchains = new ToolChain[] { new WindowsToolchain(new Lazy <WindowsSdk>(() => WindowsSdk.Locatorx64.UserDefaultOrLatest).Value), new MacToolchain(new Lazy <MacSdk>(() => MacSdk.Locatorx64.UserDefaultOrLatest).Value), //new AndroidNdkToolchain(new Lazy<AndroidNdk>(() => (AndroidNdk) ToolChain.Store.Android().r16b().Arm64().Sdk).Value), //new AndroidNdkToolchain(new Lazy<AndroidNdk>(() => (AndroidNdk) ToolChain.Store.Android().r16b().Armv7().Sdk).Value), //new IOSToolchain(new Lazy<IOSSdk>(() => IOSSdk.LocatorArm64.UserDefaultOrLatest).Value), }; np.OutputName.Add(s => s.Platform is AndroidPlatform, $"lib{np.Name}"); foreach (var toolchain in toolchains) { var name = toolchain.Platform.Name.ToLower(); if (!toolchain.CanBuild) { Console.WriteLine($"Can't build {toolchain.ToString()}"); continue; } var nativeProgramConfiguration = new NativeProgramConfiguration(CodeGen.Debug, toolchain, lump: false); //we want to build the nativeprogram into an executable. each toolchain can provide different ways of "linking" (static, dynamic, executable are default ones) var format = toolchain is IOSToolchain ? toolchain.StaticLibraryFormat : toolchain.DynamicLibraryFormat; //and here the magic happens, the nativeprogram gets setup for the specific configuration we just made. var folder = name; var deployFolder = new NPath("build").Combine(folder).Combine(toolchain.Architecture.DisplayName); var output = np.SetupSpecificConfiguration(nativeProgramConfiguration, format).DeployTo(deployFolder); var metaFolder = new NPath("Meta/").Combine(folder).Combine(toolchain.Architecture.DisplayName); var metaFile = metaFolder.Combine("plugin." + output.Path.Extension + ".meta"); var deployedMetaFile = deployFolder.Combine(output.Path.FileName + ".meta"); CopyMetaFileWithNewGUID(metaFile, deployedMetaFile); var alias = name; Backend.Current.AddAliasDependency(alias, output.Path); Backend.Current.AddAliasDependency(alias, deployedMetaFile); } }
internal NativeProgram GetOrMakeNativeProgram() { if (NativeProgram != null) { return(NativeProgram); } var libname = "lib_" + new NPath(FileName).FileNameWithoutExtension.ToLower().Replace(".", "_"); NativeProgram = new NativeProgram(libname); SetupDotsRuntimeNativeProgram(libname, NativeProgram); // sigh NativeProgram.Defines.Add("BUILD_" + MainSourcePath.FileName.ToUpper().Replace(".", "_") + "=1"); return(NativeProgram); }
public static void SetupDotsRuntimeNativeProgram(string libname, NativeProgram np) { np.DynamicLinkerSettingsForMac().Add(c => c.WithInstallName(libname + ".dylib")); np.DynamicLinkerSettingsForIos() .Add(c => c.WithInstallName("@executable_path/Frameworks/" + libname + ".dylib")); np.IncludeDirectories.Add(BuildProgram.BeeRootValue.Combine("cppsupport/include")); //lets always add a dummy cpp file, in case this np is only used to carry other libraries np.Sources.Add(BuildProgram.BeeRootValue.Combine("cppsupport/dummy.cpp").ResolveWithFileSystem()); np.Defines.Add(c => c.Platform is WebGLPlatform, "UNITY_WEBGL=1"); np.Defines.Add(c => c.Platform is WindowsPlatform, "UNITY_WINDOWS=1"); np.Defines.Add(c => c.Platform is MacOSXPlatform, "UNITY_MACOSX=1"); np.Defines.Add(c => c.Platform is LinuxPlatform, "UNITY_LINUX=1"); np.Defines.Add(c => c.Platform is IosPlatform, "UNITY_IOS=1"); np.Defines.Add(c => c.Platform is AndroidPlatform, "UNITY_ANDROID=1"); np.Defines.Add(c => c.CodeGen == CodeGen.Debug, "DEBUG=1"); np.Defines.Add("BINDGEM_DOTS=1"); np.Defines.Add(c => ((DotsRuntimeNativeProgramConfiguration)c).CSharpConfig.EnableManagedDebugging && ((DotsRuntimeNativeProgramConfiguration)c).CSharpConfig.WaitForManagedDebugger, "UNITY_DOTSRUNTIME_IL2CPP_WAIT_FOR_MANAGED_DEBUGGER"); np.Defines.Add(c => ((DotsRuntimeNativeProgramConfiguration)c).CSharpConfig.EnableUnityCollectionsChecks, "ENABLE_UNITY_COLLECTIONS_CHECKS"); // Using ENABLE_PROFILER and not ENABLE_DOTSRUNTIME_PROFILER because native code doesn't call any DOTS Runtime specific API np.Defines.Add(c => (c as DotsRuntimeNativeProgramConfiguration)?.CSharpConfig.EnableProfiler == true, "ENABLE_PROFILER"); //we don't want to do this for c#, because then burst sees different code from the unbursted path and it's very //easy and tempting to go insane this way. but for native, it's fine, since burst //doesn't see that directly. and also, it enables us to error when we don't find the burst dll when burst is on, //and not look for it when it's off. np.Defines.Add(c => ((DotsRuntimeNativeProgramConfiguration)c).CSharpConfig.UseBurst, "ENABLE_UNITY_BURST=1"); np.CompilerSettingsForEmscripten().Add(c => ((DotsRuntimeNativeProgramConfiguration)c).CSharpConfig.EnableManagedDebugging, c => c.WithMultithreading_Compiler(EmscriptenMultithreadingMode.Enabled)); np.StaticLinkerSettings() .Add(c => c.ToolChain is EmscriptenToolchain && ((DotsRuntimeNativeProgramConfiguration)c).CSharpConfig.EnableManagedDebugging, s => s.WithCustomFlags_workaround(new[] { "-s", "USE_PTHREADS=1" })); np.CompilerSettings().Add(c => c.WithWarningsAsErrors(ShouldEnableWarningsAsErrors(libname))); }
static void Main() { // For Windows plugins List <BuildCommand> desktop = new List <BuildCommand>(); desktop.Add(BuildCommand.Create(new WindowsToolchain(WindowsSdk.Locatorx86.UserDefaultOrLatest), "windows", "x86")); desktop.Add(BuildCommand.Create(new WindowsToolchain(WindowsSdk.Locatorx64.UserDefaultOrLatest), "windows", "x86_64")); desktop.Add(BuildCommand.Create(new LinuxGccToolchain(WSLGccSdk.Locatorx64.UserDefaultOrLatest), "linux", "x86_64")); // For Android plugins List <BuildCommand> android = new List <BuildCommand>(); android.Add(BuildCommand.Create(new AndroidNdkToolchain(AndroidNdk.LocatorArmv7.UserDefaultOrLatest), "android", "Android/armeabi-v7a")); android.Add(BuildCommand.Create(new AndroidNdkToolchain(AndroidNdk.LocatorArm64.UserDefaultOrLatest), "android", "Android/arm64-v8a")); android.Add(BuildCommand.Create(new AndroidNdkToolchain(AndroidNdk.Locatorx86.UserDefaultOrLatest), "android", "Android/x86")); NativeProgram androidStudioPlugin = new NativeProgram("libProfilerPluginGAS"); androidStudioPlugin.Sources.Add("src/ProfilerPlugin.cpp"); androidStudioPlugin.Sources.Add("src/AndroidSystrace.cpp"); androidStudioPlugin.Sources.Add("src/AndroidSystraceProfiler.cpp"); androidStudioPlugin.PrebuiltLibraries.Add(new SystemLibrary("log")); ProcessProgram(androidStudioPlugin, "../com.unity.nativeprofilers.androidsystrace/Plugins", android); NativeProgram streamlineAnalyzerPlugin = new NativeProgram("libProfilerPluginASA"); streamlineAnalyzerPlugin.Sources.Add("src/ProfilerPlugin.cpp"); streamlineAnalyzerPlugin.Sources.Add("src/StreamlineAnalyzerProfiler.cpp"); streamlineAnalyzerPlugin.Sources.Add("src/Arm"); streamlineAnalyzerPlugin.PrebuiltLibraries.Add(new SystemLibrary("log")); ProcessProgram(streamlineAnalyzerPlugin, "../com.unity.nativeprofilers.streamlineanalyzer/Plugins", android); NativeProgram vtuneAmplifierPlugin = new NativeProgram("ProfilerPluginIVT"); vtuneAmplifierPlugin.Sources.Add("src/ProfilerPlugin.cpp"); vtuneAmplifierPlugin.Sources.Add("src/VTuneAmplifierProfiler.cpp"); vtuneAmplifierPlugin.DynamicLinkerSettingsForWindows().Add(s => s.WithDefinitionFile("src/ProfilerPlugin.def")); vtuneAmplifierPlugin.PrebuiltLibraries.Add((program) => { return((program.Platform is WindowsPlatform) && (program.ToolChain.Architecture == Architecture.x86)); }, new StaticLibrary("src/Intel/libittnotify32.lib")); vtuneAmplifierPlugin.PrebuiltLibraries.Add((program) => { return((program.Platform is WindowsPlatform) && (program.ToolChain.Architecture == Architecture.x64)); }, new StaticLibrary("src/Intel/libittnotify64.lib")); vtuneAmplifierPlugin.PrebuiltLibraries.Add((program) => { return(program.Platform is LinuxPlatform); }, new StaticLibrary("src/Intel/libittnotify64.a")); vtuneAmplifierPlugin.PrebuiltLibraries.Add((program) => { return(program.Platform is LinuxPlatform); }, new SystemLibrary("dl")); ProcessProgram(vtuneAmplifierPlugin, "../com.unity.nativeprofilers.vtune/Plugins", desktop); }
//Run ./bee build-lib-webp to compile the webp library located in Unity.Tiny.Image2D.Native.cpp~/libwebp and copy it to Unity.Tiny.Image2D.Authoring/libwebp public override void Customize() { var asmdefRoot = AsmDefConfigFile.AsmDefDescriptionFor("Unity.Tiny.Image2D.Native").Directory; var outputDirectory = AsmDefConfigFile.AsmDefDescriptionFor("Unity.Tiny.Image2D.Authoring").Directory; NativeProgram WebPLib = new NativeProgram("libwebp") { Sources = { asmdefRoot.Combine("cpp~/libwebp"), }, IncludeDirectories = { asmdefRoot.Combine("cpp~/libwebp") }, OutputDirectory = { outputDirectory.Combine("libwebp") } }; DotsRuntimeNativeProgramConfiguration config = DotsConfigs.HostDotnet.NativeProgramConfiguration; var builtWebPLib = WebPLib.SetupSpecificConfiguration(config, config.ToolChain.DynamicLibraryFormat); Backend.Current.AddAliasDependency("build-lib-webp", builtWebPLib.Path); }
public static void AddLibIl2CppAsLibraryFor(NativeProgram program) { program.Libraries.Add(c => !ManagedDebuggingIsEnabled(c), LibIL2Cpp); program.Libraries.Add(ManagedDebuggingIsEnabled, BigLibIL2Cpp); }
static NativeProgram CreateLibIl2CppProgram(bool useExceptions, NativeProgram boehmGcProgram = null, string libil2cppname = "libil2cpptiny") { var fileList = Distribution.GetFileList(libil2cppname).ToArray(); var nPaths = fileList.Where(f => f.HasExtension("cpp")).ToArray(); var win32Sources = nPaths.Where(p => p.HasDirectory("Win32")).ToArray(); var posixSources = nPaths.Where(p => p.HasDirectory("Posix")).ToArray(); nPaths = nPaths.Except(win32Sources).Except(posixSources).ToArray(); var program = new NativeProgram("libil2cpp") { Sources = { nPaths, { c => c.Platform.HasPosix,posixSources }, { c => c.Platform is WindowsPlatform,win32Sources } }, Exceptions = { useExceptions }, PublicIncludeDirectories = { Distribution.Path.Combine(libil2cppname), Distribution.Path.Combine("libil2cpp") }, PublicDefines = { "NET_4_0", "GC_NOT_DLL", "RUNTIME_IL2CPP", "LIBIL2CPP_IS_IN_EXECUTABLE=1", { c => c.ToolChain is VisualStudioToolchain,"NOMINMAX", "WIN32_THREADS", "IL2CPP_TARGET_WINDOWS=1" }, { c => c.CodeGen == CodeGen.Debug,"DEBUG", "IL2CPP_DEBUG" } }, Libraries = { { c => c.Platform is WindowsPlatform, new[] { "user32.lib", "advapi32.lib", "ole32.lib", "oleaut32.lib", "Shell32.lib", "Crypt32.lib", "psapi.lib", "version.lib", "MsWSock.lib", "ws2_32.lib", "Iphlpapi.lib", "Dbghelp.lib" }.Select(s => new SystemLibrary(s)) }, { c => c.Platform is MacOSXPlatform, new PrecompiledLibrary[] { new SystemFramework("CoreFoundation") } }, { c => c.Platform is LinuxPlatform, new SystemLibrary("dl") } } }; program.Libraries.Add(BoehmGCProgram); program.RTTI.Set(c => useExceptions && c.ToolChain.EnablingExceptionsRequiresRTTI); if (libil2cppname == "libil2cpptiny") { program.Sources.Add(Distribution.GetFileList("libil2cpp/os")); program.Sources.Add(Distribution.GetFileList("libil2cpp/gc")); program.Sources.Add(Distribution.GetFileList("libil2cpp/utils")); program.Sources.Add(Distribution.GetFileList("libil2cpp/vm-utils")); program.PublicIncludeDirectories.Add(Distribution.Path.Combine("libil2cpp")); program.PublicIncludeDirectories.Add(Distribution.Path.Combine("external").Combine("xxHash")); program.PublicDefines.Add("IL2CPP_TINY"); } //program.CompilerSettingsForMsvc().Add(l => l.WithCompilerRuntimeLibrary(CompilerRuntimeLibrary.None)); return(program); }
public static NativeProgram SetupGLFW() { var glfwArtifacts = new StevedoreArtifact("glfw"); Backend.Current.Register(glfwArtifacts); var glfwRoot = glfwArtifacts.Path; var glfwLib = new NativeProgram("libglfw") { //RootDirectory = glfwRoot, IncludeDirectories = { glfwRoot.Combine("include"), glfwRoot.Combine("src"), }, PublicIncludeDirectories = { glfwRoot.Combine("include") }, Sources = { }, }; glfwLib.Defines.Add(c => c.CodeGen != CodeGen.Debug, "NDEBUG"); glfwLib.Sources.Add(glfwRoot.Combine("src").CombineMany(new string[] { "context.c", "init.c", "input.c", "monitor.c", "vulkan.c", "window.c", })); // // Windows // glfwLib.Defines.Add(c => c.Platform is WindowsPlatform, "_GLFW_WIN32", "_GLFW_BUILD_DLL"); glfwLib.Sources.Add(c => c.Platform is WindowsPlatform, glfwRoot.Combine("src").CombineMany(new string[] { "win32_init.c", "win32_joystick.c", "win32_monitor.c", "win32_time.c", "win32_thread.c", "win32_window.c", "wgl_context.c", "egl_context.c", "osmesa_context.c" })); glfwLib.Libraries.Add(c => c.Platform is WindowsPlatform, new List <string> { "winmm", "gdi32", "opengl32", "user32", "winspool", "shell32", "uuid", "comdlg32", "advapi32" } .ConvertAll(s => new SystemLibrary(s + ".lib")) ); // // Linux // glfwLib.Defines.Add(c => c.Platform is LinuxPlatform, new string[] { "_GLFW_X11", "IL_NO_UTX" }); glfwLib.Sources.Add(c => c.Platform is LinuxPlatform, glfwRoot.Combine("src").CombineMany(new string[] { "input.c", "linux_joystick.c", "x11_init.c", "x11_monitor.c", "x11_window.c", "xkb_unicode.c", "egl_context.c", "glx_context.c", "osmesa_context.c", "posix_thread.c", "posix_time.c" })); glfwLib.Libraries.Add(c => c.Platform is LinuxPlatform, new List <string> { "GL", "X11", "udev", "Xrandr", "dl", "rt" } .ConvertAll(s => new SystemLibrary(s))); // // Mac/iOS // glfwLib.Defines.Add(c => c.Platform is MacOSXPlatform, new string[] { "_GLFW_COCOA" }); glfwLib.Sources.Add(c => c.Platform is MacOSXPlatform, glfwRoot.Combine("src").CombineMany(new string[] { "cocoa_init.m", "cocoa_joystick.m", "cocoa_monitor.m", "cocoa_window.m", "cocoa_time.c", "posix_thread.c", "nsgl_context.m", "egl_context.c", "osmesa_context.c" })); glfwLib.Libraries.Add(c => c.Platform is MacOSXPlatform, new List <string> { "OpenGL", "CoreFoundation", "IOKit", "Cocoa", "CoreData", "CoreVideo" } .ConvertAll(s => new SystemFramework(s))); return(glfwLib); }
public abstract void ProvideNativeProgramSettings(NativeProgram program);
public abstract void ProvideLibIl2CppProgramSettings(NativeProgram program);
private NativeProgramAsLibrary CreateLibIl2CppProgram(bool useExceptions, IL2CPPPlatformBeeSupport platformSupport, bool managedDebuggingEnabled = true, string libil2cppname = "libil2cpp") { NPath[] fileList; if (libil2cppname == "libil2cpptiny" && managedDebuggingEnabled) { fileList = Distribution.GetFileList("libil2cpp").ToArray(); } else { fileList = Distribution.GetFileList(libil2cppname).ToArray(); } var nPaths = fileList.Where(f => f.Parent.FileName != "pch" && f.HasExtension("cpp")).ToArray(); var il2cppPlayerPackageDirectory = _incrementalClassicSharedData.PlayerPackageDirectory.Combine("il2cpp"); var program = new NativeProgram(libil2cppname) { Sources = { nPaths }, Exceptions = { useExceptions }, PublicIncludeDirectories = { Distribution.Path.Combine("libil2cpp") }, IncludeDirectories = { il2cppPlayerPackageDirectory.Exists() ? il2cppPlayerPackageDirectory.Combine("external/baselib/include") : Distribution.Path.Combine("external/baselib/include"), c => il2cppPlayerPackageDirectory.Exists() ? il2cppPlayerPackageDirectory.Combine($"external/baselib/Platforms/{c.Platform.Name}/Include") : Distribution.Path.Combine($"external/baselib/Platforms/{c.Platform.Name}/Include"), Distribution.Path.Combine("external/mono/mono/eglib"), Distribution.Path.Combine("external/mono/mono"), Distribution.Path.Combine("external/mono/"), Distribution.Path.Combine("external/mono/mono/sgen"), Distribution.Path.Combine("external/mono/mono/utils"), Distribution.Path.Combine("external/mono/mono/metadata"), Distribution.Path.Combine("external/mono/mono/metadata/private"), Distribution.Path.Combine("libmono/config"), Distribution.Path.Combine("libil2cpp/os/c-api"), Distribution.Path.Combine("libil2cpp/debugger") }, PublicDefines = { "NET_4_0", "GC_NOT_DLL", "RUNTIME_IL2CPP", "LIBIL2CPP_IS_IN_EXECUTABLE=0", { c => c.ToolChain is VisualStudioToolchain,"NOMINMAX", "WIN32_THREADS", "IL2CPP_TARGET_WINDOWS=1" }, { c => c.CodeGen == CodeGen.Debug,"DEBUG", "IL2CPP_DEBUG=1" }, { c => !(c.Platform is WebGLPlatform),"GC_THREADS=1", "USE_MMAP=1", "USE_MUNMAP=1" }, }, Defines = { "BASELIB_INLINE_NAMESPACE=il2cpp_baselib" }, Libraries = { { c => c.Platform is WindowsPlatform, new[] { "user32.lib", "advapi32.lib", "ole32.lib", "oleaut32.lib", "Shell32.lib", "Crypt32.lib", "psapi.lib", "version.lib", "MsWSock.lib", "ws2_32.lib", "Iphlpapi.lib", "Dbghelp.lib" }.Select(s => new SystemLibrary(s)) }, { c => c.Platform is MacOSXPlatform || c.Platform is IosPlatform, new ILibrary[] { new SystemFramework("CoreFoundation") } }, { c => c.Platform is LinuxPlatform, new SystemLibrary("dl") }, { c => c.Platform is AndroidPlatform, new ILibrary[] { new SystemLibrary("log") } }, } }; program.RTTI.Set(c => useExceptions && c.ToolChain.EnablingExceptionsRequiresRTTI); if (libil2cppname == "libil2cpptiny") { program.Defines.Add("IL2CPP_TINY"); if (!managedDebuggingEnabled) { // Tiny needs to be able to find its include directory before libil2cpp program.IncludeDirectories.AddFront(Distribution.Path.Combine("libil2cpptiny")); program.Sources.Add(Distribution.GetFileList("libil2cpp/os")); program.Sources.Add(Distribution.GetFileList("libil2cpp/gc")); program.Sources.Add(Distribution.GetFileList("libil2cpp/utils")); program.Sources.Add(Distribution.GetFileList("libil2cpp/vm-utils")); } } if (managedDebuggingEnabled) { program.Defines.Add("IL2CPP_MONO_DEBUGGER=1", "IL2CPP_DEBUGGER_PORT=56000", "PLATFORM_UNITY", "UNITY_USE_PLATFORM_STUBS", "ENABLE_OVERRIDABLE_ALLOCATORS", "IL2CPP_ON_MONO=1", "DISABLE_JIT=1", "DISABLE_REMOTING=1", "HAVE_CONFIG_H", "MONO_DLL_EXPORT=1"); program.Defines.Add(c => c.ToolChain.Platform is WebGLPlatform, "HOST_WASM=1"); program.CompilerSettingsForMsvc().Add(c => c.WithCustomFlags(new[] { "/EHcs" })); program.CompilerSettingsForClang().Add(c => c.WithRTTI(true)); program.CompilerSettingsForClang().Add(c => c.WithExceptions(true)); } else { program.Defines.Add("IL2CPP_MONO_DEBUGGER_DISABLED"); } program.PublicDefines.Add(c => c.ToolChain.Platform is AndroidPlatform, "LINUX", "ANDROID", "PLATFORM_ANDROID", "__linux__", "__STDC_FORMAT_MACROS" ); program.PublicDefines.Add(c => c.ToolChain.Platform is AndroidPlatform && c.ToolChain.Architecture is Arm64Architecture, "TARGET_ARM64"); var MonoSourceDir = Distribution.Path.Combine("external/mono"); program.Sources.Add(c => MonoSourcesFor(c, MonoSourceDir, managedDebuggingEnabled)); program.NonLumpableFiles.Add(c => MonoSourcesFor(c, MonoSourceDir, managedDebuggingEnabled)); if (libil2cppname != "libil2cpptiny") { program.PublicIncludeDirectories.Add(Distribution.Path.Combine("external/zlib")); var zlibSources = Distribution.GetFileList("external/zlib").Where(f => f.Extension.Equals("c")).ToArray(); program.NonLumpableFiles.Add(zlibSources); program.Sources.Add(zlibSources); } else { program.PublicIncludeDirectories.Add(Distribution.Path.Combine("external/xxHash")); program.Sources.Add(Distribution.Path.Combine("external/xxHash/xxhash.c")); } var boehmGcRoot = Distribution.Path.Combine("external/bdwgc"); program.Sources.Add(boehmGcRoot.Combine("extra/gc.c")); program.PublicIncludeDirectories.Add(boehmGcRoot.Combine("include")); program.IncludeDirectories.Add(boehmGcRoot.Combine("libatomic_ops/src")); program.Defines.Add( "ALL_INTERIOR_POINTERS=1", "GC_GCJ_SUPPORT=1", "JAVA_FINALIZATION=1", "NO_EXECUTE_PERMISSION=1", "GC_NO_THREADS_DISCOVERY=1", "IGNORE_DYNAMIC_LOADING=1", "GC_DONT_REGISTER_MAIN_STATIC_DATA=1", "NO_DEBUGGING=1", "GC_VERSION_MAJOR=7", "GC_VERSION_MINOR=7", "GC_VERSION_MICRO=0", "HAVE_BDWGC_GC", "HAVE_BOEHM_GC", "DEFAULT_GC_NAME=\"BDWGC\"", "NO_CRT=1", "DONT_USE_ATEXIT=1", "NO_GETENV=1"); program.Defines.Add(c => !(c.Platform is WebGLPlatform), "GC_THREADS=1", "USE_MMAP=1", "USE_MUNMAP=1"); program.Defines.Add(c => c.ToolChain is VisualStudioToolchain, "NOMINMAX", "WIN32_THREADS"); program.CompilerSettings().Add(s => s.WithCppLanguageVersion(CppLanguageVersion.Cpp11)); if (platformSupport != null) { platformSupport.ProvideLibIl2CppProgramSettings(program); } return(program); }
private static DotsRuntimeCSharpProgram SetupGame(AsmDefDescription game) { var gameProgram = GetOrMakeDotsRuntimeCSharpProgramFor(game); var configToSetupGame = new Dictionary <DotsRuntimeCSharpProgramConfiguration, DotNetAssembly>(); if (!PerConfigBuildSettings.ContainsKey(game.Name)) { return(null); } var configsToUse = PerConfigBuildSettings[game.Name].Where(config => !CanSkipSetupOf(game.Name, config)); foreach (var config in configsToUse) { var withoutExt = new NPath(new NPath(gameProgram.FileName).FileNameWithoutExtension).Combine(config.Identifier); NPath exportManifest = withoutExt.Combine("export.manifest"); Backend.Current.RegisterFileInfluencingGraph(exportManifest); if (exportManifest.FileExists()) { var dataFiles = exportManifest.MakeAbsolute().ReadAllLines(); foreach (var dataFile in dataFiles.Select(d => new NPath(d))) { gameProgram.SupportFiles.Add( c => c.Equals(config), new DeployableFile(dataFile, GetDeployPathFromExportPath(dataFile))); } } gameProgram.ProjectFile.StartInfo.Add( c => c == config, StartInfoFor(config, EntryPointExecutableFor(gameProgram, config))); gameProgram.ProjectFile.BuildCommand.Add( c => c == config, new BeeBuildCommand(GameDeployBinaryFor(gameProgram, config).ToString(), false, false).ToExecuteArgs()); } foreach (var config in configsToUse) { DotNetAssembly setupGame = gameProgram.SetupSpecificConfiguration(config); if (config.TargetFramework == TargetFramework.Tiny) { var tinyStandard = new DotNetAssembly(Il2Cpp.Distribution.Path.Combine("build/profiles/Tiny/Facades/netstandard.dll"), Framework.FrameworkNone); setupGame = setupGame.WithDeployables(tinyStandard); } var postILProcessedGame = ILPostProcessorTool.SetupInvocation( setupGame, config, gameProgram.Defines.For(config).ToArray()); var postTypeRegGenGame = TypeRegistrationTool.SetupInvocation(postILProcessedGame, config); configToSetupGame[config] = postTypeRegGenGame; } var il2CppOutputProgram = new Il2Cpp.Il2CppOutputProgram(gameProgram.AsmDefDescription.Name); var configToSetupGameBursted = new Dictionary <DotsRuntimeCSharpProgramConfiguration, DotNetAssembly>(); foreach (var kvp in configToSetupGame) { var config = kvp.Key; var setupGame = kvp.Value; if (config.UseBurst) { BurstCompiler burstCompiler = null; if (config.Platform is WindowsPlatform) { burstCompiler = new BurstCompilerForWindows64(); burstCompiler.Link = false; } else if (config.Platform is MacOSXPlatform) { burstCompiler = new BurstCompilerForMac(); burstCompiler.Link = false; } else if (config.Platform is IosPlatform) { burstCompiler = new BurstCompilerForiOS(); burstCompiler.EnableStaticLinkage = true; burstCompiler.ObjectFileExtension = "a"; } else if (config.Platform is LinuxPlatform) { burstCompiler = new BurstCompilerForLinuxWaitingForBurstRelease(); } else if (config.Platform is AndroidPlatform) { burstCompiler = new BurstCompilerForAndroid(); burstCompiler.EnableStaticLinkage = false; burstCompiler.Link = false; burstCompiler.EnableDirectExternalLinking = true; if (config.NativeProgramConfiguration.ToolChain.Architecture is Arm64Architecture) { burstCompiler.TargetArchitecture = "ARMV8A_AARCH64"; } } else if (config.Platform is WebGLPlatform) { burstCompiler = new BurstCompilerForEmscripten(); burstCompiler.EnableStaticLinkage = true; burstCompiler.DisableVectors = false; } // Only generate marshaling info for platforms that require marshalling (e.g. Windows DotNet) // but also if collection checks are enabled (as that is why we need marshalling) burstCompiler.EnableJobMarshalling &= config.EnableUnityCollectionsChecks; burstCompiler.SafetyChecks = config.EnableUnityCollectionsChecks; burstCompiler.DisableWarnings = "BC1370"; // Suppress warning for burst function throwing an exception var outputDir = $"artifacts/{game.Name}/{config.Identifier}_bursted"; var burstLibName = "lib_burst_generated"; DotNetAssembly burstedGame = setupGame; var burstlib = BurstCompiler.SetupBurstCompilationForAssemblies( burstCompiler, setupGame, new NPath(outputDir).Combine("bclobj"), outputDir, burstLibName, out burstedGame); if ((config.Platform is IosPlatform || config.Platform is AndroidPlatform) && config.NativeProgramConfiguration.ToolChain.DynamicLibraryFormat.Extension == "a") // static lib based toolchain { il2CppOutputProgram.Libraries.Add(c => c.Equals(config.NativeProgramConfiguration), burstlib); il2CppOutputProgram.Defines.Add( c => c.Equals(config.NativeProgramConfiguration), $"FORCE_PINVOKE_{burstLibName}_INTERNAL"); } else if (config.Platform is WebGLPlatform) { il2CppOutputProgram.Libraries.Add(c => c.Equals(config.NativeProgramConfiguration), burstlib); } else { var burstDynamicLib = new NativeProgram(burstLibName); burstDynamicLib.Libraries.Add(c => c.Equals(config.NativeProgramConfiguration), burstlib); burstDynamicLib.Libraries.Add( c => c.Equals(config.NativeProgramConfiguration), gameProgram.TransitiveReferencesFor(config) .Where( p => p is DotsRuntimeCSharpProgram && ((DotsRuntimeCSharpProgram)p).NativeProgram != null) .Select( p => new NativeProgramAsLibrary(((DotsRuntimeCSharpProgram)p).NativeProgram) { BuildMode = NativeProgramLibraryBuildMode.Dynamic })); if (config.Platform is IosPlatform || config.Platform is AndroidPlatform) { NativeJobsPrebuiltLibrary.AddToNativeProgram(burstDynamicLib); } DotsRuntimeCSharpProgram.SetupDotsRuntimeNativeProgram(burstLibName, burstDynamicLib); var builtBurstLib = burstDynamicLib.SetupSpecificConfiguration( config.NativeProgramConfiguration, config.NativeProgramConfiguration.ToolChain.DynamicLibraryFormat); burstedGame = burstedGame.WithDeployables(builtBurstLib); } configToSetupGameBursted[config] = burstedGame; } else { configToSetupGameBursted[config] = setupGame; } } var configToSetupGameStripped = new Dictionary <DotsRuntimeCSharpProgramConfiguration, DotNetAssembly>(); foreach (var kvp in configToSetupGameBursted) { var config = kvp.Key; var setupGame = kvp.Value; if (config.ScriptingBackend == ScriptingBackend.TinyIl2cpp) { setupGame = Il2Cpp.UnityLinker.SetupInvocation(setupGame, $"artifacts/{game.Name}/{config.Identifier}_stripped", config.NativeProgramConfiguration); il2CppOutputProgram.SetupConditionalSourcesAndLibrariesForConfig(config, setupGame); configToSetupGameStripped[kvp.Key] = setupGame; } else { configToSetupGameStripped[kvp.Key] = kvp.Value; } } foreach (var kvp in configToSetupGameStripped) { var config = kvp.Key; var setupGame = kvp.Value; NPath deployPath = GameDeployDirectoryFor(gameProgram, config); IDeployable deployedGame; NPath entryPointExecutable = null; if (config.ScriptingBackend == ScriptingBackend.TinyIl2cpp) { var tinyShellFileName = "tiny_shell.html"; NPath tinyShellPath = new NPath(new NPath(gameProgram.FileName).FileNameWithoutExtension).Combine(config.Identifier, "WebTemplate", tinyShellFileName); il2CppOutputProgram.DynamicLinkerSettingsForEmscripten().Add(c => c.WithShellFile(tinyShellPath)); var builtNativeProgram = il2CppOutputProgram.SetupSpecificConfiguration( config.NativeProgramConfiguration, config.NativeProgramConfiguration.ExecutableFormat ) .WithDeployables(setupGame.RecursiveRuntimeDependenciesIncludingSelf.SelectMany(a => a.Deployables.Where(d => !(d is DotNetAssembly) && !(d is StaticLibrary))) .ToArray()); if (builtNativeProgram is IPackagedAppExtension) { (builtNativeProgram as IPackagedAppExtension).SetAppPackagingParameters( gameProgram.AsmDefDescription.Name, config.DotsConfiguration); } if (config.PlatformBuildConfig is WebBuildConfig webBuildConfig) { if (webBuildConfig.SingleFile) { deployedGame = new DeployableFile(GameDeployBinaryFor(gameProgram, config)); CopyTool.Instance().Setup(deployedGame.Path, (builtNativeProgram as EmscriptenExecutable).Path); } else { deployedGame = builtNativeProgram.DeployTo(deployPath); } var webTemplateFolder = webBuildConfig.WebTemplateFolder; if (String.IsNullOrEmpty(webTemplateFolder)) { webTemplateFolder = LowLevelRoot.Combine("WebSupport", "WebTemplates", "Default").ToString(); } if (new NPath(webTemplateFolder).IsRelative) { webTemplateFolder = new NPath("../..").Combine(webTemplateFolder).MakeAbsolute().ToString(); } if (!new NPath(webTemplateFolder).Combine(tinyShellFileName).FileExists()) { throw new InvalidProgramException($"Web template folder \"{webTemplateFolder}\" doesn't contain \"{tinyShellFileName}\" file."); } foreach (var templateFilePath in new NPath(webTemplateFolder).Files(recurse:true)) { string fileRelativePath = templateFilePath.ToString().Substring(webTemplateFolder.Length + 1); if (fileRelativePath == tinyShellFileName) { NPath shellPackager = LowLevelRoot.Combine("WebSupport", "package_shell_file.js"); NPath tinyShellJS = LowLevelRoot.Combine("WebSupport", "tiny_shell.js"); var inputs = new List <NPath> { TinyEmscripten.NodeExe, shellPackager, templateFilePath, tinyShellJS }; var commandLineArguments = new List <string> { shellPackager.ToString(), "--outputHtml", tinyShellPath.ToString(), "--inputShellHtml", templateFilePath.ToString(), "--inputShellJs", tinyShellJS.ToString() }; NPath exportManifest = new NPath(new NPath(gameProgram.FileName).FileNameWithoutExtension).Combine(config.Identifier, "export.manifest"); if (webBuildConfig.SingleFile && exportManifest.FileExists()) { inputs.Add(exportManifest.MakeAbsolute().ReadAllLines().Select(d => new NPath(d))); NPath assetRootDirectory = new NPath(new NPath(gameProgram.FileName).FileNameWithoutExtension).Combine(config.Identifier); commandLineArguments.AddRange(new List <string> { "--assetRootDirectory", assetRootDirectory.ToString(), "--assetManifest", exportManifest.ToString() }); } Backend.Current.AddAction( actionName: "Package Shell File", targetFiles: new NPath[] { tinyShellPath }, inputs: inputs.ToArray(), executableStringFor: TinyEmscripten.NodeExe.InQuotes(), commandLineArguments: commandLineArguments.Select(d => d.InQuotes()).ToArray() ); Backend.Current.AddDependency(deployedGame.Path, tinyShellPath); } else if (!templateFilePath.HasExtension("meta")) { var targetPath = deployPath.Combine(fileRelativePath); CopyTool.Instance().Setup(targetPath, templateFilePath); Backend.Current.AddDependency(deployedGame.Path, targetPath); } } } else { deployedGame = builtNativeProgram.DeployTo(deployPath); } entryPointExecutable = deployedGame.Path; if (config.EnableManagedDebugging && !(builtNativeProgram is IPackagedAppExtension)) { Backend.Current.AddDependency(deployedGame.Path, Il2Cpp.CopyIL2CPPMetadataFile(deployPath, setupGame)); } // make sure http-server gets fetched from stevedore. this should probably go elsewhere, but this is // a convenient quick hack place. if (config.PlatformBuildConfig is WebBuildConfig) { var httpserver = new StevedoreArtifact("http-server"); httpserver.GenerateUnusualPath(); var httpserverpath = httpserver.GetUnusualPath().Combine("bin", "http-server"); Backend.Current.AddDependency(deployedGame.Path, httpserverpath); } } else { deployedGame = setupGame.DeployTo(deployPath); var dotNetAssembly = (DotNetAssembly)deployedGame; //Usually a dotnet runtime game does not have a static void main(), and instead references another "entrypoint asmdef" that provides it. //This is convenient, but what makes it weird is that you have to start YourEntryPoint.exe instead of YourGame.exe. Until we have a better //solution for this, we're going to copy YourEntryPoint.exe to YourGame.exe, so that it's easier to find, and so that when it runs and you look //at the process name you understand what it is. if (deployedGame.Path.HasExtension("dll")) { var to = deployPath.Combine(deployedGame.Path.ChangeExtension("exe").FileName); // Do an explicit check for the entrypoint.exe as a program may refer to other exes as assembly references var from = dotNetAssembly.RecursiveRuntimeDependenciesIncludingSelf.SingleOrDefault(a => a.Path.FileName == "Unity.Runtime.EntryPoint.exe")?.Path; if (from == null) { throw new InvalidProgramException($"Program {dotNetAssembly.Path} is an executable-like thing, but doesn't reference anything with Main"); } Backend.Current.AddDependency(deployedGame.Path, CopyTool.Instance().Setup(to, from)); entryPointExecutable = to; } else { entryPointExecutable = deployedGame.Path; } } //Because we use multidag, and try to not run all the setupcode when we just want to create projectfiles, we have a bit of a challenge. //Projectfiles require exact start and build commands. So we need to have a cheap way to calculate those. However, it's important that they //exactly match the actual place where the buildprogram is going to place our files. If these don't match things break down. The checks //in this block, they compare the "quick way to determine where the binary will be placed, and what the start executable is", with the //actual return values returned from .DeployTo(), when we do run the actual buildcode. NPath deployedGamePath = GameDeployBinaryFor(gameProgram, config); //Identifier with slash means that this is complementary target and we should skip steps which are main target specific. //See comment in DotsConfigs.cs DotsConfigs.MakeConfigs() method for details. if (config.Identifier.IndexOf('/') != -1) { continue; } if (deployedGame.Path != deployedGamePath) { throw new InvalidProgramException($"We expected deployPath to be {deployedGamePath}, but in reality it was {deployedGame.Path}"); } var expectedEntryPointExecutable = EntryPointExecutableFor(gameProgram, config); if (entryPointExecutable != expectedEntryPointExecutable) { throw new InvalidProgramException($"We expected entryPointExecutable to be {expectedEntryPointExecutable}, but in reality it was {entryPointExecutable}"); } Backend.Current.AddAliasDependency(config.Identifier, deployedGamePath); } return(gameProgram); }
public static void Add(NativeProgram np) { var allPlatforms = new [] { "Android", "Linux", "Windows", "OSX", "IOS", "WebGL" }; var staticPlatforms = new[] { "IOS", "WebGL", }; var allArtifact = new StevedoreArtifact("nativejobs-all-public"); Backend.Current.Register(allArtifact); np.PublicIncludeDirectories.Add(allArtifact.Path.Combine("Include")); DotsConfiguration DotsConfig(NativeProgramConfiguration npc) => ((DotsRuntimeNativeProgramConfiguration)npc).CSharpConfig.DotsConfiguration; foreach (var platform in allPlatforms) { var platformIncludes = new StevedoreArtifact($"nativejobs-{platform}-public"); var prebuiltLibName = $"nativejobs-{platform}" + (staticPlatforms.Contains(platform) ? "-s" : "-d"); var prebuiltLib = new StevedoreArtifact(prebuiltLibName); Backend.Current.Register(platformIncludes); Backend.Current.Register(prebuiltLib); np.PublicDefines.Add(c => c.Platform.Name == platform, "BASELIB_USE_DYNAMICLIBRARY=1"); np.PublicIncludeDirectories.Add(c => c.Platform.Name == platform, platformIncludes.Path.Combine("Platforms", platform, "Include")); switch (platform) { case "Windows": np.Libraries.Add(c => c.Platform.Name == platform, c => new[] { new MsvcDynamicLibrary(prebuiltLib.Path.Combine("lib", platform.ToLower(), BaselibArchitectureName(c), DotsConfig(c).ToString().ToLower(), "nativejobs.dll")) }); break; case "Linux": case "Android": np.Libraries.Add(c => c.Platform.Name == platform, c => new[] { new DynamicLibrary(prebuiltLib.Path.Combine("lib", platform.ToLower(), BaselibArchitectureName(c), DotsConfig(c).ToString().ToLower(), "libnativejobs.so")) }); break; case "OSX": np.Libraries.Add(c => c.Platform.Name == platform, c => new[] { new DynamicLibrary(prebuiltLib.Path.Combine("lib", platform.ToLower(), BaselibArchitectureName(c), DotsConfig(c).ToString().ToLower(), "libnativejobs.dylib")) }); break; case "IOS": // this is ugly solution, but I don't see any other way to add static librray to Deployables np.Libraries.Add(c => c.Platform.Name == platform, c => new[] { new DynamicLibrary(prebuiltLib.Path.Combine("lib", platform.ToLower(), BaselibArchitectureName(c), DotsConfig(c).ToString().ToLower(), "libnativejobs.a")) }); break; case "WebGL": np.Libraries.Add(c => c.Platform.Name == platform, c => new[] { new StaticLibrary(prebuiltLib.Path.Combine("lib", platform.ToLower(), BaselibArchitectureName(c), DotsConfig(c).ToString().ToLower(), "libnativejobs.bc")) }); break; } } }
private NativeProgram NativeProgramForIL2CPPOutput(string nativeProgramName, NPath[] il2cppOutputFiles, IL2CPPPlatformBeeSupport platformSupport, bool managedDebuggingEnabled = true, bool libil2cpptiny = false) { var il2cppPlayerPackageDirectory = _incrementalClassicSharedData.PlayerPackageDirectory.Combine("il2cpp"); var nativeProgram = new NativeProgram(nativeProgramName) { Sources = { il2cppOutputFiles }, Exceptions = { true }, IncludeDirectories = { il2cppPlayerPackageDirectory.Exists() ? il2cppPlayerPackageDirectory.Combine("libil2cpp/include") : Distribution.Path.Combine("libil2cpp"), il2cppPlayerPackageDirectory.Exists() ? il2cppPlayerPackageDirectory.Combine("external/baselib/include") : Distribution.Path.Combine("external/baselib/include"), c => il2cppPlayerPackageDirectory.Exists() ? il2cppPlayerPackageDirectory.Combine($"external/baselib/Platforms/{c.Platform.Name}/Include") : Distribution.Path.Combine($"external/baselib/Platforms/{c.Platform.Name}/Include") }, Defines = { "BASELIB_INLINE_NAMESPACE=il2cpp_baselib", "RUNTIME_IL2CPP=1" } }; nativeProgram.Libraries.Add(c => CreateLibIl2CppProgram(!libil2cpptiny, platformSupport, managedDebuggingEnabled, libil2cpptiny ? "libil2cpptiny" : "libil2cpp")); nativeProgram.Libraries.Add(c => c.ToolChain.Platform is WindowsPlatform && _incrementalClassicSharedData.VariationDirectory.Combine("baselib.dll.lib").Exists(), new StaticLibrary(_incrementalClassicSharedData.VariationDirectory.Combine("baselib.dll.lib"))); nativeProgram.Libraries.Add(c => c.ToolChain.Platform is AndroidPlatform && c.ToolChain.Architecture is Arm64Architecture && _incrementalClassicSharedData.VariationDirectory.Combine("StaticLibs/arm64-v8a/baselib.a").Exists(), new StaticLibrary(_incrementalClassicSharedData.VariationDirectory.Combine("StaticLibs/arm64-v8a/baselib.a"))); nativeProgram.Libraries.Add(c => c.ToolChain.Platform is AndroidPlatform && c.ToolChain.Architecture is ARMv7Architecture && _incrementalClassicSharedData.VariationDirectory.Combine("StaticLibs/armeabi-v7a/baselib.a").Exists(), new StaticLibrary(_incrementalClassicSharedData.VariationDirectory.Combine("StaticLibs/armeabi-v7a/baselib.a"))); nativeProgram.Libraries.Add(c => c.ToolChain.Platform is MacOSXPlatform && _incrementalClassicSharedData.VariationDirectory.Combine("baselib.a").Exists(), new StaticLibrary(_incrementalClassicSharedData.VariationDirectory.Combine("baselib.a"))); nativeProgram.Libraries.Add(c => c.ToolChain.Platform is IosPlatform && _incrementalClassicSharedData.PlayerPackageDirectory.Combine("Trampoline/Libraries/baselib-dev.a").Exists(), new StaticLibrary(_incrementalClassicSharedData.PlayerPackageDirectory.Combine("Trampoline", "Libraries", "baselib-dev.a"))); if (il2cppPlayerPackageDirectory.Combine("libil2cpp/include/pch").Exists() || Distribution.Path.Combine("libil2cpp/pch").Exists()) { var libil2cppDir = il2cppPlayerPackageDirectory.Combine("libil2cpp/include").Exists() ? il2cppPlayerPackageDirectory.Combine("libil2cpp/include") : Distribution.Path.Combine("libil2cpp"); var libil2cpptinyDir = il2cppPlayerPackageDirectory.Combine("libil2cpptiny/include").Exists() ? il2cppPlayerPackageDirectory.Combine("libil2cpptiny/include") : Distribution.Path.Combine("libil2cpptiny"); if (libil2cpptiny) { nativeProgram.Defines.Add("IL2CPP_TINY"); if (managedDebuggingEnabled) { nativeProgram.IncludeDirectories.Add(libil2cppDir.Combine("pch")); nativeProgram.PerFilePchs.Add(libil2cppDir.Combine("pch/pch-cpp.hpp"), nativeProgram.Sources.ForAny().Where(f => f.HasExtension(".cpp"))); nativeProgram.PerFilePchs.Add(libil2cppDir.Combine("pch/pch-c.h"), nativeProgram.Sources.ForAny().Where(f => f.HasExtension(".c"))); } else { // Tiny needs to be able to find its include directory before libil2cpp nativeProgram.IncludeDirectories.AddFront(libil2cpptinyDir); nativeProgram.IncludeDirectories.AddFront(libil2cpptinyDir.Combine("pch")); nativeProgram.PerFilePchs.Add(libil2cpptinyDir.Combine("pch/pch-cpp.hpp"), nativeProgram.Sources.ForAny().Where(f => f.HasExtension(".cpp"))); } } else { nativeProgram.IncludeDirectories.Add(libil2cppDir.Combine("pch")); nativeProgram.PerFilePchs.Add(libil2cppDir.Combine("pch/pch-cpp.hpp"), nativeProgram.Sources.ForAny().Where(f => f.HasExtension(".cpp"))); nativeProgram.PerFilePchs.Add(libil2cppDir.Combine("pch/pch-c.h"), nativeProgram.Sources.ForAny().Where(f => f.HasExtension(".c"))); } } nativeProgram.CompilerSettings().Add(s => s.WithCppLanguageVersion(CppLanguageVersion.Cpp11)); nativeProgram.CompilerSettingsForMsvc() .Add(c => c.WithCustomFlags(new[] { "/EHs" })); nativeProgram.CompilerSettingsForMsvc() .Add(c => c.WithWarningPolicies(new[] { new WarningAndPolicy("4102", WarningPolicy.Silent) })); // nativeProgram.CompilerSettingsForMsvc() // .Add(c => c.WithPDB(_incrementalClassicSharedData.BeeProjectRoot.Combine("libil2cpp.pdb"))); nativeProgram.CompilerSettingsForClang().Add(c => c.WithWarningPolicies(new[] { new WarningAndPolicy("pragma-once-outside-header", WarningPolicy.Silent) })); if (platformSupport != null) { platformSupport.ProvideNativeProgramSettings(nativeProgram); } nativeProgram.NonLumpableFiles.Add(nativeProgram.Sources.ForAny()); return(nativeProgram); }
public BgfxBuild() { var rendererRoot = AsmDefConfigFile.AsmDefDescriptionFor("Unity.Tiny.Rendering.Native").Directory; bool useLocalBgfx = false; BgfxArtifact = new StevedoreArtifact("bgfx-source"); BgfxRoot = BgfxArtifact.Path.ResolveWithFileSystem(); //BgfxRoot = @"C:\Users\sebastianm\gits\bgfx-root"; //useLocalBgfx = true; var bx = BgfxRoot.Combine("bx"); var bgfx = BgfxRoot.Combine("bgfx"); var bimg = BgfxRoot.Combine("bimg"); // Note that these 3 NativePrograms are only linked in as BagOfObjects into the bgfx dll above. // They should not have Libraries themselves (e.g. bgfx should not reference the bx or bimg NativePrograms). // This means that PublicIncludes won't work, which is why Bimg and Bgfx explicitly add BxLib's PublicIncludes // to their own Includes. BxLib = new NativeProgram("bx") { Exceptions = { false }, RTTI = { false }, PublicIncludeDirectories = { bx.Combine("include"), bx.Combine("3rdparty"), }, Sources = { //bx.Combine("src").Files("*.cpp").Except(new[] {bx.Combine("src/amalgamated.cpp"), bx.Combine("src/crtnone.cpp")}) bx.Combine("src/amalgamated.cpp") }, Defines = { "__STDC_FORMAT_MACROS" }, }; BxLib.CompilerSettings().Add(c => c.WithCppLanguageVersion(CppLanguageVersion.Cpp14)); BxLib.CompilerSettingsForMac().Add(c => c.WithObjcArc(false)); BxLib.CompilerSettingsForIos().Add(c => c.WithObjcArc(false)); BxLib.Defines.Add(c => c.Platform is WindowsPlatform, "_CRT_SECURE_NO_WARNINGS"); BxLib.PublicIncludeDirectories.Add(c => c.ToolChain is WindowsToolchain, bx.Combine("include/compat/msvc")); BxLib.PublicIncludeDirectories.Add(c => c.Platform is MacOSXPlatform, bx.Combine("include/compat/osx")); BxLib.PublicIncludeDirectories.Add(c => c.Platform is IosPlatform, bx.Combine("include/compat/ios")); BxLib.CompilerSettingsForEmscripten().Add(Il2Cpp.ManagedDebuggingIsEnabled, c => c.WithMultithreading_Compiler(EmscriptenMultithreadingMode.Enabled)); BimgLib = new NativeProgram("bimg") { Exceptions = { false }, RTTI = { false }, IncludeDirectories = { bimg.Combine("include"), bimg.Combine("3rdparty/astc-codec/include"), // comment out next line once BIMG_DECODE_ASTC lands in bimg bimg.Combine("3rdparty/astc-codec"), }, Sources = { bimg.Combine("src/image.cpp"), bimg.Combine("src/image_gnf.cpp"), // comment out next line once BIMG_DECODE_ASTC lands in bimg bimg.Combine("3rdparty/astc-codec/src/decoder").CombineMany(new [] { "astc_file.cc","codec.cc", "endpoint_codec.cc", "footprint.cc", "integer_sequence_codec.cc", "intermediate_astc_block.cc", "logical_astc_block.cc", "partition.cc", "physical_astc_block.cc", "quantization.cc", "weight_infill.cc" }) }, Defines = { "__STDC_FORMAT_MACROS", "BIMG_DECODE_ENABLE=0" }, }; BimgLib.CompilerSettings().Add(c => c.WithCppLanguageVersion(CppLanguageVersion.Cpp14)); BimgLib.CompilerSettingsForMac().Add(c => c.WithObjcArc(false)); BimgLib.CompilerSettingsForIos().Add(c => c.WithObjcArc(false)); BimgLib.IncludeDirectories.Add(c => BxLib.PublicIncludeDirectories.For(c)); BimgLib.CompilerSettingsForEmscripten().Add(Il2Cpp.ManagedDebuggingIsEnabled, c => c.WithMultithreading_Compiler(EmscriptenMultithreadingMode.Enabled)); BgfxLib = new NativeProgram("bgfx") { Exceptions = { false }, RTTI = { false }, IncludeDirectories = { bimg.Combine("include"), bgfx.Combine("include"), bgfx.Combine("3rdparty"), bgfx.Combine("3rdparty/khronos"), rendererRoot.Combine("cpp~/include"), }, Defines = { "BGFX_SHARED_LIB_BUILD", "__STDC_FORMAT_MACROS" }, }; BgfxLib.CompilerSettings().Add(c => c.WithCppLanguageVersion(CppLanguageVersion.Cpp14)); BgfxLib.CompilerSettingsForMac().Add(c => c.WithObjcArc(false)); BgfxLib.CompilerSettingsForIos().Add(c => c.WithObjcArc(false)); BgfxLib.IncludeDirectories.Add(c => BxLib.PublicIncludeDirectories.For(c)); BgfxLib.Defines.Add(c => ((DotsRuntimeNativeProgramConfiguration)c).CSharpConfig.Defines.Contains("RENDERING_ENABLE_TRACE"), "BGFX_CONFIG_DEBUG=1"); BgfxLib.Defines.Add(c => c.ToolChain is WindowsToolchain, "_CRT_SECURE_NO_WARNINGS"); //BgfxLib.Defines.Add("BGFX_CONFIG_DEBUG_UNIFORM=0"); if (!useLocalBgfx) { // when using bgfx from stevedore, this requires pix3.h which we don't distribute BgfxLib.Defines.Add(c => c.Platform is WindowsPlatform, "BGFX_CONFIG_DEBUG_ANNOTATION=0"); } else { BgfxLib.Defines.Add(c => c.Platform is WindowsPlatform, "BGFX_CONFIG_DEBUG_ANNOTATION=0"); ///BgfxLib.IncludeDirectories.Add(bgfx.Combine("3rdparty/dxsdk")); } BgfxLib.Defines.Add("BGFX_CONFIG_MAX_BONES=4"); BgfxLib.Defines.Add(c => (c as DotsRuntimeNativeProgramConfiguration)?.CSharpConfig.EnableProfiler == true, "BGFX_CONFIG_PROFILER=1"); // At some point we need to stop using amalgamated, especially for small-size web builds BgfxLib.Sources.Add(c => !(c.Platform is MacOSXPlatform || c.Platform is IosPlatform), bgfx.Combine("src/amalgamated.cpp")); BgfxLib.Sources.Add(c => (c.Platform is MacOSXPlatform || c.Platform is IosPlatform), bgfx.Combine("src/amalgamated.mm")); // This is a hack that the Khronos eglplatform.h header understands in order to define the EGL types as intptr_t, // which is what emscripten wants. Otherwise we fall into a __unix__ path, which includes X11/Xlib.h, and // all hell breaks loose. BgfxLib.Defines.Add(c => c.Platform is WebGLPlatform, "USE_OZONE"); BgfxLib.CompilerSettingsForEmscripten().Add(Il2Cpp.ManagedDebuggingIsEnabled, c => c.WithMultithreading_Compiler(EmscriptenMultithreadingMode.Enabled)); }
static NativeProgram CreateLibIl2CppProgram(bool useExceptions, NativeProgram boehmGcProgram = null, string libil2cppname = "libil2cpptiny") { var fileList = Distribution.GetFileList(libil2cppname).ToArray(); var nPaths = fileList.Where(f => f.HasExtension("cpp")).ToArray(); var win32Sources = nPaths.Where(p => p.HasDirectory("Win32")).ToArray(); var posixSources = nPaths.Where(p => p.HasDirectory("Posix")).ToArray(); nPaths = nPaths.Except(win32Sources).Except(posixSources).ToArray(); var program = new NativeProgram(libil2cppname) { Sources = { nPaths, { c => c.Platform.HasPosix,posixSources }, { c => c.Platform is WindowsPlatform,win32Sources } }, Exceptions = { useExceptions }, PublicIncludeDirectories = { Distribution.Path.Combine(libil2cppname), Distribution.Path.Combine("libil2cpp"), }, PublicDefines = { "NET_4_0", "GC_NOT_DLL", "RUNTIME_IL2CPP", "LIBIL2CPP_IS_IN_EXECUTABLE=1", { c => c.ToolChain is VisualStudioToolchain,"NOMINMAX", "WIN32_THREADS", "IL2CPP_TARGET_WINDOWS=1" }, { c => c.CodeGen == CodeGen.Debug,"DEBUG", "IL2CPP_DEBUG" } }, Libraries = { { c => c.Platform is WindowsPlatform, new[] { "user32.lib", "advapi32.lib", "ole32.lib", "oleaut32.lib", "Shell32.lib", "Crypt32.lib", "psapi.lib", "version.lib", "MsWSock.lib", "ws2_32.lib", "Iphlpapi.lib", "Dbghelp.lib" }.Select(s => new SystemLibrary(s)) }, { c => c.Platform is MacOSXPlatform, new PrecompiledLibrary[] { new SystemFramework("CoreFoundation") } }, { c => c.Platform is LinuxPlatform, new SystemLibrary("dl") }, { c => c.Platform is AndroidPlatform, new[] { new SystemLibrary("log") } } } }; program.Libraries.Add(BoehmGCProgram); program.RTTI.Set(c => useExceptions && c.ToolChain.EnablingExceptionsRequiresRTTI); if (libil2cppname == "libil2cpptiny") { program.Sources.Add(Distribution.GetFileList("libil2cpp/os")); program.Sources.Add(Distribution.GetFileList("libil2cpp/gc")); program.Sources.Add(Distribution.GetFileList("libil2cpp/utils")); program.Sources.Add(Distribution.GetFileList("libil2cpp/vm-utils")); program.PublicIncludeDirectories.Add(Distribution.Path.Combine("libil2cpp")); } else { program.Defines.Add(ManagedDebuggingIsEnabled, "IL2CPP_MONO_DEBUGGER=1", "PLATFORM_UNITY", "UNITY_USE_PLATFORM_STUBS", "ENABLE_OVERRIDABLE_ALLOCATORS", "IL2CPP_ON_MONO=1", "DISABLE_JIT=1", "DISABLE_REMOTING=1", "HAVE_CONFIG_H", "MONO_DLL_EXPORT=1"); program.Defines.Add(c => c.ToolChain.Platform is WebGLPlatform && ManagedDebuggingIsEnabled(c), "HOST_WASM=1"); program.IncludeDirectories.Add(ManagedDebuggingIsEnabled, new[] { Distribution.Path.Combine("external/mono/mono/eglib"), Distribution.Path.Combine("external/mono/mono"), Distribution.Path.Combine("external/mono/"), Distribution.Path.Combine("external/mono/mono/sgen"), Distribution.Path.Combine("external/mono/mono/utils"), Distribution.Path.Combine("external/mono/mono/metadata"), Distribution.Path.Combine("external/mono/metadata/private"), Distribution.Path.Combine("libmono/config"), Distribution.Path.Combine("libil2cpp/os/c-api") }); var MonoSourceDir = Distribution.Path.Combine("external/mono"); program.Sources.Add(ManagedDebuggingIsEnabled, new [] { "mono/eglib/garray.c", "mono/eglib/gbytearray.c", "mono/eglib/gdate-unity.c", "mono/eglib/gdir-unity.c", "mono/eglib/gerror.c", "mono/eglib/gfile-unity.c", "mono/eglib/gfile.c", "mono/eglib/ghashtable.c", "mono/eglib/giconv.c", "mono/eglib/glist.c", "mono/eglib/gmarkup.c", "mono/eglib/gmem.c", "mono/eglib/gmisc-unity.c", "mono/eglib/goutput.c", "mono/eglib/gpath.c", "mono/eglib/gpattern.c", "mono/eglib/gptrarray.c", "mono/eglib/gqsort.c", "mono/eglib/gqueue.c", "mono/eglib/gshell.c", "mono/eglib/gslist.c", "mono/eglib/gspawn.c", "mono/eglib/gstr.c", "mono/eglib/gstring.c", "mono/eglib/gunicode.c", "mono/eglib/gutf8.c", "mono/metadata/mono-hash.c", "mono/metadata/profiler.c", "mono/mini/debugger-agent.c", "mono/utils/atomic.c", "mono/utils/bsearch.c", "mono/utils/dlmalloc.c", "mono/utils/hazard-pointer.c", "mono/utils/json.c", "mono/utils/lock-free-alloc.c", "mono/utils/lock-free-array-queue.c", "mono/utils/lock-free-queue.c", "mono/utils/memfuncs.c", "mono/utils/mono-codeman.c", "mono/utils/mono-conc-hashtable.c", "mono/utils/mono-context.c", "mono/utils/mono-counters.c", "mono/utils/mono-dl.c", "mono/utils/mono-error.c", "mono/utils/mono-filemap.c", "mono/utils/mono-hwcap.c", "mono/utils/mono-internal-hash.c", "mono/utils/mono-io-portability.c", "mono/utils/mono-linked-list-set.c", "mono/utils/mono-log-common.c", "mono/utils/mono-logger.c", "mono/utils/mono-math.c", "mono/utils/mono-md5.c", "mono/utils/mono-mmap-windows.c", "mono/utils/mono-mmap.c", "mono/utils/mono-networkinterfaces.c", "mono/utils/mono-os-mutex.c", "mono/utils/mono-path.c", "mono/utils/mono-poll.c", "mono/utils/mono-proclib-windows.c", "mono/utils/mono-proclib.c", "mono/utils/mono-property-hash.c", "mono/utils/mono-publib.c", "mono/utils/mono-sha1.c", "mono/utils/mono-stdlib.c", "mono/utils/mono-threads-coop.c", "mono/utils/mono-threads-state-machine.c", "mono/utils/mono-threads.c", "mono/utils/mono-tls.c", "mono/utils/mono-uri.c", "mono/utils/mono-value-hash.c", "mono/utils/monobitset.c", "mono/utils/networking-missing.c", "mono/utils/networking.c", "mono/utils/parse.c", "mono/utils/strenc.c", "mono/utils/unity-rand.c", "mono/utils/unity-time.c", "mono/utils/mono-dl-unity.c", "mono/utils/mono-log-unity.c", "mono/utils/mono-threads-unity.c", "mono/utils/networking-unity.c", "mono/utils/os-event-unity.c", "mono/metadata/console-unity.c", "mono/metadata/file-mmap-unity.c", "mono/metadata/w32error-unity.c", "mono/metadata/w32event-unity.c", "mono/metadata/w32file-unity.c", "mono/metadata/w32mutex-unity.c", "mono/metadata/w32process-unity.c", "mono/metadata/w32semaphore-unity.c", "mono/metadata/w32socket-unity.c" }.Select(path => MonoSourceDir.Combine(path))); program.Sources.Add(c => c.ToolChain.Platform is WindowsPlatform && ManagedDebuggingIsEnabled(c), MonoSourceDir.Combine("mono/eglib/gunicode-win32.c")); program.Sources.Add(c => c.ToolChain.Platform is WindowsPlatform && ManagedDebuggingIsEnabled(c), MonoSourceDir.Combine("mono/utils/mono-os-wait-win32.c")); program.Sources.Add(c => c.ToolChain.Platform is WebGLPlatform && ManagedDebuggingIsEnabled(c), MonoSourceDir.Combine("mono/utils/mono-hwcap-web.c")); program.Sources.Add(c => c.ToolChain.Architecture is IntelArchitecture && ManagedDebuggingIsEnabled(c), MonoSourceDir.Combine("mono/utils/mono-hwcap-x86.c")); program.Sources.Add(c => c.ToolChain.Architecture is ARMv7Architecture && ManagedDebuggingIsEnabled(c), MonoSourceDir.Combine("mono/utils/mono-hwcap-arm.c")); program.Sources.Add(c => c.ToolChain.Architecture is Arm64Architecture && ManagedDebuggingIsEnabled(c), MonoSourceDir.Combine("mono/utils/mono-hwcap-arm64.c")); program.IncludeDirectories.Add(ManagedDebuggingIsEnabled, Distribution.Path.Combine("libil2cpp/debugger")); } program.PublicDefines.Add("IL2CPP_TINY"); program.PublicIncludeDirectories.Add(Distribution.Path.Combine("external").Combine("xxHash")); program.CompilerSettings().Add(s => s.WithCppLanguageVersion(CppLanguageVersion.Cpp11)); // Use Baselib headers and library code from the NativeJobs library. CustomizerForZeroJobs.NativeJobsPrebuiltLibrary.Add(program); //program.CompilerSettingsForMsvc().Add(l => l.WithCompilerRuntimeLibrary(CompilerRuntimeLibrary.None)); return(program); }