GoaLitiuM/FlaxEngine
1
0
Fork 0
Code Issues Pull Requests Actions 7 Packages Projects Releases Wiki Activity

Add support for building dependencies with specific architecture

Browse Source
This commit is contained in:
Ari Vuollet
2025-10-14 01:50:31 +03:00
parent 9ffe206b81
commit da1c112c92
24 changed files with 1364 additions and 808 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
Source/Tools/Flax.Build/Deps/Dependencies/AGS.cs
View File

@@ -18,6 +18,24 @@ namespace Flax.Deps.Dependencies
get => new[] { TargetPlatform.Windows }; get => new[] { TargetPlatform.Windows };
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -30,7 +48,7 @@ namespace Flax.Deps.Dependencies
// Copy files // Copy files
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); BuildStarted(platform, TargetArchitecture.x64);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64); var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
Utilities.FileCopy(Path.Combine(root, "ags_lib/lib/amd_ags_x64.lib"), Path.Combine(depsFolder, "amd_ags_x64.lib")); Utilities.FileCopy(Path.Combine(root, "ags_lib/lib/amd_ags_x64.lib"), Path.Combine(depsFolder, "amd_ags_x64.lib"));
Utilities.FileCopy(Path.Combine(root, "ags_lib/lib/amd_ags_x64.dll"), Path.Combine(depsFolder, "amd_ags_x64.dll")); Utilities.FileCopy(Path.Combine(root, "ags_lib/lib/amd_ags_x64.dll"), Path.Combine(depsFolder, "amd_ags_x64.dll"));

102
Source/Tools/Flax.Build/Deps/Dependencies/Assimp.cs
View File

@@ -2,6 +2,7 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.Linq;
using Flax.Build; using Flax.Build;
namespace Flax.Deps.Dependencies namespace Flax.Deps.Dependencies
@@ -39,6 +40,36 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -91,22 +122,22 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{ switch (platform)
var configuration = "Release";
var binariesWin = new[]
{ {
Path.Combine("bin", configuration, "assimp-vc140-md.dll"), case TargetPlatform.Windows:
Path.Combine("lib", configuration, "assimp-vc140-md.lib"), {
}; var configuration = "Release";
var binariesWin = new[]
{
Path.Combine("bin", configuration, "assimp-vc140-md.dll"),
Path.Combine("lib", configuration, "assimp-vc140-md.lib"),
};
// Build for Windows // Build for Windows
File.Delete(Path.Combine(root, "CMakeCache.txt")); File.Delete(Path.Combine(root, "CMakeCache.txt"));
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{
var buildDir = Path.Combine(root, "build-" + architecture); var buildDir = Path.Combine(root, "build-" + architecture);
var solutionPath = Path.Combine(buildDir, "Assimp.sln"); var solutionPath = Path.Combine(buildDir, "Assimp.sln");
SetupDirectory(buildDir, true); SetupDirectory(buildDir, true);
@@ -116,41 +147,38 @@ namespace Flax.Deps.Dependencies
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in binariesWin) foreach (var file in binariesWin)
Utilities.FileCopy(Path.Combine(buildDir, file), Path.Combine(depsFolder, Path.GetFileName(file))); Utilities.FileCopy(Path.Combine(buildDir, file), Path.Combine(depsFolder, Path.GetFileName(file)));
break;
} }
case TargetPlatform.Linux:
break;
}
case TargetPlatform.Linux:
{
var envVars = new Dictionary<string, string>
{ {
{ "CC", "clang-" + Configuration.LinuxClangMinVer }, var envVars = new Dictionary<string, string>
{ "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer }, {
{ "CXX", "clang++-" + Configuration.LinuxClangMinVer }, { "CC", "clang-" + Configuration.LinuxClangMinVer },
}; { "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer },
{ "CXX", "clang++-" + Configuration.LinuxClangMinVer },
{ "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel },
};
// Build for Linux // Build for Linux
RunCmake(root, platform, TargetArchitecture.x64, " -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF " + globalConfig, envVars); RunCmake(root, platform, architecture, " -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF " + globalConfig, envVars);
Utilities.Run("make", null, null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars); Utilities.Run("make", null, null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
configHeaderFilePath = Path.Combine(root, "include", "assimp", "config.h"); configHeaderFilePath = Path.Combine(root, "include", "assimp", "config.h");
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
Utilities.FileCopy(Path.Combine(root, "lib", "libassimp.a"), Path.Combine(depsFolder, "libassimp.a")); Utilities.FileCopy(Path.Combine(root, "lib", "libassimp.a"), Path.Combine(depsFolder, "libassimp.a"));
break; break;
} }
case TargetPlatform.Mac: case TargetPlatform.Mac:
{
// Build for Mac
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{ {
// Build for Mac
RunCmake(root, platform, architecture, " -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF " + globalConfig); RunCmake(root, platform, architecture, " -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF " + globalConfig);
Utilities.Run("make", null, null, root, Utilities.RunOptions.ThrowExceptionOnError); Utilities.Run("make", null, null, root, Utilities.RunOptions.ThrowExceptionOnError);
configHeaderFilePath = Path.Combine(root, "include", "assimp", "config.h"); configHeaderFilePath = Path.Combine(root, "include", "assimp", "config.h");
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
Utilities.FileCopy(Path.Combine(root, "lib", "libassimp.a"), Path.Combine(depsFolder, "libassimp.a")); Utilities.FileCopy(Path.Combine(root, "lib", "libassimp.a"), Path.Combine(depsFolder, "libassimp.a"));
Utilities.Run("make", "clean", null, root, Utilities.RunOptions.ThrowExceptionOnError); Utilities.Run("make", "clean", null, root, Utilities.RunOptions.ThrowExceptionOnError);
break;
}
} }
break;
}
} }
} }

30
Source/Tools/Flax.Build/Deps/Dependencies/DirectXMesh.cs
View File

@@ -28,6 +28,24 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -46,12 +64,12 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{ switch (platform)
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 }) {
case TargetPlatform.Windows:
{ {
Deploy.VCEnvironment.BuildSolution(solutionPath, configuration, architecture.ToString()); Deploy.VCEnvironment.BuildSolution(solutionPath, configuration, architecture.ToString());
var depsFolder = GetThirdPartyFolder(options, TargetPlatform.Windows, architecture); var depsFolder = GetThirdPartyFolder(options, TargetPlatform.Windows, architecture);
@@ -61,7 +79,7 @@ namespace Flax.Deps.Dependencies
} }
} }
break; break;
} }
} }
} }

40
Source/Tools/Flax.Build/Deps/Dependencies/DirectXShaderCompiler.cs
View File

@@ -31,22 +31,40 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{ switch (platform)
var sdk = WindowsPlatformBase.GetSDKs().Last();
var sdkLibLocation = Path.Combine(sdk.Value, "Lib", WindowsPlatformBase.GetSDKVersion(sdk.Key).ToString(), "um");
string binLocation = Path.Combine(sdk.Value, "bin", WindowsPlatformBase.GetSDKVersion(sdk.Key).ToString());
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{ {
case TargetPlatform.Windows:
{
var sdk = WindowsPlatformBase.GetSDKs().Last();
var sdkLibLocation = Path.Combine(sdk.Value, "Lib", WindowsPlatformBase.GetSDKVersion(sdk.Key).ToString(), "um");
string binLocation = Path.Combine(sdk.Value, "bin", WindowsPlatformBase.GetSDKVersion(sdk.Key).ToString());
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
string dxilLocation = @$"{binLocation}\{architecture}\dxil.dll"; string dxilLocation = @$"{binLocation}\{architecture}\dxil.dll";
@@ -60,9 +78,9 @@ namespace Flax.Deps.Dependencies
string d3dcompilerLibLocation = @$"{sdkLibLocation}\{architecture}\d3dcompiler.lib"; string d3dcompilerLibLocation = @$"{sdkLibLocation}\{architecture}\d3dcompiler.lib";
Utilities.FileCopy(dxcompilerLibLocation, Path.Combine(depsFolder, Path.GetFileName(dxcompilerLibLocation))); Utilities.FileCopy(dxcompilerLibLocation, Path.Combine(depsFolder, Path.GetFileName(dxcompilerLibLocation)));
Utilities.FileCopy(d3dcompilerLibLocation, Path.Combine(depsFolder, "d3dcompiler_47.lib")); Utilities.FileCopy(d3dcompilerLibLocation, Path.Combine(depsFolder, "d3dcompiler_47.lib"));
break;
}
} }
break;
}
} }
} }
} }

80
Source/Tools/Flax.Build/Deps/Dependencies/DirectXTex.cs
View File

@@ -30,6 +30,24 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -47,44 +65,44 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{ switch (platform)
var solutionPath = Path.Combine(root, "DirectXTex_Desktop_2022_Win10.sln");
var binFolder = Path.Combine(root, "DirectXTex", "Bin", "Desktop_2022_Win10");
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{ {
case TargetPlatform.Windows:
{
var solutionPath = Path.Combine(root, "DirectXTex_Desktop_2022_Win10.sln");
var binFolder = Path.Combine(root, "DirectXTex", "Bin", "Desktop_2022_Win10");
Deploy.VCEnvironment.BuildSolution(solutionPath, configuration, architecture.ToString()); Deploy.VCEnvironment.BuildSolution(solutionPath, configuration, architecture.ToString());
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in outputFileNames) foreach (var file in outputFileNames)
Utilities.FileCopy(Path.Combine(binFolder, architecture.ToString(), configuration, file), Path.Combine(depsFolder, file)); Utilities.FileCopy(Path.Combine(binFolder, architecture.ToString(), configuration, file), Path.Combine(depsFolder, file));
break;
}
case TargetPlatform.UWP:
{
var solutionPath = Path.Combine(root, "DirectXTex_Windows10_2019.sln");
var binFolder = Path.Combine(root, "DirectXTex", "Bin", "Windows10_2019");
Deploy.VCEnvironment.BuildSolution(solutionPath, configuration, "x64");
var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in outputFileNames)
Utilities.FileCopy(Path.Combine(binFolder, "x64", configuration, file), Path.Combine(depsFolder, file));
break;
}
case TargetPlatform.XboxOne:
case TargetPlatform.XboxScarlett:
{
var solutionPath = Path.Combine(root, "DirectXTex_GDK_2022.sln");
var binFolder = Path.Combine(root, "DirectXTex", "Bin", "GDK_2022");
var xboxName = platform == TargetPlatform.XboxOne ? "Gaming.Xbox.XboxOne.x64" : "Gaming.Xbox.Scarlett.x64";
Deploy.VCEnvironment.BuildSolution(solutionPath, configuration, xboxName);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
foreach (var file in outputFileNames)
Utilities.FileCopy(Path.Combine(binFolder, xboxName, configuration, file), Path.Combine(depsFolder, file));
break;
}
} }
break;
}
case TargetPlatform.UWP:
{
var solutionPath = Path.Combine(root, "DirectXTex_Windows10_2019.sln");
var binFolder = Path.Combine(root, "DirectXTex", "Bin", "Windows10_2019");
Deploy.VCEnvironment.BuildSolution(solutionPath, configuration, "x64");
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
foreach (var file in outputFileNames)
Utilities.FileCopy(Path.Combine(binFolder, "x64", configuration, file), Path.Combine(depsFolder, file));
break;
}
case TargetPlatform.XboxOne:
case TargetPlatform.XboxScarlett:
{
var solutionPath = Path.Combine(root, "DirectXTex_GDK_2022.sln");
var binFolder = Path.Combine(root, "DirectXTex", "Bin", "GDK_2022");
var xboxName = platform == TargetPlatform.XboxOne ? "Gaming.Xbox.XboxOne.x64" : "Gaming.Xbox.Scarlett.x64";
Deploy.VCEnvironment.BuildSolution(solutionPath, configuration, xboxName);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
foreach (var file in outputFileNames)
Utilities.FileCopy(Path.Combine(binFolder, xboxName, configuration, file), Path.Combine(depsFolder, file));
break;
}
} }
} }

18
Source/Tools/Flax.Build/Deps/Dependencies/NewtonsoftJson.cs
View File

