protected void RegisterRemoteToolChain(UnrealTargetPlatform InPlatform, CPPTargetPlatform CPPPlatform)
{
RemoteToolChainPlatform = InPlatform;
// Register this tool chain for IOS
Log.TraceVerbose(" Registered for {0}", CPPPlatform.ToString());
UEToolChain.RegisterPlatformToolChain(CPPPlatform, this);
}
public override void RegisterToolChain()
{
// Register this tool chain for WinRT
Log.TraceVerbose(" Registered for {0}", CPPTargetPlatform.WinRT.ToString());
Log.TraceVerbose(" Registered for {0}", CPPTargetPlatform.WinRT_ARM.ToString());
UEToolChain.RegisterPlatformToolChain(CPPTargetPlatform.WinRT, this);
UEToolChain.RegisterPlatformToolChain(CPPTargetPlatform.WinRT_ARM, this);
}
public override void RegisterToolChain()
{
if (UWPPlatform.bEnableUWPSupport)
{
// Register this tool chain for UWP
Log.TraceVerbose(" Registered for {0}", CPPTargetPlatform.UWP.ToString());
UEToolChain.RegisterPlatformToolChain(CPPTargetPlatform.UWP, this);
}
}
// cache the location of SDK tools
public override void RegisterToolChain()
{
if (HTML5SDKInfo.IsSDKInstalled())
{
// set some environment variable we'll need
//Environment.SetEnvironmentVariable("EMCC_DEBUG", "cache");
Environment.SetEnvironmentVariable("EMCC_CORES", "8");
Environment.SetEnvironmentVariable("EMCC_OPTIMIZE_NORMALLY", "1");
// finally register the toolchain that is now ready to go
Log.TraceVerbose(" Registered for {0}", CPPTargetPlatform.HTML5.ToString());
UEToolChain.RegisterPlatformToolChain(CPPTargetPlatform.HTML5, this);
}
}
public override void RegisterToolChain()
{
if (!CrossCompiling())
{
// use native linux toolchain
ClangPath = Which("clang++");
GCCPath = Which("g++");
ArPath = Which("ar");
RanlibPath = Which("ranlib");
// if clang is available, zero out gcc (@todo: support runtime switching?)
if (!String.IsNullOrEmpty(ClangPath))
{
GCCPath = null;
}
}
else
{
// use cross linux toolchain if LINUX_ROOT is specified
BaseLinuxPath = Environment.GetEnvironmentVariable("LINUX_ROOT");
// don't register if we don't have an LINUX_ROOT specified
if (String.IsNullOrEmpty(BaseLinuxPath))
{
return;
}
BaseLinuxPath = BaseLinuxPath.Replace("\"", "");
// set up the path to our toolchains (FIXME: support switching per architecture)
GCCPath = "";
ClangPath = Path.Combine(BaseLinuxPath, @"bin\Clang++.exe");
ArPath = Path.Combine(BaseLinuxPath, @"bin\x86_64-unknown-linux-gnu-ar.exe");
RanlibPath = Path.Combine(BaseLinuxPath, @"bin\x86_64-unknown-linux-gnu-ranlib.exe");
}
if (!DetermineCompilerVersion())
{
Console.WriteLine("Could not determine version of the compiler, not registering Linux toolchain");
return;
}
// Register this tool chain for both Linux
if (BuildConfiguration.bPrintDebugInfo)
{
Console.WriteLine(" Registered for {0}", CPPTargetPlatform.Linux.ToString());
}
UEToolChain.RegisterPlatformToolChain(CPPTargetPlatform.Linux, this);
}
public override void RegisterToolChain()
{
// Make sure the SDK is installed
// look up installed SDK.
string BaseSDKPath = Environment.GetEnvironmentVariable("EMSCRIPTEN");
if (!String.IsNullOrEmpty(BaseSDKPath))
{
BaseSDKPath = BaseSDKPath.Replace("\"", "");
if (!String.IsNullOrEmpty(BaseSDKPath))
{
var EmscriptenSettings = ReadEmscriptenSettings();
EMCCPath = Path.Combine(BaseSDKPath, "emcc");
// also figure out where python lives (if no envvar, assume it's in the path)
if (EmscriptenSettings.ContainsKey("PYTHON"))
{
PythonPath = EmscriptenSettings["PYTHON"];
}
else
{
PythonPath = Environment.GetEnvironmentVariable("PYTHON");
}
string PythonExeName = Utils.IsRunningOnMono ? "python" : "python.exe";
if (PythonPath == null)
{
PythonPath = PythonExeName;
}
else
{
if (!PythonPath.EndsWith(PythonExeName))
{
PythonPath += "/" + PythonExeName;
}
}
EMCCPath = "\"" + EMCCPath + "\"";
// set some environment variable we'll need
//Environment.SetEnvironmentVariable("EMCC_DEBUG", "cache");
Environment.SetEnvironmentVariable("EMCC_CORES", "8");
Environment.SetEnvironmentVariable("EMCC_FORCE_STDLIBS", "1");
Environment.SetEnvironmentVariable("EMCC_OPTIMIZE_NORMALLY", "1");
// finally register the toolchain that is now ready to go
Log.TraceVerbose(" Registered for {0}", CPPTargetPlatform.HTML5.ToString());
UEToolChain.RegisterPlatformToolChain(CPPTargetPlatform.HTML5, this);
}
}
}
// cache the location of SDK tools
public override void RegisterToolChain()
{
if (HTML5SDKInfo.IsSDKInstalled() && HTML5SDKInfo.IsPythonInstalled())
{
EMCCPath = "\"" + HTML5SDKInfo.EmscriptenCompiler() + "\"";
PythonPath = HTML5SDKInfo.PythonPath();
// set some environment variable we'll need
//Environment.SetEnvironmentVariable("EMCC_DEBUG", "cache");
Environment.SetEnvironmentVariable("EMCC_CORES", "8");
Environment.SetEnvironmentVariable("EMCC_FORCE_STDLIBS", "1");
Environment.SetEnvironmentVariable("EMCC_OPTIMIZE_NORMALLY", "1");
// finally register the toolchain that is now ready to go
Log.TraceVerbose(" Registered for {0}", CPPTargetPlatform.HTML5.ToString());
UEToolChain.RegisterPlatformToolChain(CPPTargetPlatform.HTML5, this);
}
}
public override void RegisterToolChain()
{
string NDKPath = Environment.GetEnvironmentVariable("NDKROOT");
// don't register if we don't have an NDKROOT specified
if (String.IsNullOrEmpty(NDKPath))
{
return;
}
NDKPath = NDKPath.Replace("\"", "");
string ClangVersion = "";
string GccVersion = "";
// prefer clang 3.3, but fall back to 3.1 if needed for now
if (Directory.Exists(Path.Combine(NDKPath, @"toolchains\llvm-3.3")))
{
ClangVersion = "3.3";
GccVersion = "4.8";
}
else if (Directory.Exists(Path.Combine(NDKPath, @"toolchains\llvm-3.1")))
{
ClangVersion = "3.1";
GccVersion = "4.6";
}
else
{
return;
}
string ArchitecturePath = "";
string ArchitecturePathWindows32 = @"prebuilt\windows";
string ArchitecturePathWindows64 = @"prebuilt\windows-x86_64";
if (Directory.Exists(Path.Combine(NDKPath, ArchitecturePathWindows64)))
{
Log.TraceVerbose(" Found Windows 64 bit versions of toolchain");
ArchitecturePath = ArchitecturePathWindows64;
}
else if (Directory.Exists(Path.Combine(NDKPath, ArchitecturePathWindows32)))
{
Log.TraceVerbose(" Found Windows 32 bit versions of toolchain");
ArchitecturePath = ArchitecturePathWindows32;
}
else
{
Log.TraceVerbose(" Did not find 32 bit or 64 bit versions of toolchain");
return;
}
// set up the path to our toolchains
ClangPath = Path.Combine(NDKPath, @"toolchains\llvm-" + ClangVersion, ArchitecturePath, @"bin\clang++.exe");
ArPathArm = Path.Combine(NDKPath, @"toolchains\arm-linux-androideabi-" + GccVersion, ArchitecturePath, @"bin\arm-linux-androideabi-ar.exe"); //@todo android: use llvm-ar.exe instead?
ArPathx86 = Path.Combine(NDKPath, @"toolchains\x86-" + GccVersion, ArchitecturePath, @"bin\i686-linux-android-ar.exe"); //@todo android: verify x86 toolchain
// toolchain params
ToolchainParamsArm = " -target armv7-none-linux-androideabi" +
" --sysroot=\"" + Path.Combine(NDKPath, "platforms", GetNdkApiLevel(), "arch-arm") + "\"" +
" -gcc-toolchain \"" + Path.Combine(NDKPath, @"toolchains\arm-linux-androideabi-" + GccVersion, ArchitecturePath) + "\"";
ToolchainParamsx86 = " -target i686-none-linux-android" +
" --sysroot=\"" + Path.Combine(NDKPath, "platforms", GetNdkApiLevel(), "arch-x86") + "\"" +
" -gcc-toolchain \"" + Path.Combine(NDKPath, @"toolchains\x86-" + GccVersion, ArchitecturePath) + "\"";
// Register this tool chain
Log.TraceVerbose(" Registered for {0}", CPPTargetPlatform.Android.ToString());
UEToolChain.RegisterPlatformToolChain(CPPTargetPlatform.Android, this);
}
public override void RegisterToolChain()
{
if (!CrossCompiling())
{
// use native linux toolchain
string[] ClangNames = { "clang++", "clang++-3.5", "clang++-3.3" };
foreach (var ClangName in ClangNames)
{
ClangPath = Which(ClangName);
if (!String.IsNullOrEmpty(ClangPath))
{
break;
}
}
GCCPath = Which("g++");
ArPath = Which("ar");
RanlibPath = Which("ranlib");
// if clang is available, zero out gcc (@todo: support runtime switching?)
if (!String.IsNullOrEmpty(ClangPath))
{
GCCPath = null;
}
}
else
{
// use cross linux toolchain if LINUX_ROOT is specified
BaseLinuxPath = Environment.GetEnvironmentVariable("LINUX_ROOT");
// don't register if we don't have an LINUX_ROOT specified
if (String.IsNullOrEmpty(BaseLinuxPath))
{
return;
}
BaseLinuxPath = BaseLinuxPath.Replace("\"", "");
// set up the path to our toolchains
GCCPath = "";
ClangPath = Path.Combine(BaseLinuxPath, @"bin\clang++.exe");
// ar and ranlib will be switched later to match the architecture
ArPath = "ar.exe";
RanlibPath = "ranlib.exe";
}
if (!DetermineCompilerVersion())
{
Console.WriteLine("\n*** Could not determine version of the compiler, not registering Linux toolchain.\n");
return;
}
// refuse to use compilers that we know won't work
// disable that only if you are a dev and you know what you are doing
if (!UsingClang())
{
Console.WriteLine("\n*** This version of the engine can only be compiled by clang - refusing to register the Linux toolchain.\n");
return;
}
else if (CompilerVersionMajor == 3 && CompilerVersionMinor == 4)
{
Console.WriteLine("\n*** clang 3.4.x is known to miscompile the engine - refusing to register the Linux toolchain.\n");
return;
}
// Register this tool chain for both Linux
if (BuildConfiguration.bPrintDebugInfo)
{
Console.WriteLine(" Registered for {0}", CPPTargetPlatform.Linux.ToString());
}
UEToolChain.RegisterPlatformToolChain(CPPTargetPlatform.Linux, this);
}
public override void RegisterToolChain()
{
string NDKPath = Environment.GetEnvironmentVariable("NDKROOT");
// don't register if we don't have an NDKROOT specified
if (String.IsNullOrEmpty(NDKPath))
{
return;
}
NDKPath = NDKPath.Replace("\"", "");
string ClangVersion = "";
string GccVersion = "";
// prefer clang 3.5, but fall back if needed for now
if (Directory.Exists(Path.Combine(NDKPath, @"toolchains/llvm-3.5")))
{
ClangVersion = "3.5";
GccVersion = "4.9";
}
else if (Directory.Exists(Path.Combine(NDKPath, @"toolchains/llvm-3.3")))
{
ClangVersion = "3.3";
GccVersion = "4.8";
}
else if (Directory.Exists(Path.Combine(NDKPath, @"toolchains/llvm-3.1")))
{
ClangVersion = "3.1";
GccVersion = "4.6";
}
else
{
return;
}
ClangVersionFloat = float.Parse(ClangVersion, System.Globalization.CultureInfo.InvariantCulture);
// Console.WriteLine("Compiling with clang {0}", ClangVersionFloat);
string ArchitecturePath = "";
string ArchitecturePathWindows32 = @"prebuilt/windows";
string ArchitecturePathWindows64 = @"prebuilt/windows-x86_64";
string ArchitecturePathMac = @"prebuilt/darwin-x86_64";
string ExeExtension = ".exe";
if (Directory.Exists(Path.Combine(NDKPath, ArchitecturePathWindows64)))
{
Log.TraceVerbose(" Found Windows 64 bit versions of toolchain");
ArchitecturePath = ArchitecturePathWindows64;
}
else if (Directory.Exists(Path.Combine(NDKPath, ArchitecturePathWindows32)))
{
Log.TraceVerbose(" Found Windows 32 bit versions of toolchain");
ArchitecturePath = ArchitecturePathWindows32;
}
else if (Directory.Exists(Path.Combine(NDKPath, ArchitecturePathMac)))
{
Log.TraceVerbose(" Found Mac versions of toolchain");
ArchitecturePath = ArchitecturePathMac;
ExeExtension = "";
}
else
{
Log.TraceVerbose(" Did not find 32 bit or 64 bit versions of toolchain");
return;
}
// set up the path to our toolchains
ClangPath = Path.Combine(NDKPath, @"toolchains/llvm-" + ClangVersion, ArchitecturePath, @"bin/clang++" + ExeExtension);
ArPathArm = Path.Combine(NDKPath, @"toolchains/arm-linux-androideabi-" + GccVersion, ArchitecturePath, @"bin/arm-linux-androideabi-ar" + ExeExtension); //@todo android: use llvm-ar.exe instead?
ArPathx86 = Path.Combine(NDKPath, @"toolchains/x86-" + GccVersion, ArchitecturePath, @"bin/i686-linux-android-ar" + ExeExtension); //@todo android: verify x86 toolchain
// toolchain params
ToolchainParamsArm = " -target armv7-none-linux-androideabi" +
" --sysroot=\"" + Path.Combine(NDKPath, "platforms", GetNdkApiLevel(), "arch-arm") + "\"" +
" -gcc-toolchain \"" + Path.Combine(NDKPath, @"toolchains/arm-linux-androideabi-" + GccVersion, ArchitecturePath) + "\"";
ToolchainParamsx86 = " -target i686-none-linux-android" +
" --sysroot=\"" + Path.Combine(NDKPath, "platforms", GetNdkApiLevel(), "arch-x86") + "\"" +
" -gcc-toolchain \"" + Path.Combine(NDKPath, @"toolchains/x86-" + GccVersion, ArchitecturePath) + "\"";
// Register this tool chain
Log.TraceVerbose(" Registered for {0}", CPPTargetPlatform.Android.ToString());
UEToolChain.RegisterPlatformToolChain(CPPTargetPlatform.Android, this);
}
