public D3D12RHIModule(TargetRules Rules) : base(Rules)
{
ModuleName = "D3D12RHI";
SourceFileSearchDir = "D3D12RHI";
ModuleOutputType = ModuleDef.ModuleType.LIB;
IncludeDirectories.Add("Source/Core");
SolutionFolderPath = "Engine/Modules/RHI";
UseCorePCH = false;
PCH = "D3D12RHIPCH";
ModuleOutputType = ModuleDef.ModuleType.ModuleDLL;
UseUnity = true;
ThirdPartyModules.Add("Dx12Build");
ThirdPartyModules.Add("OpenVRBuild");
ThirdPartyModules.Add("PixBuild");
ThirdPartyModules.Add("nvapiBuild");
NuGetPackages.Add("WinPixEventRuntime");
UnsupportedPlatforms.Add("Win64_VK");
UnsupportedPlatforms.Add("Linux");
UnsupportedPlatforms.Add("Android");
string Win64 = "win64";
StaticLibraries.Add(new LibDependency("d3d12.lib", Win64));
StaticLibraries.Add(new LibDependency("dxguid.lib", Win64));
StaticLibraries.Add(new LibDependency("dxgi.lib", Win64));
StaticLibraries.Add(new LibDependency("d3dcompiler.lib", Win64));
if (Rules.Win_SupportsRT())
{
StaticLibraries.Add(new LibDependency("dxcompiler.lib", Win64));
}
}
internal virtual void AddIncludeDirectories(string dirs)
{
//IncludeDirectories.Clear();
string[] ss = dirs.Split(';');
foreach (string s in ss)
{
IncludeDirectories.Add(s);
}
}
public WindowsShaderCompilerModule(TargetRules Rules) : base(Rules)
{
SolutionFolderPath = "Engine/ShaderCompilers/Windows";
ModuleName = "WindowsShaderCompiler";
SourceFileSearchDir = "WindowsShaderCompiler";
PCH = "WindowsShaderPCH";
ModuleOutputType = ModuleDef.ModuleType.DLL;
UseCorePCH = false;
UseUnity = true;
IncludeDirectories.Add("$(Console_SdkIncludeRoot)");
SystemLibNames.Add("d3d12.lib");
SystemLibNames.Add("dxcompiler.lib");
UnsupportedPlatforms.Add("X*");
}
public IncludeDirectory TrackIncludeDir(IncludeDirectory includeDirectory)
{
// cached object
foreach (IncludeDirectory incDir in IncludeDirectories)
{
if (incDir.ToAbsolutizedString() == includeDirectory.ToAbsolutizedString())
{
return(incDir);
}
}
// new object
IncludeDirectories.Add(includeDirectory);
return(null);
}
public CSharpContainerModule(TargetRules Rules) : base(Rules)
{
SolutionFolderPath = "Engine/CSharp";
ModuleName = "CSharpContainer";
SourceFileSearchDir = "CoreModules/CSharpContainer";//CoreModules/
PCH = "CSharpContainerPCH";
ModuleOutputType = ModuleDef.ModuleType.ModuleDLL;
UseCorePCH = false;
UseUnity = true;
NetReferences.Add("CSharpCore");
ModuleDepends.Add("CSharpCore");
IncludeDirectories.Add("//Source//CoreModules//CSharpBridge//");
LaunguageType = ProjectType.ManagedCPP;
UnsupportedPlatforms.Add("Android");
}
public Il2CppOutputProgram(string name) : base(name)
{
AddLibIl2CppAsLibraryFor(this);
var distRoot = Distribution.Path.ResolveWithFileSystem();
Libraries.Add(BoehmGCProgram);
Sources.Add(distRoot.Combine("external").Combine("xxHash/xxhash.c"));
this.DynamicLinkerSettingsForMsvc()
.Add(l => l.WithSubSystemType(SubSystemType.Console).WithEntryPoint("wWinMainCRTStartup"));
Libraries.Add(c => c.ToolChain.Platform is WindowsPlatform, new SystemLibrary("kernel32.lib"));
this.DynamicLinkerSettingsForMsvc().Add(l => l
.WithSubSystemType(SubSystemType.Console)
.WithEntryPoint("wWinMainCRTStartup")
);
Defines.Add(c => c.ToolChain.DynamicLibraryFormat == null, "FORCE_PINVOKE_INTERNAL=1");
this.DynamicLinkerSettingsForAndroid().Add(c =>
((DotsRuntimeNativeProgramConfiguration)c).CSharpConfig.DotsConfiguration == DotsConfiguration.Release, l => l.WithStripAll(true));
Libraries.Add(c => c.Platform is WebGLPlatform, new PreJsLibrary(BuildProgram.BeeRoot.Parent.Combine("LowLevelSupport~", "WebSupport", "tiny_runtime.js")));
Defines.Add(ManagedDebuggingIsEnabled, "IL2CPP_MONO_DEBUGGER=1");
Defines.Add(ManagedDebuggingIsEnabled, "IL2CPP_DEBUGGER_PORT=56000");
// Remove this comment to enable the managed debugger log file. It will be written to the working directory. For Web builds, the output will go to the browser's console.
//Defines.Add(ManagedDebuggingIsEnabled, "IL2CPP_MONO_DEBUGGER_LOGFILE=il2cpp-debugger.log");
Defines.Add(c => ((DotsRuntimeNativeProgramConfiguration)c).CSharpConfig.DotsConfiguration != DotsConfiguration.Release, "IL2CPP_TINY_DEBUG_METADATA");
CompilerSettings().Add(ManagedDebuggingIsEnabled, c => c.WithExceptions(true));
CompilerSettings().Add(ManagedDebuggingIsEnabled, c => c.WithRTTI(true));
IncludeDirectories.Add(ManagedDebuggingIsEnabled, distRoot.Combine("libil2cpp/pch"));
CompilerSettings().Add(s => s.WithCppLanguageVersion(CppLanguageVersion.Cpp11));
this.CompilerSettingsForMsvc().Add(c => c.WithWarningPolicies(new [] { new WarningAndPolicy("4102", WarningPolicy.Silent) }));
this.CompilerSettingsForGcc().Add(s => s.WithWarningPolicies(GetGccLikeWarningPolicies()));
this.CompilerSettingsForClang().Add(s => s.WithWarningPolicies(GetGccLikeWarningPolicies()));
this.CompilerSettingsForEmscripten().Add(s => s.WithWarningPolicies(GetGccLikeWarningPolicies()));
this.CompilerSettingsForIos().Add(s => s.WithWarningPolicies(GetGccLikeWarningPolicies()));
NativeJobsPrebuiltLibrary.AddToNativeProgram(this); // Only required for managed debugging
this.CompilerSettingsForEmscripten().Add(ManagedDebuggingIsEnabled,
c => c.WithMultithreading_Compiler(EmscriptenMultithreadingMode.Enabled));
this.CompilerSettingsForGccLike().Add(s => s.WithCustomFlags(new[] { "-fno-strict-overflow" }));
}
public override void ProcessArgument(string Argument)
{
if (!Argument.StartsWith("-") && FirstStage)
{
InputFile = Argument;
return;
}
switch (Argument)
{
case "-E": FirstStage = true; break;
case "-o": OutputFile = NextArg; break;
case "-c": InputFile = NextArg; break;
case "-I": IncludeDirectories.Add(NextArg); break;
case "-D":
{
var Data = NextArg;
if (Data.StartsWith("_cc2_"))
{
Data = Data.Substring(5);
int iPos = Data.IndexOf('=');
var Var = Data.Substring(0, iPos);
var Value = Data.Substring(iPos + 1);
Vars.Add(Var, Value);
Log.Write($"{Var} = {Value}");
}
Definitions.Add(Data);
}
break;
case "-iprefix": SkipArg(); break;
case "-auxbase-strip": SkipArg(); break;
case "-fpreprocessed": InputFile = NextArg; break;
}
}
public override void Generate(string Path)
{
if (!PreprocessorDefinitions.Contains("%(PreprocessorDefinitions)"))
{
PreprocessorDefinitions += "%(PreprocessorDefinitions)";
}
if (!IncludeDirectories.Contains("%(AdditionalIncludeDirectories)"))
{
IncludeDirectories += "%(AdditionalIncludeDirectories)";
}
if (!IncludeLibraryDirectories.Contains("%(AdditionalLibraryDirectories)"))
{
IncludeLibraryDirectories += "%(AdditionalLibraryDirectories)";
}
if (!IncludeLibraries.Contains("%(AdditionalDependencies)"))
{
IncludeLibraries += "%(AdditionalDependencies)";
}
base.Generate(Path);
}
public Boolean TestWhetherProjectFileBelongs(ProjectFile pf)
{
// TODO: allow relax if some defines are absent in one of sets
if (!CompilerPossiblyRelativePathComparer.Instance.Equals(CompilerInstance.BaseCompiler,
pf.CompilerOfFile.BaseCompiler))
{
return(false);
}
if (OwnerSolution.config.RelaxIncludeDirsOrder)
{
if (!IncludeDirectories.ListIdenticalRelaxOrder(pf.IncludeDirectories))
{
return(false);
}
}
else
{
if (!IncludeDirectories.ListIdentical(pf.IncludeDirectories))
{
return(false);
}
}
if (!Defines.SetEquals(pf.SetOfDefines))
{
return(false);
}
if (!ForcedIncludes.SetEquals(pf.ForceIncludes))
{
return(false);
}
return(true);
}
public void AddIncludeDir(IncludeDirectory includeDir)
{
// TODO: preserve include directories order
IncludeDirectories.AddIncludeDirectory(includeDir);
}
/// <summary>
/// Call RemoteHost.ExtractInfoFromCompiler() instead.
/// Requires these utilities on the remote system: pwd, echo, which, touch, sort, pushd, popd, zip
/// </summary>
/// <param name="remote">Remote host where compiler installed</param>
public void ExtractAdditionalInfo(RemoteHost remote)
{
String remoteTempFile = String.Format(Compiler.RemoteTempFile, BaseCompiler.ShortName, instanceGuid.ToString());
if (remote.Execute("pwd || echo $PWD", out String pwd) != RemoteHost.Success)
{
throw new ApplicationException("could not get current directory name");
}
pwd = pwd.TrimEnd(RemoteHost.LineEndingChars);
if (remote.Execute($"which {BaseCompiler.ExePath}", out String absExePath) != RemoteHost.Success)
{
throw new ApplicationException("could not get absolute compiler path");
}
absExePath = absExePath.TrimEnd(RemoteHost.LineEndingChars);
if (remote.Execute($"{BaseCompiler.ExePath} -dumpversion", out String version) != RemoteHost.Success)
{
throw new ApplicationException("could not extract version from compiler");
}
Version = version.TrimEnd(RemoteHost.LineEndingChars);
// create temporary .c file for auto-distinguishment between C and C++
if (remote.Execute($"touch {remoteTempFile} || echo > {remoteTempFile}", out String _) != RemoteHost.Success)
{
throw new ApplicationException("could not create temporary file");
}
if (remote.Execute($"{BaseCompiler.ExePath} {this} -E -dM {remoteTempFile} | sort", out String defines) != RemoteHost.Success)
{
throw new ApplicationException("could not extract defines from compiler");
}
if (remote.Execute($"{BaseCompiler.ExePath} {this} -E -Wp,-v {remoteTempFile} 2>&1 1> /dev/null", out String includeDirs) != RemoteHost.Success)
{
throw new ApplicationException("could not extract include dirs from compiler");
}
AbsoluteCrosspath xpwd = AbsoluteCrosspath.FromString(pwd);
AbsoluteCrosspath xcompiler = AbsoluteCrosspath.FromString(absExePath);
if (!xcompiler.ToString().Equals(BaseCompiler.ExePath.ToString()))
{
AbsoluteCrosspath compilerLocatedIn = new AbsoluteCrosspath(xcompiler);
((RelativeCrosspath)BaseCompiler.ExePath).SetWorkingDirectory(xcompiler.ToContainingDirectory());
Logger.WriteLine(LogLevel.Info, $"compiler '{BaseCompiler.ExePath}' actually located at '{xcompiler}'");
}
Defines.Clear();
Platform fallbackPlatform = Platform.x64;
foreach (String macro in defines.Split(RemoteHost.LineEndings, StringSplitOptions.RemoveEmptyEntries))
{
// assuming standard format '#define MACRO some thing probably with spaces'
String[] defArray = macro.Split(new[] { ' ' }, 3);
// try to auto-detect the platform
if (VSPlatform == Platform.Unknown)
{
switch (defArray[1])
{
case "__x86_64__": VSPlatform = Platform.x64; break;
case "__i386__": VSPlatform = Platform.x86; break;
case "__arm__": VSPlatform = Platform.ARM; break;
case "__aarch64__": VSPlatform = Platform.ARM64; break;
case "__mips__": VSPlatform = Platform.MIPS; break;
case "__WORDSIZE__": /* this seems to be standard */
case "__INTPTR_WIDTH__": /* this not, but use as fallback */
if (Int32.Parse(defArray[2]) == 32)
{
fallbackPlatform = Platform.x86;
}
break;
}
}
Defines.Add(new Define(defArray[1], defArray[2]));
}
if (VSPlatform == Platform.Unknown)
{
VSPlatform = fallbackPlatform;
}
IncludeDirectories.Clear();
IncludeDirectoryType incDirType = IncludeDirectoryType.Null;
foreach (String cppLine in includeDirs.Split(RemoteHost.LineEndings, StringSplitOptions.RemoveEmptyEntries))
{
// sample output:
/*
* ignoring nonexistent directory "/opt/gcc-4.1.2-glibc-2.5-binutils-2.17-kernel-2.6.18/arm-v5te-linux-gnueabi/include"
#include "..." search starts here:
#include <...> search starts here:
* /opt/gcc-4.1.2-glibc-2.5-binutils-2.17-kernel-2.6.18/bin/../lib/gcc/arm-v5te-linux-gnueabi/4.1.2/include
* /opt/gcc-4.1.2-glibc-2.5-binutils-2.17-kernel-2.6.18/bin/../sysroot-arm-v5te-linux-gnueabi/usr/include
* End of search list.
*/
// regarding priority:
// -iquote has the highest priority affecting #include "..." not only #include <...>
// -I has lower priority than -iquote
// -isystem has lower priority but yet higher priority than system-wide headers
// then follows the priority of system-wide-headers
// -idirafter has the lowest priority possible
// example (gcc 9):
/*
* $ gcc -x c -c -Wp,-v -iquote /proc/1 -I /proc/10 -isystem /proc/12 -I /proc/14 -idirafter /proc/1204 - < /dev/null
* ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
* ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/include-fixed"
* ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/9/../../../../x86_64-linux-gnu/include"
#include "..." search starts here:
* /proc/1
#include <...> search starts here:
* /proc/10
* /proc/14
* /proc/12
* /usr/lib/gcc/x86_64-linux-gnu/9/include
* /usr/local/include
* /usr/include/x86_64-linux-gnu
* /usr/include
* /proc/1204
* End of search list.
*/
// usually gcc does not have any include directories in the #include "..." section.
// so the reason for parsing this section is when using some compiler wrapper that puts some paths to -iquote.
if (cppLine == "#include \"...\" search starts here:")
{
incDirType = IncludeDirectoryType.Quote;
continue;
}
if (cppLine == "#include <...> search starts here:")
{
incDirType = IncludeDirectoryType.System;
continue;
}
if (cppLine.Length > 0 && cppLine[0] == ' ')
{
Crosspath xpath = Crosspath.FromString(cppLine.Substring(1));
if (xpath is RelativeCrosspath relPath)
{
relPath.SetWorkingDirectory(xpwd);
xpath = relPath.Absolutized();
}
IncludeDirectory incDir = new IncludeDirectory(xpath as AbsoluteCrosspath, incDirType);
IncludeDirectory incDirCached = BaseCompiler.TrackIncludeDir(incDir);
if (incDirCached != null)
{
incDir = incDirCached;
}
IncludeDirectories.Add(incDir);
continue;
}
if (cppLine == "End of search list.")
{
break;
}
}
HaveAdditionalInfo = true;
Logger.WriteLine(LogLevel.Info, $"{absExePath} {this} is {VSPlatform} compiler");
}
List <string> FilterProjectDirectories(List <string> directories)
{
return(directories.Where((d) => IncludeDirectories.Contains(d) && !ExcludeDirectories.Contains(d)).ToList());
}
/// <summary>
/// コレクションが変更されたときはソートし直す
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void IncludeDirectories_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
List <IncludeDirectory> sorted = IncludeDirectories.ToList();
IncludeDirectories = new ObservableCollection <IncludeDirectory>(sorted);
}