@@ -36,6 +36,24 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {

95
Source/Tools/Flax.Build/Deps/Dependencies/NvCloth.cs
View File

@@ -50,6 +50,36 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -61,39 +91,40 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
Build(options, platform, TargetArchitecture.x64); switch (platform)
Build(options, platform, TargetArchitecture.ARM64); {
break; case TargetPlatform.Windows:
case TargetPlatform.XboxOne: Build(options, platform, architecture);
case TargetPlatform.XboxScarlett: break;
Build(options, platform, TargetArchitecture.x64); case TargetPlatform.XboxOne:
break; case TargetPlatform.XboxScarlett:
case TargetPlatform.PS4: Build(options, platform, TargetArchitecture.x64);
case TargetPlatform.PS5: break;
Utilities.DirectoryCopy(Path.Combine(GetBinariesFolder(options, platform), "Data", "NvCloth"), root, true, true); case TargetPlatform.PS4:
Build(options, platform, TargetArchitecture.x64); case TargetPlatform.PS5:
break; Utilities.DirectoryCopy(Path.Combine(GetBinariesFolder(options, platform), "Data", "NvCloth"), root, true, true);
case TargetPlatform.Switch: Build(options, platform, TargetArchitecture.x64);
Utilities.DirectoryCopy(Path.Combine(GetBinariesFolder(options, platform), "Data", "NvCloth"), root, true, true); break;
Build(options, platform, TargetArchitecture.ARM64); case TargetPlatform.Switch:
break; Utilities.DirectoryCopy(Path.Combine(GetBinariesFolder(options, platform), "Data", "NvCloth"), root, true, true);
case TargetPlatform.Android: Build(options, platform, TargetArchitecture.ARM64);
Build(options, platform, TargetArchitecture.ARM64); break;
break; case TargetPlatform.Android:
case TargetPlatform.Mac: Build(options, platform, TargetArchitecture.ARM64);
Build(options, platform, TargetArchitecture.x64); break;
Build(options, platform, TargetArchitecture.ARM64); case TargetPlatform.Mac:
break; Build(options, platform, architecture);
case TargetPlatform.iOS: break;
Build(options, platform, TargetArchitecture.ARM64); case TargetPlatform.iOS:
break; Build(options, platform, TargetArchitecture.ARM64);
case TargetPlatform.Linux: break;
Build(options, platform, TargetArchitecture.x64); case TargetPlatform.Linux:
break; Build(options, platform, architecture);
break;
}
} }
} }

363
Source/Tools/Flax.Build/Deps/Dependencies/OpenAL.cs
View File

@@ -45,6 +45,36 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -54,26 +84,55 @@ namespace Flax.Deps.Dependencies
var cmakeArgs = "-DCMAKE_POLICY_VERSION_MINIMUM=3.5"; var cmakeArgs = "-DCMAKE_POLICY_VERSION_MINIMUM=3.5";
var dstIncludePath = Path.Combine(options.ThirdPartyFolder, "OpenAL"); var dstIncludePath = Path.Combine(options.ThirdPartyFolder, "OpenAL");
if (options.Platforms.Contains(TargetPlatform.Windows))
{
// Get the source
CloneGitRepo(root, "https://github.com/kcat/openal-soft.git");
GitCheckout(root, "master", "d3875f333fb6abe2f39d82caca329414871ae53b"); // 1.23.1
}
else
{
// Get the source
var packagePath = Path.Combine(root, $"package-{version}.zip");
if (!File.Exists(packagePath))
{
Downloader.DownloadFileFromUrlToPath("https://openal-soft.org/openal-releases/openal-soft-" + version + ".tar.bz2", packagePath);
using (ZipArchive archive = ZipFile.Open(packagePath, ZipArchiveMode.Read))
{
if (!Directory.Exists(root))
archive.ExtractToDirectory(root);
root = Path.Combine(root, archive.Entries.First().FullName);
}
}
/*if (Platform.BuildTargetPlatform == TargetPlatform.Windows)
{
// TODO: Maybe use PowerShell Expand-Archive instead?
var sevenZip = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "7-Zip", "7z.exe");
Utilities.Run(sevenZip, "x package.zip", null, root);
Utilities.Run(sevenZip, "x package", null, root);
}
else
{
Utilities.Run("tar", "xjf " + packagePath.Replace('\\', '/'), null, root, Utilities.RunOptions.ConsoleLogOutput);
}*/
}
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{ switch (platform)
var binariesToCopy = new[]
{ {
"OpenAL32.lib", case TargetPlatform.Windows:
"OpenAL32.dll",
};
// Get the source
CloneGitRepo(root, "https://github.com/kcat/openal-soft.git");
GitCheckout(root, "master", "dc7d7054a5b4f3bec1dc23a42fd616a0847af948"); // 1.24.3
// Build for Win64 and ARM64
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{ {
var binariesToCopy = new[]
{
"OpenAL32.lib",
"OpenAL32.dll",
};
// Build for Windows
var buildDir = Path.Combine(root, "build-" + architecture.ToString()); var buildDir = Path.Combine(root, "build-" + architecture.ToString());
var solutionPath = Path.Combine(buildDir, "OpenAL.sln"); var solutionPath = Path.Combine(buildDir, "OpenAL.sln");
@@ -82,184 +141,146 @@ namespace Flax.Deps.Dependencies
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in binariesToCopy) foreach (var file in binariesToCopy)
Utilities.FileCopy(Path.Combine(buildDir, configuration, file), Path.Combine(depsFolder, Path.GetFileName(file))); Utilities.FileCopy(Path.Combine(buildDir, configuration, file), Path.Combine(depsFolder, Path.GetFileName(file)));
}
#if false #if false
// Get the binaries // Get the binaries
var packagePath = Path.Combine(root, "package.zip"); var packagePath = Path.Combine(root, "package.zip");
if (!File.Exists(packagePath)) if (!File.Exists(packagePath))
Downloader.DownloadFileFromUrlToPath("https://openal-soft.org/openal-binaries/openal-soft-" + version + "-bin.zip", packagePath); Downloader.DownloadFileFromUrlToPath("https://openal-soft.org/openal-binaries/openal-soft-" + version + "-bin.zip", packagePath);
using (ZipArchive archive = ZipFile.Open(packagePath, ZipArchiveMode.Read)) using (ZipArchive archive = ZipFile.Open(packagePath, ZipArchiveMode.Read))
{ {
if (!Directory.Exists(root)) if (!Directory.Exists(root))
archive.ExtractToDirectory(root); archive.ExtractToDirectory(root);
root = Path.Combine(root, archive.Entries.First().FullName); root = Path.Combine(root, archive.Entries.First().FullName);
} }
// Deploy Win64 binaries // Deploy Win64 binaries
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64); var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
Utilities.FileCopy(Path.Combine(root, "bin", "Win64", "soft_oal.dll"), Path.Combine(depsFolder, "OpenAL32.dll")); Utilities.FileCopy(Path.Combine(root, "bin", "Win64", "soft_oal.dll"), Path.Combine(depsFolder, "OpenAL32.dll"));
Utilities.FileCopy(Path.Combine(root, "libs", "Win64", "OpenAL32.lib"), Path.Combine(depsFolder, "OpenAL32.lib")); Utilities.FileCopy(Path.Combine(root, "libs", "Win64", "OpenAL32.lib"), Path.Combine(depsFolder, "OpenAL32.lib"));
// Deploy license // Deploy license
Utilities.FileCopy(Path.Combine(root, "COPYING"), Path.Combine(dstIncludePath, "COPYING"), true); Utilities.FileCopy(Path.Combine(root, "COPYING"), Path.Combine(dstIncludePath, "COPYING"), true);
// Deploy header files // Deploy header files
var files = Directory.GetFiles(Path.Combine(root, "include", "AL")); var files = Directory.GetFiles(Path.Combine(root, "include", "AL"));
foreach (var file in files) foreach (var file in files)
{ {
Utilities.FileCopy(file, Path.Combine(dstIncludePath, Path.GetFileName(file))); Utilities.FileCopy(file, Path.Combine(dstIncludePath, Path.GetFileName(file)));
} }
#endif #endif
break; break;
}
case TargetPlatform.Linux:
{
var binariesToCopy = new[]
{
"libopenal.a",
};
var envVars = new Dictionary<string, string>
{
{ "CC", "clang-" + Configuration.LinuxClangMinVer },
{ "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer },
{ "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel },
};
var config = $"-DALSOFT_REQUIRE_ALSA=ON " +
$"-DALSOFT_REQUIRE_OSS=ON " +
$"-DALSOFT_REQUIRE_PORTAUDIO=ON " +
$"-DALSOFT_REQUIRE_PULSEAUDIO=ON " +
$"-DALSOFT_REQUIRE_JACK=ON " +
$"-DALSOFT_REQUIRE_PIPEWIRE=ON " +
$"-DALSOFT_EMBED_HRTF_DATA=YES "
+ cmakeArgs;
// Get the source
var packagePath = Path.Combine(root, "package.zip");
File.Delete(packagePath);
Downloader.DownloadFileFromUrlToPath("https://openal-soft.org/openal-releases/openal-soft-" + version + ".tar.bz2", packagePath);
Utilities.Run("tar", "xjf " + packagePath.Replace('\\', '/'), null, root, Utilities.RunOptions.ConsoleLogOutput);
// Use separate build directory
root = Path.Combine(root, "openal-soft-" + version);
var buildDir = Path.Combine(root, "build");
SetupDirectory(buildDir, true);
// Build for Linux
Utilities.Run("cmake", $"-G \"Unix Makefiles\" -DCMAKE_BUILD_TYPE={configuration} -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DLIBTYPE=STATIC {config} ..", null, buildDir, Utilities.RunOptions.ConsoleLogOutput, envVars);
BuildCmake(buildDir, configuration, envVars);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
foreach (var file in binariesToCopy)
Utilities.FileCopy(Path.Combine(buildDir, file), Path.Combine(depsFolder, file));
break;
}
case TargetPlatform.Android:
{
var binariesToCopy = new[]
{
"libopenal.a",
};
var envVars = new Dictionary<string, string>
{
{ "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel },
};
var config = " -DALSOFT_REQUIRE_OBOE=OFF -DALSOFT_REQUIRE_OPENSL=ON -DALSOFT_EMBED_HRTF_DATA=YES " + cmakeArgs;
// Get the source
var packagePath = Path.Combine(root, "package.zip");
File.Delete(packagePath);
Downloader.DownloadFileFromUrlToPath("https://openal-soft.org/openal-releases/openal-soft-" + version + ".tar.bz2", packagePath);
if (Platform.BuildTargetPlatform == TargetPlatform.Windows)
{
var sevenZip = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "7-Zip", "7z.exe");
Utilities.Run(sevenZip, "x package.zip", null, root);
Utilities.Run(sevenZip, "x package", null, root);
} }
else case TargetPlatform.Linux:
{ {
Utilities.Run("tar", "xjf " + packagePath.Replace('\\', '/'), null, root, Utilities.RunOptions.ConsoleLogOutput); var binariesToCopy = new[]
{
"libopenal.a",
};
var envVars = new Dictionary<string, string>
{
{ "CC", "clang-" + Configuration.LinuxClangMinVer },
{ "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer },
{ "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel },
};
var config = $"-DALSOFT_REQUIRE_ALSA=ON " +
$"-DALSOFT_REQUIRE_OSS=ON " +
$"-DALSOFT_REQUIRE_PORTAUDIO=ON " +
$"-DALSOFT_REQUIRE_PULSEAUDIO=ON " +
$"-DALSOFT_REQUIRE_JACK=ON " +
$"-DALSOFT_REQUIRE_PIPEWIRE=ON " +
$"-DALSOFT_EMBED_HRTF_DATA=YES "
+ cmakeArgs;
// Use separate build directory
root = Path.Combine(root, "openal-soft-" + version);
var buildDir = Path.Combine(root, "build");
SetupDirectory(buildDir, true);
// Build for Linux
Utilities.Run("cmake", $"-G \"Unix Makefiles\" -DCMAKE_BUILD_TYPE={configuration} -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DLIBTYPE=STATIC {config} ..", null, buildDir, Utilities.RunOptions.ConsoleLogOutput, envVars);
BuildCmake(buildDir, configuration, envVars);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
foreach (var file in binariesToCopy)
Utilities.FileCopy(Path.Combine(buildDir, file), Path.Combine(depsFolder, file));
break;
} }
case TargetPlatform.Android:
// Use separate build directory
root = Path.Combine(root, "openal-soft-" + version);
var buildDir = Path.Combine(root, "build");
SetupDirectory(buildDir, true);
// Build
RunCmake(buildDir, platform, TargetArchitecture.ARM64, ".. -DLIBTYPE=STATIC -DCMAKE_BUILD_TYPE=" + configuration + config, envVars);
BuildCmake(buildDir, envVars);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64);
foreach (var file in binariesToCopy)
Utilities.FileCopy(Path.Combine(buildDir, file), Path.Combine(depsFolder, file));
break;
}
case TargetPlatform.Mac:
{
var binariesToCopy = new[]
{ {
"libopenal.a", var binariesToCopy = new[]
}; {
var envVars = new Dictionary<string, string> "libopenal.a",
};
var envVars = new Dictionary<string, string>
{
{ "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel },
};
var config = "-DALSOFT_REQUIRE_OBOE=OFF -DALSOFT_REQUIRE_OPENSL=ON -DALSOFT_EMBED_HRTF_DATA=YES " + cmakeArgs;
// Use separate build directory
root = Path.Combine(root, "openal-soft-" + version);
var buildDir = Path.Combine(root, "build");
SetupDirectory(buildDir, true);
// Build
RunCmake(buildDir, platform, TargetArchitecture.ARM64, ".. -DLIBTYPE=STATIC -DCMAKE_BUILD_TYPE=" + configuration + config, envVars);
BuildCmake(buildDir, envVars);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64);
foreach (var file in binariesToCopy)
Utilities.FileCopy(Path.Combine(buildDir, file), Path.Combine(depsFolder, file));
break;
}
case TargetPlatform.Mac:
{ {
{ "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel }, var binariesToCopy = new[]
}; {
var config = " -DALSOFT_REQUIRE_COREAUDIO=ON -DALSOFT_EMBED_HRTF_DATA=YES " + cmakeArgs; "libopenal.a",
};
var envVars = new Dictionary<string, string>
{
{ "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel },
};
var config = " -DALSOFT_REQUIRE_COREAUDIO=ON -DALSOFT_EMBED_HRTF_DATA=YES " + cmakeArgs;
// Get the source // Use separate build directory
var packagePath = Path.Combine(root, "package.zip"); root = Path.Combine(root, "openal-soft-" + version);
File.Delete(packagePath); var buildDir = Path.Combine(root, "build");
Downloader.DownloadFileFromUrlToPath("https://openal-soft.org/openal-releases/openal-soft-" + version + ".tar.bz2", packagePath);
Utilities.Run("tar", "xjf " + packagePath.Replace('\\', '/'), null, root, Utilities.RunOptions.ConsoleLogOutput);
// Use separate build directory // Build for Mac
root = Path.Combine(root, "openal-soft-" + version);
var buildDir = Path.Combine(root, "build");
// Build for Mac
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{
SetupDirectory(buildDir, true); SetupDirectory(buildDir, true);
RunCmake(buildDir, platform, architecture, ".. -DLIBTYPE=STATIC -DCMAKE_BUILD_TYPE=" + configuration + config, envVars); RunCmake(buildDir, platform, architecture, ".. -DLIBTYPE=STATIC -DCMAKE_BUILD_TYPE=" + configuration + config, envVars);
BuildCmake(buildDir, envVars); BuildCmake(buildDir, envVars);
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in binariesToCopy) foreach (var file in binariesToCopy)
Utilities.FileCopy(Path.Combine(buildDir, file), Path.Combine(depsFolder, file)); Utilities.FileCopy(Path.Combine(buildDir, file), Path.Combine(depsFolder, file));
break;
} }
break; case TargetPlatform.iOS:
}
case TargetPlatform.iOS:
{
var binariesToCopy = new[]
{ {
"libopenal.a", var binariesToCopy = new[]
}; {
var envVars = new Dictionary<string, string> "libopenal.a",
{ };
{ "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel }, var envVars = new Dictionary<string, string>
}; {
var config = " -DALSOFT_REQUIRE_COREAUDIO=ON -DALSOFT_EMBED_HRTF_DATA=YES " + cmakeArgs; { "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel },
};
var config = " -DALSOFT_REQUIRE_COREAUDIO=ON -DALSOFT_EMBED_HRTF_DATA=YES " + cmakeArgs;
// Get the source // Use separate build directory
var packagePath = Path.Combine(root, "package.zip"); root = Path.Combine(root, "openal-soft-" + version);
if (!File.Exists(packagePath)) var buildDir = Path.Combine(root, "build");
{
Downloader.DownloadFileFromUrlToPath("https://openal-soft.org/openal-releases/openal-soft-" + version + ".tar.bz2", packagePath); // Build for iOS
Utilities.Run("tar", "xjf " + packagePath.Replace('\\', '/'), null, root, Utilities.RunOptions.ConsoleLogOutput); SetupDirectory(buildDir, true);
RunCmake(buildDir, platform, TargetArchitecture.ARM64, ".. -DCMAKE_SYSTEM_NAME=iOS -DALSOFT_OSX_FRAMEWORK=ON -DLIBTYPE=STATIC -DCMAKE_BUILD_TYPE=" + configuration + config, envVars);
BuildCmake(buildDir, envVars);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64);
foreach (var file in binariesToCopy)
Utilities.FileCopy(Path.Combine(buildDir, file), Path.Combine(depsFolder, file));
break;
}
} }
// Use separate build directory
root = Path.Combine(root, "openal-soft-" + version);
var buildDir = Path.Combine(root, "build");
// Build for iOS
SetupDirectory(buildDir, true);
RunCmake(buildDir, platform, TargetArchitecture.ARM64, ".. -DCMAKE_SYSTEM_NAME=iOS -DALSOFT_OSX_FRAMEWORK=ON -DLIBTYPE=STATIC -DCMAKE_BUILD_TYPE=" + configuration + config, envVars);
BuildCmake(buildDir, envVars);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64);
foreach (var file in binariesToCopy)
Utilities.FileCopy(Path.Combine(buildDir, file), Path.Combine(depsFolder, file));
break;
}
} }
} }
} }

158
Source/Tools/Flax.Build/Deps/Dependencies/PhysX.cs
View File

@@ -51,6 +51,36 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
private string root; private string root;
private string projectGenDir; private string projectGenDir;
private string projectGenPath; private string projectGenPath;
@@ -374,69 +404,79 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{ switch (platform)
try
{ {
Build(options, "vc18win64", platform, architecture); case TargetPlatform.Windows:
Build(options, "vc18win-arm64", platform, architecture);
}
catch
{ {
Log.Verbose("Failed to generate VS2026 solution for PhysX, fallback to VS2022"); if (architecture == TargetArchitecture.x64 || architecture == TargetArchitecture.ARM64)
Build(options, "vc17win64", platform, architecture); {
Build(options, "vc17win-arm64", platform, architecture); try
{
Build(options, architecture == TargetArchitecture.x64 ? "vc18win64" : "vc18win-arm64", platform, architecture);
}
catch
{
Log.Verbose("Failed to generate VS2026 solution for PhysX, fallback to VS2022");
Build(options, architecture == TargetArchitecture.x64 ? "vc17win64" : "vc17win-arm64", platform, architecture);
}
}
else
throw new InvalidArchitectureException(architecture);
break;
}
case TargetPlatform.Linux:
{
Build(options, "linux", platform, architecture);
break;
}
case TargetPlatform.PS4:
{
Utilities.DirectoryCopy(Path.Combine(GetBinariesFolder(options, platform), "Data", "PhysX"), root, true, true);
Build(options, "ps4", platform, TargetArchitecture.x64);
break;
}
case TargetPlatform.PS5:
{
Utilities.DirectoryCopy(Path.Combine(GetBinariesFolder(options, platform), "Data", "PhysX"), root, true, true);
Build(options, "ps5", platform, TargetArchitecture.x64);
break;
}
case TargetPlatform.XboxScarlett:
case TargetPlatform.XboxOne:
{
Build(options, "vc16win64", platform, TargetArchitecture.x64);
break;
}
case TargetPlatform.Android:
{
Build(options, "android", platform, TargetArchitecture.ARM64);
break;
}
case TargetPlatform.Switch:
{
Utilities.DirectoryCopy(Path.Combine(GetBinariesFolder(options, platform), "Data", "PhysX"), root, true, true);
Build(options, "switch64", platform, TargetArchitecture.ARM64);
break;
}
case TargetPlatform.Mac:
{
if (architecture == TargetArchitecture.x64)
Build(options, "mac64", platform, architecture);
else if (architecture == TargetArchitecture.ARM64)
Build(options, "mac-arm64", platform, architecture);
else
throw new InvalidArchitectureException(architecture);
break;
}
case TargetPlatform.iOS:
{
Build(options, "ios64", platform, TargetArchitecture.ARM64);
break;
}
} }
break;
}
case TargetPlatform.Linux:
{
Build(options, "linux", platform, TargetArchitecture.x64);
break;
}
case TargetPlatform.PS4:
{
Utilities.DirectoryCopy(Path.Combine(GetBinariesFolder(options, platform), "Data", "PhysX"), root, true, true);
Build(options, "ps4", platform, TargetArchitecture.x64);
break;
}
case TargetPlatform.PS5:
{
Utilities.DirectoryCopy(Path.Combine(GetBinariesFolder(options, platform), "Data", "PhysX"), root, true, true);
Build(options, "ps5", platform, TargetArchitecture.x64);
break;
}
case TargetPlatform.XboxScarlett:
case TargetPlatform.XboxOne:
{
Build(options, "vc16win64", platform, TargetArchitecture.x64);
break;
}
case TargetPlatform.Android:
{
Build(options, "android", platform, TargetArchitecture.ARM64);
break;
}
case TargetPlatform.Switch:
{
Utilities.DirectoryCopy(Path.Combine(GetBinariesFolder(options, platform), "Data", "PhysX"), root, true, true);
Build(options, "switch64", platform, TargetArchitecture.ARM64);
break;
}
case TargetPlatform.Mac:
{
Build(options, "mac64", platform, TargetArchitecture.x64);
Build(options, "mac-arm64", platform, TargetArchitecture.ARM64);
break;
}
case TargetPlatform.iOS:
{
Build(options, "ios64", platform, TargetArchitecture.ARM64);
break;
}
} }
} }

60
Source/Tools/Flax.Build/Deps/Dependencies/SDL.cs
View File

@@ -43,6 +43,36 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -94,12 +124,12 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{ switch (platform)
foreach (var architecture in new TargetArchitecture[] { TargetArchitecture.x64/*, TargetArchitecture.ARM64*/ }) {
case TargetPlatform.Windows:
{ {
var buildDir = Path.Combine(root, "build-" + architecture.ToString()); var buildDir = Path.Combine(root, "build-" + architecture.ToString());
@@ -109,7 +139,7 @@ namespace Flax.Deps.Dependencies
else else
binariesToCopy = new[] { "SDL3.dll", "SDL3.lib", }; binariesToCopy = new[] { "SDL3.dll", "SDL3.lib", };
directoriesToCopy.Add(Path.Combine(buildDir, "include", "SDL3")); directoriesToCopy.Add(Path.Combine(buildDir, "include", "SDL3"));
var solutionPath = Path.Combine(buildDir, "SDL3.sln"); var solutionPath = Path.Combine(buildDir, "SDL3.sln");
RunCmake(root, platform, architecture, $"-B\"{buildDir}\" -DCMAKE_INSTALL_PREFIX=\"{buildDir}\" -DSDL_SHARED={(!buildStatic ? "ON" : "OFF")} -DSDL_STATIC={(buildStatic ? "ON" : "OFF")} -DCMAKE_POLICY_DEFAULT_CMP0091=NEW -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDLL " + string.Join(" ", configs)); RunCmake(root, platform, architecture, $"-B\"{buildDir}\" -DCMAKE_INSTALL_PREFIX=\"{buildDir}\" -DSDL_SHARED={(!buildStatic ? "ON" : "OFF")} -DSDL_STATIC={(buildStatic ? "ON" : "OFF")} -DCMAKE_POLICY_DEFAULT_CMP0091=NEW -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDLL " + string.Join(" ", configs));
@@ -120,16 +150,14 @@ namespace Flax.Deps.Dependencies
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in binariesToCopy) foreach (var file in binariesToCopy)
Utilities.FileCopy(Path.Combine(buildDir, configuration, file), Path.Combine(depsFolder, file == "SDL3-static.lib" ? "SDL3.lib" : file)); Utilities.FileCopy(Path.Combine(buildDir, configuration, file), Path.Combine(depsFolder, file == "SDL3-static.lib" ? "SDL3.lib" : file));
break;
} }
break; case TargetPlatform.Linux:
} case TargetPlatform.Mac:
case TargetPlatform.Linux:
case TargetPlatform.Mac:
{
foreach (var architecture in new [] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{ {
var buildDir = Path.Combine(root, "build-" + architecture.ToString()); var buildDir = Path.Combine(root, "build-" + architecture.ToString());
string[] binariesToCopy; string[] binariesToCopy;
if (buildStatic) if (buildStatic)
binariesToCopy = new[] { "libSDL3.a" }; binariesToCopy = new[] { "libSDL3.a" };
@@ -139,16 +167,16 @@ namespace Flax.Deps.Dependencies
int concurrency = Math.Min(Math.Max(1, (int)(Environment.ProcessorCount * Configuration.ConcurrencyProcessorScale)), Configuration.MaxConcurrency); int concurrency = Math.Min(Math.Max(1, (int)(Environment.ProcessorCount * Configuration.ConcurrencyProcessorScale)), Configuration.MaxConcurrency);
RunCmake(root, platform, architecture, $"-B\"{buildDir}\" -DCMAKE_BUILD_TYPE={configuration} -DCMAKE_INSTALL_PREFIX=\"{buildDir}\" -DSDL_SHARED={(!buildStatic ? "ON" : "OFF")} -DSDL_STATIC={(buildStatic ? "ON" : "OFF")} -DCMAKE_POSITION_INDEPENDENT_CODE=ON " + string.Join(" ", configs)); RunCmake(root, platform, architecture, $"-B\"{buildDir}\" -DCMAKE_BUILD_TYPE={configuration} -DCMAKE_INSTALL_PREFIX=\"{buildDir}\" -DSDL_SHARED={(!buildStatic ? "ON" : "OFF")} -DSDL_STATIC={(buildStatic ? "ON" : "OFF")} -DCMAKE_POSITION_INDEPENDENT_CODE=ON " + string.Join(" ", configs));
BuildCmake(buildDir, configuration, new Dictionary<string, string>() { {"CMAKE_BUILD_PARALLEL_LEVEL", concurrency.ToString()} }); BuildCmake(buildDir, configuration, new Dictionary<string, string>() { { "CMAKE_BUILD_PARALLEL_LEVEL", concurrency.ToString() } });
Utilities.Run("cmake", $"--build . --target install --config {configuration}", null, buildDir, Utilities.RunOptions.DefaultTool); Utilities.Run("cmake", $"--build . --target install --config {configuration}", null, buildDir, Utilities.RunOptions.DefaultTool);
// Copy binaries // Copy binaries
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in binariesToCopy) foreach (var file in binariesToCopy)
Utilities.FileCopy(Path.Combine(buildDir, file), Path.Combine(depsFolder, file)); Utilities.FileCopy(Path.Combine(buildDir, file), Path.Combine(depsFolder, file));
break;
}
} }
break;
}
} }
} }

46
Source/Tools/Flax.Build/Deps/Dependencies/UVAtlas.cs
View File

@@ -29,6 +29,36 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -47,23 +77,23 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{ switch (platform)
// Build for Win64
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{ {
case TargetPlatform.Windows:
{
// Build for Windows
Deploy.VCEnvironment.BuildSolution(solutionPath, configuration, architecture.ToString(), new Dictionary<string, string>() { { "RestorePackagesConfig", "true" } }); Deploy.VCEnvironment.BuildSolution(solutionPath, configuration, architecture.ToString(), new Dictionary<string, string>() { { "RestorePackagesConfig", "true" } });
var depsFolder = GetThirdPartyFolder(options, TargetPlatform.Windows, architecture); var depsFolder = GetThirdPartyFolder(options, TargetPlatform.Windows, architecture);
foreach (var file in outputFileNames) foreach (var file in outputFileNames)
{ {
Utilities.FileCopy(Path.Combine(binFolder, architecture.ToString(), "Release", file), Path.Combine(depsFolder, file)); Utilities.FileCopy(Path.Combine(binFolder, architecture.ToString(), "Release", file), Path.Combine(depsFolder, file));
} }
break;
}
} }
break;
}
} }
} }

20
Source/Tools/Flax.Build/Deps/Dependencies/Wayland.cs
View File

@@ -29,6 +29,24 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -38,7 +56,7 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); BuildStarted(platform, TargetArchitecture.AnyCPU);
switch (platform) switch (platform)
{ {
case TargetPlatform.Linux: case TargetPlatform.Linux:

38
Source/Tools/Flax.Build/Deps/Dependencies/astc.cs
View File

@@ -34,6 +34,30 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -45,12 +69,12 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
switch (platform)
foreach (var architecture in new []{ TargetArchitecture.x64, TargetArchitecture.ARM64 }) {
case TargetPlatform.Windows:
{ {
string buildDir = Path.Combine(root, "build-" + architecture.ToString()); string buildDir = Path.Combine(root, "build-" + architecture.ToString());
var isa = architecture == TargetArchitecture.ARM64 ? "-DASTCENC_ISA_NEON=ON" : "-DASTCENC_ISA_SSE2=ON"; var isa = architecture == TargetArchitecture.ARM64 ? "-DASTCENC_ISA_NEON=ON" : "-DASTCENC_ISA_SSE2=ON";
@@ -62,8 +86,7 @@ namespace Flax.Deps.Dependencies
Utilities.FileCopy(Path.Combine(buildDir, "Source/Release", lib), Path.Combine(depsFolder, "astcenc.lib")); Utilities.FileCopy(Path.Combine(buildDir, "Source/Release", lib), Path.Combine(depsFolder, "astcenc.lib"));
} }
break; break;
case TargetPlatform.Mac: case TargetPlatform.Mac:
foreach (var architecture in new []{ TargetArchitecture.x64, TargetArchitecture.ARM64 })
{ {
string buildDir = Path.Combine(root, "build-" + architecture.ToString()); string buildDir = Path.Combine(root, "build-" + architecture.ToString());
var isa = architecture == TargetArchitecture.ARM64 ? "-DASTCENC_ISA_NEON=ON" : "-DASTCENC_ISA_SSE2=ON"; var isa = architecture == TargetArchitecture.ARM64 ? "-DASTCENC_ISA_NEON=ON" : "-DASTCENC_ISA_SSE2=ON";
@@ -75,6 +98,7 @@ namespace Flax.Deps.Dependencies
Utilities.FileCopy(Path.Combine(buildDir, "Source", lib), Path.Combine(depsFolder, "libastcenc.a")); Utilities.FileCopy(Path.Combine(buildDir, "Source", lib), Path.Combine(depsFolder, "libastcenc.a"));
} }
break; break;
}
} }
} }

138
Source/Tools/Flax.Build/Deps/Dependencies/curl.cs
View File

@@ -41,6 +41,36 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -69,14 +99,14 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{ switch (platform)
// Build for Win64 and ARM64
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{ {
case TargetPlatform.Windows:
{
// Build for Windows
var buildDir = Path.Combine(root, "build-" + architecture.ToString()); var buildDir = Path.Combine(root, "build-" + architecture.ToString());
var solutionPath = Path.Combine(buildDir, "CURL.sln"); var solutionPath = Path.Combine(buildDir, "CURL.sln");
@@ -85,56 +115,54 @@ namespace Flax.Deps.Dependencies
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in binariesToCopyWin) foreach (var file in binariesToCopyWin)
Utilities.FileCopy(Path.Combine(buildDir, "lib", configuration, file), Path.Combine(depsFolder, Path.GetFileName(file))); Utilities.FileCopy(Path.Combine(buildDir, "lib", configuration, file), Path.Combine(depsFolder, Path.GetFileName(file)));
break;
} }
break; case TargetPlatform.Linux:
}
case TargetPlatform.Linux:
{
// Build for Linux
var settings = new[]
{ {
"--without-librtmp", // Build for Linux
"--without-ssl", var settings = new[]
"--with-gnutls", {
"--disable-ipv6", "--without-librtmp",
"--disable-manual", "--without-ssl",
"--disable-verbose", "--with-gnutls",
"--disable-shared", "--disable-ipv6",
"--enable-static", "--disable-manual",
"-disable-ldap --disable-sspi --disable-ftp --disable-file --disable-dict --disable-telnet --disable-tftp --disable-rtsp --disable-pop3 --disable-imap --disable-smtp --disable-gopher --disable-smb", "--disable-verbose",
}; "--disable-shared",
var envVars = new Dictionary<string, string> "--enable-static",
{ "-disable-ldap --disable-sspi --disable-ftp --disable-file --disable-dict --disable-telnet --disable-tftp --disable-rtsp --disable-pop3 --disable-imap --disable-smtp --disable-gopher --disable-smb",
{ "CC", "clang-" + Configuration.LinuxClangMinVer }, };
{ "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer }, var envVars = new Dictionary<string, string>
}; {
var buildDir = Path.Combine(root, "build"); { "CC", "clang-" + Configuration.LinuxClangMinVer },
SetupDirectory(buildDir, true); { "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer },
Utilities.Run("chmod", "+x configure", null, root, Utilities.RunOptions.ThrowExceptionOnError); };
Utilities.Run(Path.Combine(root, "configure"), string.Join(" ", settings) + " --prefix=\"" + buildDir + "\"", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars); var buildDir = Path.Combine(root, "build");
Utilities.Run("make", null, null, root, Utilities.RunOptions.ThrowExceptionOnError); SetupDirectory(buildDir, true);
Utilities.Run("make", "install", null, root, Utilities.RunOptions.ThrowExceptionOnError); Utilities.Run("chmod", "+x configure", null, root, Utilities.RunOptions.ThrowExceptionOnError);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64); Utilities.Run(Path.Combine(root, "configure"), string.Join(" ", settings) + " --prefix=\"" + buildDir + "\"", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
var filename = "libcurl.a"; Utilities.Run("make", null, null, root, Utilities.RunOptions.ThrowExceptionOnError);
Utilities.FileCopy(Path.Combine(buildDir, "lib", filename), Path.Combine(depsFolder, filename)); Utilities.Run("make", "install", null, root, Utilities.RunOptions.ThrowExceptionOnError);
break; var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
} var filename = "libcurl.a";
case TargetPlatform.Mac: Utilities.FileCopy(Path.Combine(buildDir, "lib", filename), Path.Combine(depsFolder, filename));
{ break;
// Build for Mac }
var settings = new[] case TargetPlatform.Mac:
{
"--with-secure-transport",
"--without-librtmp",
"--disable-ipv6",
"--disable-manual",
"--disable-verbose",
"--disable-shared",
"--enable-static",
"-disable-ldap --disable-sspi --disable-ftp --disable-file --disable-dict --disable-telnet --disable-tftp --disable-rtsp --disable-pop3 --disable-imap --disable-smtp --disable-gopher --disable-smb",
};
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{ {
// Build for Mac
var settings = new[]
{
"--with-secure-transport",
"--without-librtmp",
"--disable-ipv6",
"--disable-manual",
"--disable-verbose",
"--disable-shared",
"--enable-static",
"-disable-ldap --disable-sspi --disable-ftp --disable-file --disable-dict --disable-telnet --disable-tftp --disable-rtsp --disable-pop3 --disable-imap --disable-smtp --disable-gopher --disable-smb",
};
var arch = GetAppleArchName(architecture); var arch = GetAppleArchName(architecture);
var archName = arch + "-apple-darwin19"; var archName = arch + "-apple-darwin19";
if (architecture == TargetArchitecture.ARM64) if (architecture == TargetArchitecture.ARM64)
@@ -161,9 +189,9 @@ namespace Flax.Deps.Dependencies
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
var filename = "libcurl.a"; var filename = "libcurl.a";
Utilities.FileCopy(Path.Combine(buildDir, "lib", filename), Path.Combine(depsFolder, filename)); Utilities.FileCopy(Path.Combine(buildDir, "lib", filename), Path.Combine(depsFolder, filename));
break;
}
} }
break;
}
} }
} }

34
Source/Tools/Flax.Build/Deps/Dependencies/dbghelp.cs
View File

@@ -30,27 +30,45 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{ switch (platform)
var sdk = WindowsPlatformBase.GetSDKs().Last();
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{ {
case TargetPlatform.Windows:
{
var sdk = WindowsPlatformBase.GetSDKs().Last();
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
var libLocation = @$"{sdk.Value}Debuggers\lib\{architecture}\dbghelp.lib"; var libLocation = @$"{sdk.Value}Debuggers\lib\{architecture}\dbghelp.lib";
var dllLocation = @$"{sdk.Value}Debuggers\{architecture}\dbghelp.dll"; var dllLocation = @$"{sdk.Value}Debuggers\{architecture}\dbghelp.dll";
Utilities.FileCopy(libLocation, Path.Combine(depsFolder, Path.GetFileName(libLocation))); Utilities.FileCopy(libLocation, Path.Combine(depsFolder, Path.GetFileName(libLocation)));
Utilities.FileCopy(dllLocation, Path.Combine(depsFolder, Path.GetFileName(dllLocation))); Utilities.FileCopy(dllLocation, Path.Combine(depsFolder, Path.GetFileName(dllLocation)));
break;
}
} }
break;
}
} }
} }
} }

308
Source/Tools/Flax.Build/Deps/Dependencies/freetype.cs
View File

@@ -49,6 +49,36 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -94,168 +124,164 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{ switch (platform)
// Patch the RuntimeLibrary value
File.WriteAllText(vcxprojPath, vcxprojContents);
// Build for Windows
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{ {
case TargetPlatform.Windows:
{
// Patch the RuntimeLibrary value
File.WriteAllText(vcxprojPath, vcxprojContents);
// Build for Windows
Deploy.VCEnvironment.BuildSolution(vsSolutionPath, configurationMsvc, architecture.ToString(), msvcProps); Deploy.VCEnvironment.BuildSolution(vsSolutionPath, configurationMsvc, architecture.ToString(), msvcProps);
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var filename in binariesToCopyMsvc) foreach (var filename in binariesToCopyMsvc)
Utilities.FileCopy(Path.Combine(root, "objs", architecture.ToString(), configurationMsvc, filename), Path.Combine(depsFolder, filename)); Utilities.FileCopy(Path.Combine(root, "objs", architecture.ToString(), configurationMsvc, filename), Path.Combine(depsFolder, filename));
break;
} }
break; case TargetPlatform.Linux:
}
case TargetPlatform.Linux:
{
var envVars = new Dictionary<string, string>
{ {
{ "CC", "clang-" + Configuration.LinuxClangMinVer }, var envVars = new Dictionary<string, string>
{ "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer } {
}; { "CC", "clang-" + Configuration.LinuxClangMinVer },
{ "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer }
};
// Fix scripts // Fix scripts
Utilities.Run("sed", "-i -e \'s/\r$//\' autogen.sh", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars); Utilities.Run("sed", "-i -e \'s/\r$//\' autogen.sh", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
Utilities.Run("sed", "-i -e \'s/\r$//\' configure", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars); Utilities.Run("sed", "-i -e \'s/\r$//\' configure", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
Utilities.Run("chmod", "+x autogen.sh", null, root, Utilities.RunOptions.ThrowExceptionOnError); Utilities.Run("chmod", "+x autogen.sh", null, root, Utilities.RunOptions.ThrowExceptionOnError);
Utilities.Run("chmod", "+x configure", null, root, Utilities.RunOptions.ThrowExceptionOnError); Utilities.Run("chmod", "+x configure", null, root, Utilities.RunOptions.ThrowExceptionOnError);
Utilities.Run(Path.Combine(root, "autogen.sh"), null, null, root, Utilities.RunOptions.Default, envVars); Utilities.Run(Path.Combine(root, "autogen.sh"), null, null, root, Utilities.RunOptions.Default, envVars);
// Disable using libpng even if it's found on the system // Disable using libpng even if it's found on the system
var cmakeFile = Path.Combine(root, "CMakeLists.txt"); var cmakeFile = Path.Combine(root, "CMakeLists.txt");
File.WriteAllText(cmakeFile, File.WriteAllText(cmakeFile,
File.ReadAllText(cmakeFile) File.ReadAllText(cmakeFile)
.Replace("find_package(PNG)", "") .Replace("find_package(PNG)", "")
.Replace("find_package(ZLIB)", "") .Replace("find_package(ZLIB)", "")
.Replace("find_package(BZip2)", "") .Replace("find_package(BZip2)", "")
); );
// Build for Linux // Build for Linux
SetupDirectory(buildDir, true); SetupDirectory(buildDir, true);
var toolchain = UnixToolchain.GetToolchainName(platform, TargetArchitecture.x64); var toolchain = UnixToolchain.GetToolchainName(platform, architecture);
Utilities.Run("cmake", string.Format("-G \"Unix Makefiles\" -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DFT_WITH_BZIP2=OFF -DFT_WITH_ZLIB=OFF -DFT_WITH_PNG=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER_TARGET={0} ..", toolchain), null, buildDir, Utilities.RunOptions.ThrowExceptionOnError, envVars); Utilities.Run("cmake", string.Format("-G \"Unix Makefiles\" -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DFT_WITH_BZIP2=OFF -DFT_WITH_ZLIB=OFF -DFT_WITH_PNG=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER_TARGET={0} ..", toolchain), null, buildDir, Utilities.RunOptions.ThrowExceptionOnError, envVars);
Utilities.Run("cmake", "--build .", null, buildDir, Utilities.RunOptions.ThrowExceptionOnError, envVars); Utilities.Run("cmake", "--build .", null, buildDir, Utilities.RunOptions.ThrowExceptionOnError, envVars);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
Utilities.FileCopy(Path.Combine(buildDir, libraryFileName), Path.Combine(depsFolder, libraryFileName)); Utilities.FileCopy(Path.Combine(buildDir, libraryFileName), Path.Combine(depsFolder, libraryFileName));
break;
break; }
} case TargetPlatform.PS4:
case TargetPlatform.PS4:
{
// Get the build data files
Utilities.DirectoryCopy(
Path.Combine(GetBinariesFolder(options, platform), "Data", "freetype"),
Path.Combine(root, "builds", "PS4"), false, true);
// Build for PS4
var solutionPath = Path.Combine(root, "builds", "PS4", "freetype.sln");
Deploy.VCEnvironment.BuildSolution(solutionPath, "Release", "ORBIS");
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
Utilities.FileCopy(Path.Combine(root, "lib", "PS4", libraryFileName), Path.Combine(depsFolder, libraryFileName));
break;
}
case TargetPlatform.PS5:
{
// Get the build data files
Utilities.DirectoryCopy(
Path.Combine(GetBinariesFolder(options, platform), "Data", "freetype"),
Path.Combine(root, "builds", "PS5"), false, true);
Utilities.ReplaceInFile(Path.Combine(root, "include\\freetype\\config\\ftstdlib.h"), "#define ft_getenv getenv", "char* ft_getenv(const char* n);");
// Build for PS5
var solutionPath = Path.Combine(root, "builds", "PS5", "freetype.sln");
Deploy.VCEnvironment.BuildSolution(solutionPath, "Release", "PROSPERO");
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
Utilities.FileCopy(Path.Combine(root, "lib", "PS5", libraryFileName), Path.Combine(depsFolder, libraryFileName));
break;
}
case TargetPlatform.XboxOne:
{
// Build for Xbox One x64
Deploy.VCEnvironment.BuildSolution(vsSolutionPath, configurationMsvc, "x64", msvcProps);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
foreach (var filename in binariesToCopyMsvc)
Utilities.FileCopy(Path.Combine(root, "objs", "x64", configurationMsvc, filename), Path.Combine(depsFolder, filename));
break;
}
case TargetPlatform.XboxScarlett:
{
// Build for Xbox Scarlett
Deploy.VCEnvironment.BuildSolution(vsSolutionPath, configurationMsvc, "x64", msvcProps);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
foreach (var filename in binariesToCopyMsvc)
Utilities.FileCopy(Path.Combine(root, "objs", "x64", configurationMsvc, filename), Path.Combine(depsFolder, filename));
break;
}
case TargetPlatform.Android:
{
// Disable using libpng even if it's found on the system
var cmakeFile = Path.Combine(root, "CMakeLists.txt");
File.WriteAllText(cmakeFile,
File.ReadAllText(cmakeFile)
.Replace("find_package(PNG)", "")
.Replace("find_package(ZLIB)", "")
.Replace("find_package(BZip2)", "")
);
// Build for Android
SetupDirectory(buildDir, true);
RunCmake(buildDir, TargetPlatform.Android, TargetArchitecture.ARM64, ".. -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DFT_WITH_BZIP2=OFF -DFT_WITH_ZLIB=OFF -DFT_WITH_PNG=OFF -DCMAKE_BUILD_TYPE=Release");
BuildCmake(buildDir);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64);
Utilities.FileCopy(Path.Combine(buildDir, libraryFileName), Path.Combine(depsFolder, libraryFileName));
break;
}
case TargetPlatform.Switch:
{
// Build for Switch
SetupDirectory(buildDir, true);
RunCmake(buildDir, platform, TargetArchitecture.ARM64, ".. -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_BUILD_TYPE=Release");
BuildCmake(buildDir);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64);
Utilities.FileCopy(Path.Combine(buildDir, libraryFileName), Path.Combine(depsFolder, libraryFileName));
break;
}
case TargetPlatform.Mac:
{
// Build for Mac
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{ {
// Get the build data files
Utilities.DirectoryCopy(
Path.Combine(GetBinariesFolder(options, platform), "Data", "freetype"),
Path.Combine(root, "builds", "PS4"), false, true);
// Build for PS4
var solutionPath = Path.Combine(root, "builds", "PS4", "freetype.sln");
Deploy.VCEnvironment.BuildSolution(solutionPath, "Release", "ORBIS");
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
Utilities.FileCopy(Path.Combine(root, "lib", "PS4", libraryFileName), Path.Combine(depsFolder, libraryFileName));
break;
}
case TargetPlatform.PS5:
{
// Get the build data files
Utilities.DirectoryCopy(
Path.Combine(GetBinariesFolder(options, platform), "Data", "freetype"),
Path.Combine(root, "builds", "PS5"), false, true);
Utilities.ReplaceInFile(Path.Combine(root, "include\\freetype\\config\\ftstdlib.h"), "#define ft_getenv getenv", "char* ft_getenv(const char* n);");
// Build for PS5
var solutionPath = Path.Combine(root, "builds", "PS5", "freetype.sln");
Deploy.VCEnvironment.BuildSolution(solutionPath, "Release", "PROSPERO");
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
Utilities.FileCopy(Path.Combine(root, "lib", "PS5", libraryFileName), Path.Combine(depsFolder, libraryFileName));
break;
}
case TargetPlatform.XboxOne:
{
// Build for Xbox One x64
Deploy.VCEnvironment.BuildSolution(vsSolutionPath, configurationMsvc, "x64", msvcProps);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
foreach (var filename in binariesToCopyMsvc)
Utilities.FileCopy(Path.Combine(root, "objs", "x64", configurationMsvc, filename), Path.Combine(depsFolder, filename));
break;
}
case TargetPlatform.XboxScarlett:
{
// Build for Xbox Scarlett
Deploy.VCEnvironment.BuildSolution(vsSolutionPath, configurationMsvc, "x64", msvcProps);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
foreach (var filename in binariesToCopyMsvc)
Utilities.FileCopy(Path.Combine(root, "objs", "x64", configurationMsvc, filename), Path.Combine(depsFolder, filename));
break;
}
case TargetPlatform.Android:
{
// Disable using libpng even if it's found on the system
var cmakeFile = Path.Combine(root, "CMakeLists.txt");
File.WriteAllText(cmakeFile,
File.ReadAllText(cmakeFile)
.Replace("find_package(PNG)", "")
.Replace("find_package(ZLIB)", "")
.Replace("find_package(BZip2)", "")
);
// Build for Android
SetupDirectory(buildDir, true);
RunCmake(buildDir, TargetPlatform.Android, TargetArchitecture.ARM64, ".. -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DFT_WITH_BZIP2=OFF -DFT_WITH_ZLIB=OFF -DFT_WITH_PNG=OFF -DCMAKE_BUILD_TYPE=Release");
BuildCmake(buildDir);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64);
Utilities.FileCopy(Path.Combine(buildDir, libraryFileName), Path.Combine(depsFolder, libraryFileName));
break;
}
case TargetPlatform.Switch:
{
// Build for Switch
SetupDirectory(buildDir, true);
RunCmake(buildDir, platform, TargetArchitecture.ARM64, ".. -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_BUILD_TYPE=Release");
BuildCmake(buildDir);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64);
Utilities.FileCopy(Path.Combine(buildDir, libraryFileName), Path.Combine(depsFolder, libraryFileName));
break;
}
case TargetPlatform.Mac:
{
// Build for Mac
SetupDirectory(buildDir, true); SetupDirectory(buildDir, true);
RunCmake(buildDir, platform, architecture, ".. -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_BUILD_TYPE=Release"); RunCmake(buildDir, platform, architecture, ".. -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_BUILD_TYPE=Release");
BuildCmake(buildDir); BuildCmake(buildDir);
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
Utilities.FileCopy(Path.Combine(buildDir, libraryFileName), Path.Combine(depsFolder, libraryFileName)); Utilities.FileCopy(Path.Combine(buildDir, libraryFileName), Path.Combine(depsFolder, libraryFileName));
break;
} }
break; case TargetPlatform.iOS:
} {
case TargetPlatform.iOS: // Fix archive creation issue due to missing ar tool
{ Utilities.ReplaceInFile(Path.Combine(root, "builds/cmake/iOS.cmake"), "set(CMAKE_SYSTEM_NAME Darwin)", "set(CMAKE_SYSTEM_NAME Darwin)\nset(CMAKE_AR ar CACHE FILEPATH \"\" FORCE)");
// Fix archive creation issue due to missing ar tool
Utilities.ReplaceInFile(Path.Combine(root, "builds/cmake/iOS.cmake"), "set(CMAKE_SYSTEM_NAME Darwin)", "set(CMAKE_SYSTEM_NAME Darwin)\nset(CMAKE_AR ar CACHE FILEPATH \"\" FORCE)");
// Fix freetype toolchain rejecting min iPhone version // Fix freetype toolchain rejecting min iPhone version
Utilities.ReplaceInFile(Path.Combine(root, "builds/cmake/iOS.cmake"), "set(CMAKE_OSX_DEPLOYMENT_TARGET \"\"", "set(CMAKE_OSX_DEPLOYMENT_TARGET \"${CMAKE_OSX_DEPLOYMENT_TARGET}\""); Utilities.ReplaceInFile(Path.Combine(root, "builds/cmake/iOS.cmake"), "set(CMAKE_OSX_DEPLOYMENT_TARGET \"\"", "set(CMAKE_OSX_DEPLOYMENT_TARGET \"${CMAKE_OSX_DEPLOYMENT_TARGET}\"");
// Build for iOS // Build for iOS
SetupDirectory(buildDir, true); SetupDirectory(buildDir, true);
RunCmake(buildDir, platform, TargetArchitecture.ARM64, ".. -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DIOS_PLATFORM=OS -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_BUILD_TYPE=Release -DFT_WITH_BZIP2=OFF -DFT_WITH_ZLIB=OFF -DFT_WITH_PNG=OFF"); RunCmake(buildDir, platform, TargetArchitecture.ARM64, ".. -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DIOS_PLATFORM=OS -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_BUILD_TYPE=Release -DFT_WITH_BZIP2=OFF -DFT_WITH_ZLIB=OFF -DFT_WITH_PNG=OFF");
BuildCmake(buildDir); BuildCmake(buildDir);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64); var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64);
Utilities.FileCopy(Path.Combine(buildDir, libraryFileName), Path.Combine(depsFolder, libraryFileName)); Utilities.FileCopy(Path.Combine(buildDir, libraryFileName), Path.Combine(depsFolder, libraryFileName));
break; break;
} }
}
} }
} }

171
Source/Tools/Flax.Build/Deps/Dependencies/glslang.cs
View File

@@ -38,13 +38,43 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
var root = options.IntermediateFolder; var root = options.IntermediateFolder;
var installDir = Path.Combine(root, "install"); var installDir = Path.Combine(root, "install");
var configuration = "Release"; var configuration = "Release";
var cmakeArgs = string.Format("-DCMAKE_INSTALL_PREFIX=\"{0}\" -DCMAKE_BUILD_TYPE={1} -DENABLE_RTTI=ON -DENABLE_CTEST=OFF -DENABLE_HLSL=ON -DENABLE_SPVREMAPPER=ON -DENABLE_GLSLANG_BINARIES=OFF", installDir, configuration); var cmakeArgs = $"-DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_INSTALL_PREFIX=\"{installDir}\" -DCMAKE_BUILD_TYPE={configuration} -DENABLE_RTTI=ON -DENABLE_CTEST=OFF -DENABLE_HLSL=ON -DENABLE_SPVREMAPPER=ON -DENABLE_GLSLANG_BINARIES=OFF";
var libsRoot = Path.Combine(installDir, "lib"); var libsRoot = Path.Combine(installDir, "lib");
// Get the source // Get the source
@@ -56,93 +86,88 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{
var outputFiles = new[]
{
Path.Combine(libsRoot, "GenericCodeGen.lib"),
Path.Combine(libsRoot, "MachineIndependent.lib"),
Path.Combine(libsRoot, "HLSL.lib"),
Path.Combine(libsRoot, "OSDependent.lib"),
Path.Combine(libsRoot, "OGLCompiler.lib"),
Path.Combine(libsRoot, "SPIRV-Tools-opt.lib"),
Path.Combine(libsRoot, "SPIRV-Tools.lib"),
Path.Combine(libsRoot, "SPIRV.lib"),
Path.Combine(libsRoot, "glslang.lib"),
};
// Build for Windows var buildDir = Path.Combine(root, "build-" + architecture.ToString());
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 }) switch (platform)
{ {
var buildDir = Path.Combine(root, "build-" + architecture.ToString()); case TargetPlatform.Windows:
{
var outputFiles = new[]
{
Path.Combine(libsRoot, "GenericCodeGen.lib"),
Path.Combine(libsRoot, "MachineIndependent.lib"),
Path.Combine(libsRoot, "HLSL.lib"),
Path.Combine(libsRoot, "OSDependent.lib"),
Path.Combine(libsRoot, "OGLCompiler.lib"),
Path.Combine(libsRoot, "SPIRV-Tools-opt.lib"),
Path.Combine(libsRoot, "SPIRV-Tools.lib"),
Path.Combine(libsRoot, "SPIRV.lib"),
Path.Combine(libsRoot, "glslang.lib"),
};
// Build for Windows
var solutionPath = Path.Combine(buildDir, "glslang.sln"); var solutionPath = Path.Combine(buildDir, "glslang.sln");
SetupDirectory(buildDir, false); SetupDirectory(buildDir, false);
RunCmake(root, platform, architecture, cmakeArgs + $" -B\"{buildDir}\""); RunCmake(root, platform, architecture, $"-B\"{buildDir}\" " + cmakeArgs);
Utilities.Run("cmake", string.Format("--build . --config {0} --target install", configuration), null, buildDir, Utilities.RunOptions.ConsoleLogOutput);
Deploy.VCEnvironment.BuildSolution(solutionPath, configuration, architecture.ToString()); Deploy.VCEnvironment.BuildSolution(solutionPath, configuration, architecture.ToString());
Utilities.Run("cmake", $"--build \"{buildDir}\" --config {configuration} --target install", null, buildDir, Utilities.RunOptions.ConsoleLogOutput);
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in outputFiles) foreach (var file in outputFiles)
{ {
Utilities.FileCopy(file, Path.Combine(depsFolder, Path.GetFileName(file))); Utilities.FileCopy(file, Path.Combine(depsFolder, Path.GetFileName(file)));
} }
break;
} }
break; case TargetPlatform.Linux:
}
case TargetPlatform.Linux:
{
var outputFiles = new[]
{ {
Path.Combine(libsRoot, "libGenericCodeGen.a"), var outputFiles = new[]
Path.Combine(libsRoot, "libMachineIndependent.a"), {
Path.Combine(libsRoot, "libHLSL.a"), Path.Combine(libsRoot, "libGenericCodeGen.a"),
Path.Combine(libsRoot, "libOSDependent.a"), Path.Combine(libsRoot, "libMachineIndependent.a"),
Path.Combine(libsRoot, "libOGLCompiler.a"), Path.Combine(libsRoot, "libHLSL.a"),
Path.Combine(libsRoot, "libSPIRV-Tools-opt.a"), Path.Combine(libsRoot, "libOSDependent.a"),
Path.Combine(libsRoot, "libSPIRV-Tools.a"), Path.Combine(libsRoot, "libOGLCompiler.a"),
Path.Combine(libsRoot, "libSPIRV.a"), Path.Combine(libsRoot, "libSPIRV-Tools-opt.a"),
Path.Combine(libsRoot, "libglslang.a"), Path.Combine(libsRoot, "libSPIRV-Tools.a"),
}; Path.Combine(libsRoot, "libSPIRV.a"),
var buildDir = root; Path.Combine(libsRoot, "libglslang.a"),
};
// Build for Linux // Build for Linux
RunCmake(root, platform, TargetArchitecture.x64, cmakeArgs); RunCmake(root, platform, architecture, $"-B\"{buildDir}\" " + cmakeArgs);
Utilities.Run("cmake", string.Format("--build . --config {0} --target install", configuration), null, buildDir, Utilities.RunOptions.ConsoleLogOutput); Utilities.Run("make", null, null, buildDir, Utilities.RunOptions.ConsoleLogOutput);
Utilities.Run("make", null, null, root, Utilities.RunOptions.ConsoleLogOutput); Utilities.Run("cmake", $"--build \"{buildDir}\" --config {configuration} --target install", null, buildDir, Utilities.RunOptions.ConsoleLogOutput);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in outputFiles) foreach (var file in outputFiles)
{ {
var dst = Path.Combine(depsFolder, Path.GetFileName(file)); var dst = Path.Combine(depsFolder, Path.GetFileName(file));
Utilities.FileCopy(file, dst); Utilities.FileCopy(file, dst);
//Utilities.Run("strip", string.Format("-s \"{0}\"", dst), null, null, Utilities.RunOptions.ConsoleLogOutput); //Utilities.Run("strip", string.Format("-s \"{0}\"", dst), null, null, Utilities.RunOptions.ConsoleLogOutput);
}
break;
} }
break; case TargetPlatform.Mac:
}
case TargetPlatform.Mac:
{
var outputFiles = new[]
{ {
Path.Combine(libsRoot, "libGenericCodeGen.a"), var outputFiles = new[]
Path.Combine(libsRoot, "libMachineIndependent.a"), {
Path.Combine(libsRoot, "libHLSL.a"), Path.Combine(libsRoot, "libGenericCodeGen.a"),
Path.Combine(libsRoot, "libOSDependent.a"), Path.Combine(libsRoot, "libMachineIndependent.a"),
Path.Combine(libsRoot, "libOGLCompiler.a"), Path.Combine(libsRoot, "libHLSL.a"),
Path.Combine(libsRoot, "libSPIRV-Tools-opt.a"), Path.Combine(libsRoot, "libOSDependent.a"),
Path.Combine(libsRoot, "libSPIRV-Tools.a"), Path.Combine(libsRoot, "libOGLCompiler.a"),
Path.Combine(libsRoot, "libSPIRV.a"), Path.Combine(libsRoot, "libSPIRV-Tools-opt.a"),
Path.Combine(libsRoot, "libglslang.a"), Path.Combine(libsRoot, "libSPIRV-Tools.a"),
}; Path.Combine(libsRoot, "libSPIRV.a"),
var buildDir = root; Path.Combine(libsRoot, "libglslang.a"),
};
// Build for Mac // Build for Mac
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 }) RunCmake(root, platform, architecture, $"-B\"{buildDir}\" " + cmakeArgs);
{ Utilities.Run("make", null, null, buildDir, Utilities.RunOptions.ConsoleLogOutput);
RunCmake(root, platform, architecture, cmakeArgs); Utilities.Run("cmake", $"--build \"{buildDir}\" --config {configuration} --target install", null, buildDir, Utilities.RunOptions.ConsoleLogOutput);
Utilities.Run("cmake", string.Format("--build . --config {0} --target install", configuration), null, buildDir, Utilities.RunOptions.ConsoleLogOutput);
Utilities.Run("make", null, null, root, Utilities.RunOptions.ConsoleLogOutput);
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in outputFiles) foreach (var file in outputFiles)
{ {
@@ -150,9 +175,9 @@ namespace Flax.Deps.Dependencies
Utilities.FileCopy(file, dst); Utilities.FileCopy(file, dst);
Utilities.Run("strip", string.Format("\"{0}\"", dst), null, null, Utilities.RunOptions.ConsoleLogOutput); Utilities.Run("strip", string.Format("\"{0}\"", dst), null, null, Utilities.RunOptions.ConsoleLogOutput);
} }
break;
}
} }
break;
}
} }
} }

52
Source/Tools/Flax.Build/Deps/Dependencies/libportal.cs
View File

@@ -29,6 +29,24 @@ class libportal : Dependency
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -56,12 +74,12 @@ class libportal : Dependency
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Linux: BuildStarted(platform, architecture);
{ switch (platform)
foreach (var architecture in new TargetArchitecture[] { TargetArchitecture.x64 /*, TargetArchitecture.ARM64*/ }) {
case TargetPlatform.Linux:
{ {
var buildDir = $"build_{architecture}"; var buildDir = $"build_{architecture}";
Utilities.Run("meson", $"{buildDir} {string.Join(" ", configs)}", null, root, Utilities.RunOptions.DefaultTool); Utilities.Run("meson", $"{buildDir} {string.Join(" ", configs)}", null, root, Utilities.RunOptions.DefaultTool);
@@ -71,19 +89,19 @@ class libportal : Dependency
Utilities.FileCopy(Path.Combine(root, buildDir, "libportal", "libportal.a"), Path.Combine(depsFolder, "libportal.a")); Utilities.FileCopy(Path.Combine(root, buildDir, "libportal", "libportal.a"), Path.Combine(depsFolder, "libportal.a"));
Utilities.FileCopy(Path.Combine(root, buildDir, "libportal", "portal-enums.h"), Path.Combine(includePath, "portal-enums.h")); Utilities.FileCopy(Path.Combine(root, buildDir, "libportal", "portal-enums.h"), Path.Combine(includePath, "portal-enums.h"));
Utilities.FileCopy(Path.Combine(root, buildDir, "libportal", "portal-enums.c"), Path.Combine(dstPath, "portal-enums.c")); Utilities.FileCopy(Path.Combine(root, buildDir, "libportal", "portal-enums.c"), Path.Combine(dstPath, "portal-enums.c"));
Utilities.FileCopy(Path.Combine(root, "COPYING"), Path.Combine(dstPath, "LICENSE.txt"));
if (!Directory.Exists(includePath))
Directory.CreateDirectory(includePath);
if (!Directory.Exists(Path.Combine(includePath, "libportal")))
Directory.CreateDirectory(Path.Combine(includePath, "libportal"));
foreach (var file in Directory.GetFiles(Path.Combine(root, "libportal"), "*.h"))
Utilities.FileCopy(file, Path.Combine(includePath, "libportal", Path.GetFileName(file)));
break;
}
} }
Utilities.FileCopy(Path.Combine(root, "COPYING"), Path.Combine(dstPath, "LICENSE.txt"));
if (!Directory.Exists(includePath))
Directory.CreateDirectory(includePath);
if (!Directory.Exists(Path.Combine(includePath, "libportal")))
Directory.CreateDirectory(Path.Combine(includePath, "libportal"));
foreach (var file in Directory.GetFiles(Path.Combine(root, "libportal"), "*.h"))
Utilities.FileCopy(file, Path.Combine(includePath, "libportal", Path.GetFileName(file)));
break;
}
} }
} }
} }

30
Source/Tools/Flax.Build/Deps/Dependencies/mono.cs
View File

@@ -53,6 +53,36 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
private string root; private string root;
private string monoPropsPath; private string monoPropsPath;
private string monoPreprocesorDefines; private string monoPreprocesorDefines;

64
Source/Tools/Flax.Build/Deps/Dependencies/nethost.cs
View File

@@ -43,6 +43,39 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc />
public override bool BuildByDefault => false;
private string root; private string root;
private bool cleanArtifacts; private bool cleanArtifacts;
@@ -331,24 +364,27 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
var platformData = Path.Combine(GetBinariesFolder(options, platform), "Data", "nethost");
if (Directory.Exists(platformData))
Utilities.DirectoryCopy(platformData, root, true, true);
switch (platform)
{ {
case TargetPlatform.PS4: BuildStarted(platform, architecture);
case TargetPlatform.PS5: var platformData = Path.Combine(GetBinariesFolder(options, platform), "Data", "nethost");
case TargetPlatform.XboxOne: if (Directory.Exists(platformData))
case TargetPlatform.XboxScarlett: Utilities.DirectoryCopy(platformData, root, true, true);
Build(options, platform, TargetArchitecture.x64); switch (platform)
{
case TargetPlatform.PS4:
case TargetPlatform.PS5:
case TargetPlatform.XboxOne:
case TargetPlatform.XboxScarlett:
Build(options, platform, TargetArchitecture.x64);
break; break;
case TargetPlatform.Android: case TargetPlatform.Android:
Build(options, platform, TargetArchitecture.ARM64); Build(options, platform, TargetArchitecture.ARM64);
break; break;
case TargetPlatform.Switch: case TargetPlatform.Switch:
Build(options, platform, TargetArchitecture.ARM64); Build(options, platform, TargetArchitecture.ARM64);
break; break;
}
} }
} }

19
Source/Tools/Flax.Build/Deps/Dependencies/nvapi.cs
View File

@@ -18,6 +18,23 @@ namespace Flax.Deps.Dependencies
get => new[] { TargetPlatform.Windows }; get => new[] { TargetPlatform.Windows };
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64
};
default: return new TargetArchitecture[0];
}
}
}
/// <inheritdoc /> /// <inheritdoc />
public override void Build(BuildOptions options) public override void Build(BuildOptions options)
{ {
@@ -30,7 +47,7 @@ namespace Flax.Deps.Dependencies
// Copy files // Copy files
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); BuildStarted(platform, TargetArchitecture.x64);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64); var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
Utilities.FileCopy(Path.Combine(root, "amd64/nvapi64.lib"), Path.Combine(depsFolder, "nvapi64.lib")); Utilities.FileCopy(Path.Combine(root, "amd64/nvapi64.lib"), Path.Combine(depsFolder, "nvapi64.lib"));
} }

241
Source/Tools/Flax.Build/Deps/Dependencies/vorbis.cs
View File

@@ -49,6 +49,36 @@ namespace Flax.Deps.Dependencies
} }
} }
/// <inheritdoc />
public override TargetArchitecture[] Architectures
{
get
{
switch (BuildPlatform)
{
case TargetPlatform.Windows:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
case TargetPlatform.Linux:
return new[]
{
TargetArchitecture.x64,
//TargetArchitecture.ARM64,
};
case TargetPlatform.Mac:
return new[]
{
TargetArchitecture.x64,
TargetArchitecture.ARM64,
};
default: return new TargetArchitecture[0];
}
}
}
private struct Binary private struct Binary
{ {
public string Filename; public string Filename;
@@ -337,31 +367,32 @@ namespace Flax.Deps.Dependencies
foreach (var platform in options.Platforms) foreach (var platform in options.Platforms)
{ {
BuildStarted(platform); foreach (var architecture in options.Architectures)
switch (platform)
{ {
case TargetPlatform.Windows: BuildStarted(platform, architecture);
{ switch (platform)
BuildCmake(options, TargetPlatform.Windows, TargetArchitecture.x64); {
BuildCmake(options, TargetPlatform.Windows, TargetArchitecture.ARM64); case TargetPlatform.Windows:
break; {
} BuildCmake(options, TargetPlatform.Windows, architecture);
case TargetPlatform.UWP: break;
{ }
BuildMsbuild(options, TargetPlatform.UWP, TargetArchitecture.x64); case TargetPlatform.UWP:
break; {
} BuildMsbuild(options, TargetPlatform.UWP, architecture);
case TargetPlatform.XboxOne: break;
{ }
BuildMsbuild(options, TargetPlatform.XboxOne, TargetArchitecture.x64); case TargetPlatform.XboxOne:
break; {
} BuildMsbuild(options, TargetPlatform.XboxOne, architecture);
case TargetPlatform.Linux: break;
{ }
// Note: assumes the libogg-dev package is pre-installed on the system case TargetPlatform.Linux:
{
// Note: assumes the libogg-dev package is pre-installed on the system
// Get the source // Get the source
CloneGitRepoFast(root, "https://github.com/xiph/vorbis.git"); CloneGitRepoFast(root, "https://github.com/xiph/vorbis.git");
var envVars = new Dictionary<string, string> var envVars = new Dictionary<string, string>
{ {
@@ -370,62 +401,62 @@ namespace Flax.Deps.Dependencies
}; };
var buildDir = Path.Combine(root, "build"); var buildDir = Path.Combine(root, "build");
Utilities.Run(Path.Combine(root, "autogen.sh"), null, null, root, Utilities.RunOptions.Default, envVars); Utilities.Run(Path.Combine(root, "autogen.sh"), null, null, root, Utilities.RunOptions.Default, envVars);
// Build for Linux // Build for Linux
var toolchain = UnixToolchain.GetToolchainName(platform, TargetArchitecture.x64); var toolchain = UnixToolchain.GetToolchainName(platform, architecture);
Utilities.Run(Path.Combine(root, "configure"), string.Format("--host={0}", toolchain), null, root, Utilities.RunOptions.Default, envVars); Utilities.Run(Path.Combine(root, "configure"), string.Format("--host={0}", toolchain), null, root, Utilities.RunOptions.Default, envVars);
SetupDirectory(buildDir, true); SetupDirectory(buildDir, true);
Utilities.Run("cmake", "-G \"Unix Makefiles\" -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCMAKE_BUILD_TYPE=Release ..", null, buildDir, Utilities.RunOptions.ConsoleLogOutput, envVars); Utilities.Run("cmake", "-G \"Unix Makefiles\" -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCMAKE_BUILD_TYPE=Release ..", null, buildDir, Utilities.RunOptions.ConsoleLogOutput, envVars);
Utilities.Run("cmake", "--build .", null, buildDir, Utilities.RunOptions.ConsoleLogOutput, envVars); Utilities.Run("cmake", "--build .", null, buildDir, Utilities.RunOptions.ConsoleLogOutput, envVars);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in binariesToCopyUnix) foreach (var file in binariesToCopyUnix)
Utilities.FileCopy(Path.Combine(buildDir, file.SrcFolder, file.Filename), Path.Combine(depsFolder, file.Filename)); Utilities.FileCopy(Path.Combine(buildDir, file.SrcFolder, file.Filename), Path.Combine(depsFolder, file.Filename));
break; break;
} }
case TargetPlatform.PS4: case TargetPlatform.PS4:
{ {
BuildMsbuild(options, TargetPlatform.PS4, TargetArchitecture.x64); BuildMsbuild(options, TargetPlatform.PS4, TargetArchitecture.x64);
break; break;
} }
case TargetPlatform.PS5: case TargetPlatform.PS5:
{ {
BuildMsbuild(options, TargetPlatform.PS5, TargetArchitecture.x64); BuildMsbuild(options, TargetPlatform.PS5, TargetArchitecture.x64);
break; break;
} }
case TargetPlatform.XboxScarlett: case TargetPlatform.XboxScarlett:
{ {
BuildMsbuild(options, TargetPlatform.XboxScarlett, TargetArchitecture.x64); BuildMsbuild(options, TargetPlatform.XboxScarlett, TargetArchitecture.x64);
break; break;
} }
case TargetPlatform.Android: case TargetPlatform.Android:
{ {
var oggRoot = Path.Combine(root, "ogg"); var oggRoot = Path.Combine(root, "ogg");
var oggBuildDir = Path.Combine(oggRoot, "build"); var oggBuildDir = Path.Combine(oggRoot, "build");
var buildDir = Path.Combine(root, "build"); var buildDir = Path.Combine(root, "build");
// Get the source // Get the source
CloneGitRepoFast(root, "https://github.com/xiph/vorbis.git"); CloneGitRepoFast(root, "https://github.com/xiph/vorbis.git");
CloneGitRepo(oggRoot, "https://github.com/xiph/ogg.git"); CloneGitRepo(oggRoot, "https://github.com/xiph/ogg.git");
GitCheckout(oggRoot, "master", "4380566a44b8d5e85ad511c9c17eb04197863ec5"); GitCheckout(oggRoot, "master", "4380566a44b8d5e85ad511c9c17eb04197863ec5");
// Build for Android // Build for Android
SetupDirectory(oggBuildDir, true); SetupDirectory(oggBuildDir, true);
RunCmake(oggBuildDir, platform, TargetArchitecture.ARM64, ".. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=\"../install\""); RunCmake(oggBuildDir, platform, TargetArchitecture.ARM64, ".. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=\"../install\"");
Utilities.Run("cmake", "--build . --target install", null, oggBuildDir, Utilities.RunOptions.ConsoleLogOutput); Utilities.Run("cmake", "--build . --target install", null, oggBuildDir, Utilities.RunOptions.ConsoleLogOutput);
SetupDirectory(buildDir, true); SetupDirectory(buildDir, true);
RunCmake(buildDir, platform, TargetArchitecture.ARM64, string.Format(".. -DCMAKE_BUILD_TYPE=Release -DOGG_INCLUDE_DIR=\"{0}/install/include\" -DOGG_LIBRARY=\"{0}/install/lib\"", oggRoot)); RunCmake(buildDir, platform, TargetArchitecture.ARM64, string.Format(".. -DCMAKE_BUILD_TYPE=Release -DOGG_INCLUDE_DIR=\"{0}/install/include\" -DOGG_LIBRARY=\"{0}/install/lib\"", oggRoot));
BuildCmake(buildDir); BuildCmake(buildDir);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64); var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64);
foreach (var file in binariesToCopyUnix) foreach (var file in binariesToCopyUnix)
Utilities.FileCopy(Path.Combine(buildDir, file.SrcFolder, file.Filename), Path.Combine(depsFolder, file.Filename)); Utilities.FileCopy(Path.Combine(buildDir, file.SrcFolder, file.Filename), Path.Combine(depsFolder, file.Filename));
break; break;
} }
case TargetPlatform.Switch: case TargetPlatform.Switch:
{ {
var oggRoot = Path.Combine(root, "ogg"); var oggRoot = Path.Combine(root, "ogg");
var oggBuildDir = Path.Combine(oggRoot, "build"); var oggBuildDir = Path.Combine(oggRoot, "build");
var buildDir = Path.Combine(root, "build"); var buildDir = Path.Combine(root, "build");
// Get the source // Get the source
SetupDirectory(oggRoot, false); SetupDirectory(oggRoot, false);
@@ -455,14 +486,12 @@ namespace Flax.Deps.Dependencies
var oggBuildDir = Path.Combine(oggRoot, "build"); var oggBuildDir = Path.Combine(oggRoot, "build");
var buildDir = Path.Combine(root, "build"); var buildDir = Path.Combine(root, "build");
// Get the source // Get the source
CloneGitRepoFast(root, "https://github.com/xiph/vorbis.git"); CloneGitRepoFast(root, "https://github.com/xiph/vorbis.git");
CloneGitRepo(oggRoot, "https://github.com/xiph/ogg.git"); CloneGitRepo(oggRoot, "https://github.com/xiph/ogg.git");
GitCheckout(oggRoot, "master", "4380566a44b8d5e85ad511c9c17eb04197863ec5"); GitCheckout(oggRoot, "master", "4380566a44b8d5e85ad511c9c17eb04197863ec5");
// Build for Mac // Build for Mac
foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
{
SetupDirectory(oggBuildDir, true); SetupDirectory(oggBuildDir, true);
RunCmake(oggBuildDir, platform, architecture, ".. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=\"../install\""); RunCmake(oggBuildDir, platform, architecture, ".. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=\"../install\"");
Utilities.Run("cmake", "--build . --target install", null, oggBuildDir, Utilities.RunOptions.ConsoleLogOutput); Utilities.Run("cmake", "--build . --target install", null, oggBuildDir, Utilities.RunOptions.ConsoleLogOutput);
@@ -472,32 +501,32 @@ namespace Flax.Deps.Dependencies
var depsFolder = GetThirdPartyFolder(options, platform, architecture); var depsFolder = GetThirdPartyFolder(options, platform, architecture);
foreach (var file in binariesToCopyUnix) foreach (var file in binariesToCopyUnix)
Utilities.FileCopy(Path.Combine(buildDir, file.SrcFolder, file.Filename), Path.Combine(depsFolder, file.Filename)); Utilities.FileCopy(Path.Combine(buildDir, file.SrcFolder, file.Filename), Path.Combine(depsFolder, file.Filename));
break;
} }
break; case TargetPlatform.iOS:
} {
case TargetPlatform.iOS: var oggRoot = Path.Combine(root, "ogg");
{ var oggBuildDir = Path.Combine(oggRoot, "build");
var oggRoot = Path.Combine(root, "ogg"); var buildDir = Path.Combine(root, "build");
var oggBuildDir = Path.Combine(oggRoot, "build");
var buildDir = Path.Combine(root, "build");
// Get the source // Get the source
CloneGitRepoFast(root, "https://github.com/xiph/vorbis.git"); CloneGitRepoFast(root, "https://github.com/xiph/vorbis.git");
CloneGitRepo(oggRoot, "https://github.com/xiph/ogg.git"); CloneGitRepo(oggRoot, "https://github.com/xiph/ogg.git");
GitCheckout(oggRoot, "master", "4380566a44b8d5e85ad511c9c17eb04197863ec5"); GitCheckout(oggRoot, "master", "4380566a44b8d5e85ad511c9c17eb04197863ec5");
// Build for Mac // Build for Mac
SetupDirectory(oggBuildDir, true); SetupDirectory(oggBuildDir, true);
RunCmake(oggBuildDir, platform, TargetArchitecture.ARM64, ".. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=\"../install\""); RunCmake(oggBuildDir, platform, TargetArchitecture.ARM64, ".. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=\"../install\"");
Utilities.Run("cmake", "--build . --target install", null, oggBuildDir, Utilities.RunOptions.ConsoleLogOutput); Utilities.Run("cmake", "--build . --target install", null, oggBuildDir, Utilities.RunOptions.ConsoleLogOutput);
SetupDirectory(buildDir, true); SetupDirectory(buildDir, true);
RunCmake(buildDir, platform, TargetArchitecture.ARM64, string.Format(".. -DCMAKE_BUILD_TYPE=Release -DOGG_INCLUDE_DIR=\"{0}/install/include\" -DOGG_LIBRARY=\"{0}/install/lib\"", oggRoot)); RunCmake(buildDir, platform, TargetArchitecture.ARM64, string.Format(".. -DCMAKE_BUILD_TYPE=Release -DOGG_INCLUDE_DIR=\"{0}/install/include\" -DOGG_LIBRARY=\"{0}/install/lib\"", oggRoot));
BuildCmake(buildDir); BuildCmake(buildDir);
var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64); var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.ARM64);
foreach (var file in binariesToCopyUnix) foreach (var file in binariesToCopyUnix)
Utilities.FileCopy(Path.Combine(buildDir, file.SrcFolder, file.Filename), Path.Combine(depsFolder, file.Filename)); Utilities.FileCopy(Path.Combine(buildDir, file.SrcFolder, file.Filename), Path.Combine(depsFolder, file.Filename));
break; break;
} }
}
} }
} }

14
Source/Tools/Flax.Build/Deps/Dependency.cs
View File

@@ -40,6 +40,11 @@ namespace Flax.Deps
/// The target platforms to build dependency for (contains only platforms supported by the dependency itself). /// The target platforms to build dependency for (contains only platforms supported by the dependency itself).
/// </summary> /// </summary>
public TargetPlatform[] Platforms; public TargetPlatform[] Platforms;
/// <summary>
/// The target architectures to build dependency for (contains only platforms supported by the dependency itself).
/// </summary>
public TargetArchitecture[] Architectures;
} }
/// <summary> /// <summary>
@@ -70,6 +75,11 @@ namespace Flax.Deps
/// </summary> /// </summary>
public abstract TargetPlatform[] Platforms { get; } public abstract TargetPlatform[] Platforms { get; }
/// <summary>
/// Gets the architectures list supported by this dependency to build on the current build platform (based on <see cref="Platform.BuildPlatform"/>).
/// </summary>
public abstract TargetArchitecture[] Architectures { get; }
/// <summary> /// <summary>
/// True if build dependency by default, otherwise only when explicitly specified via command line. /// True if build dependency by default, otherwise only when explicitly specified via command line.
/// </summary> /// </summary>
@@ -85,9 +95,9 @@ namespace Flax.Deps
/// Logs build process start. /// Logs build process start.
/// </summary> /// </summary>
/// <param name="platform">Target platform.</param> /// <param name="platform">Target platform.</param>
protected void BuildStarted(TargetPlatform platform) protected void BuildStarted(TargetPlatform platform, TargetArchitecture architecture)
{ {
Log.Info($"Building {GetType().Name} for {platform}"); Log.Info($"Building {GetType().Name} for {platform}{(architecture != TargetArchitecture.AnyCPU ? $" ({architecture})" : "")}");
} }
/// <summary> /// <summary>

31
Source/Tools/Flax.Build/Deps/DepsBuilder.cs
View File

@@ -38,20 +38,21 @@ namespace Flax.Deps
var platforms = Globals.AllPlatforms; var platforms = Globals.AllPlatforms;
if (Configuration.BuildPlatforms != null && Configuration.BuildPlatforms.Length != 0) if (Configuration.BuildPlatforms != null && Configuration.BuildPlatforms.Length != 0)
platforms = Configuration.BuildPlatforms; platforms = Configuration.BuildPlatforms;
platforms = platforms.Where(x => buildPlatform.CanBuildPlatform(x)).ToArray(); platforms = platforms.Where(buildPlatform.CanBuildPlatform).ToArray();
Log.Verbose("Building deps for platforms:"); var architectures = Globals.AllArchitectures;
if (Configuration.BuildArchitectures != null && Configuration.BuildArchitectures.Length != 0)
architectures = Configuration.BuildArchitectures;
architectures = architectures.Where(buildPlatform.CanBuildArchitecture).ToArray();
Log.Verbose($"Building deps for platforms {string.Join(',', platforms)}, {string.Join(',', architectures)}:");
foreach (var platform in platforms) foreach (var platform in platforms)
{ {
Log.Verbose(" - " + platform); foreach (var architecture in architectures)
{
Log.Verbose($" - {platform} ({architecture})");
if (Platform.IsPlatformSupported(platform, TargetArchitecture.x64)) if (Platform.IsPlatformSupported(platform, architecture))
SetupDepsOutputFolder(options, platform, TargetArchitecture.x64); SetupDepsOutputFolder(options, platform, architecture);
if (Platform.IsPlatformSupported(platform, TargetArchitecture.x86)) }
SetupDepsOutputFolder(options, platform, TargetArchitecture.x86);
if (Platform.IsPlatformSupported(platform, TargetArchitecture.ARM))
SetupDepsOutputFolder(options, platform, TargetArchitecture.ARM);
if (Platform.IsPlatformSupported(platform, TargetArchitecture.ARM64))
SetupDepsOutputFolder(options, platform, TargetArchitecture.ARM64);
} }
// Get all deps // Get all deps
@@ -80,6 +81,14 @@ namespace Flax.Deps
continue; continue;
} }
options.Architectures = architectures.Intersect(dependency.Architectures).ToArray();
if (options.Architectures.Length == 0)
{
Log.Info(string.Format("Skipping {0} ({1}/{2})", name, i + 1, dependencies.Length));
Log.Verbose("Architecture not used on any of the build platforms.");
continue;
}
Log.Info(string.Format("Building {0} ({1}/{2})", name, i + 1, dependencies.Length)); Log.Info(string.Format("Building {0} ({1}/{2})", name, i + 1, dependencies.Length));
options.IntermediateFolder = Path.Combine(Environment.CurrentDirectory, "Cache", "Intermediate", "Deps", name).Replace('\\', '/'); options.IntermediateFolder = Path.Combine(Environment.CurrentDirectory, "Cache", "Intermediate", "Deps", name).Replace('\\', '/');