/// <summary>
/// Generates the projects for the targets and the solution for the workspace.
/// </summary>
public static void GenerateProjects()
{
using (new ProfileEventScope("GenerateProjects"))
{
// Pick the project format
ProjectFormat projectFormat = Platform.BuildPlatform.DefaultProjectFormat;
if (Configuration.ProjectFormatVS2019)
{
projectFormat = ProjectFormat.VisualStudio2019;
}
else if (Configuration.ProjectFormatVS2017)
{
projectFormat = ProjectFormat.VisualStudio2017;
}
else if (Configuration.ProjectFormatVS2015)
{
projectFormat = ProjectFormat.VisualStudio2015;
}
else if (Configuration.ProjectFormatVSCode)
{
projectFormat = ProjectFormat.VisualStudioCode;
}
else if (!string.IsNullOrEmpty(Configuration.ProjectFormatCustom))
{
projectFormat = ProjectFormat.Custom;
}
// Setup
var rules = GenerateRulesAssembly();
var rootProject = Globals.Project;
var projectFiles = rootProject.GetAllProjects();
var targetGroups = rules.Targets.GroupBy(x => x.ProjectName);
var workspaceRoot = rootProject.ProjectFolderPath;
var projectsRoot = Path.Combine(workspaceRoot, "Cache", "Projects");
var projects = new List <Project>();
var dotNetProjectGenerator = ProjectGenerator.Create(projectFormat, TargetType.DotNet);
var projectToBinaryModule = new Dictionary <Project, KeyValuePair <string, HashSet <Module> > >();
var projectToModulesBuildOptions = new Dictionary <Project, Dictionary <Module, BuildOptions> >();
Project mainSolutionProject = null;
ProjectGenerator nativeProjectGenerator = ProjectGenerator.Create(projectFormat, TargetType.NativeCpp);
// Setup projects for target groups (before actual generation to handle cross-project references like)
foreach (var e in targetGroups)
{
var projectName = e.Key;
using (new ProfileEventScope(projectName))
{
var targets = e.ToArray();
if (targets.Length == 0)
{
throw new Exception("No targets in a group " + projectName);
}
TargetType type = targets[0].Type;
for (int i = 1; i < targets.Length; i++)
{
if (targets[i].Type != type)
{
Log.Error(string.Format($"Invalid targets group. Project {projectName} uses type {type} from target {targets[0].Name} but target {targets[i].Name} is type of {targets[i].Type}"));
}
}
var projectInfo = targets[0] is ProjectTarget projectTarget ? projectTarget.Project : projectFiles.First(x => targets[0].FolderPath.Contains(x.ProjectFolderPath));
// Create project
Project mainProject;
var binaryModules = new Dictionary <string, HashSet <Module> >();
var modulesBuildOptions = new Dictionary <Module, BuildOptions>();
using (new ProfileEventScope("CreateProject"))
{
var generator = ProjectGenerator.Create(projectFormat, type);
var project = mainProject = generator.CreateProject();
if (targets[0].CustomExternalProjectFilePath == null)
{
project.Type = TargetType.NativeCpp;
}
project.Name = projectName;
project.Targets = targets;
project.SearchPaths = new string[0];
project.WorkspaceRootPath = projectInfo.ProjectFolderPath;
if (targets[0].CustomExternalProjectFilePath == null)
{
project.Path = Path.Combine(projectsRoot, project.Name + '.' + generator.ProjectFileExtension);
}
else
{
project.Path = targets[0].CustomExternalProjectFilePath;
}
if (project.WorkspaceRootPath.StartsWith(rootProject.ProjectFolderPath))
{
project.GroupName = Utilities.MakePathRelativeTo(project.WorkspaceRootPath, rootProject.ProjectFolderPath);
}
else if (projectInfo != Globals.Project)
{
project.GroupName = projectInfo.Name;
}
project.SourceDirectories = new List <string>
{
Path.GetDirectoryName(targets[0].FilePath)
};
SetupProjectConfigurations(project, projectInfo);
// Get all modules aggregated into all binary modules used in all configurations of this target
foreach (var configurationData in mainProject.Configurations)
{
var configurationBinaryModules = GetBinaryModules(rules, configurationData.Target, configurationData.Modules);
foreach (var configurationBinaryModule in configurationBinaryModules)
{
// Skip if none of the included binary modules is inside the project workspace (eg. merged external binary modules from engine to game project)
if (!configurationBinaryModule.Any(y => y.FolderPath.StartsWith(project.WorkspaceRootPath)))
{
continue;
}
if (!binaryModules.TryGetValue(configurationBinaryModule.Key, out var modules))
{
binaryModules[configurationBinaryModule.Key] = modules = new HashSet <Module>();
}
modules.AddRange(configurationBinaryModule);
foreach (var module in configurationBinaryModule)
{
if (!modulesBuildOptions.ContainsKey(module))
{
modulesBuildOptions.Add(module, configurationData.Modules[module]);
}
}
}
foreach (var reference in projectInfo.References)
{
var referenceTargets = GetProjectTargets(reference.Project);
foreach (var referenceTarget in referenceTargets)
{
try
{
var referenceBuildOptions = GetBuildOptions(referenceTarget, configurationData.TargetBuildOptions.Platform, configurationData.TargetBuildOptions.Toolchain, configurationData.Architecture, configurationData.Configuration, reference.Project.ProjectFolderPath);
var referenceModules = CollectModules(rules, referenceBuildOptions.Platform, referenceTarget, referenceBuildOptions, referenceBuildOptions.Toolchain, referenceBuildOptions.Architecture, referenceBuildOptions.Configuration);
var referenceBinaryModules = GetBinaryModules(rules, referenceTarget, referenceModules);
foreach (var binaryModule in referenceBinaryModules)
{
project.Defines.Add(binaryModule.Key.ToUpperInvariant() + "_API=");
}
}
catch
{
// Ignore exceptions
}
}
}
}
foreach (var binaryModule in binaryModules)
{
project.Defines.Add(binaryModule.Key.ToUpperInvariant() + "_API=");
}
// Skip using C++ project if any included binary module is C#-only
if (binaryModules.Any(x => x.Value.Any(y => y.BuildNativeCode)) && !rootProject.IsCSharpOnlyProject)
{
projects.Add(project);
if (mainSolutionProject == null && projectInfo == rootProject)
{
mainSolutionProject = project;
}
}
else if (targets[0].CustomExternalProjectFilePath != null)
{
projects.Add(project);
}
}
// Create API bindings projects
foreach (var binaryModule in binaryModules)
{
var binaryModuleName = binaryModule.Key;
// Skip excluded modules with empty BinaryModuleName
if (string.IsNullOrEmpty(binaryModuleName))
{
continue;
}
// Skip bindings projects for prebuilt targets (eg. no sources to build/view - just binaries)
if (targets[0].IsPreBuilt)
{
continue;
}
using (new ProfileEventScope(binaryModuleName))
{
// TODO: add support for extending this code and support generating bindings projects for other scripting languages
// Get source files
var sourceFiles = new List <string>();
var generatedSourceFiles = new List <string>();
foreach (var module in binaryModule.Value)
{
// C# sources included into build source files
sourceFiles.AddRange(modulesBuildOptions[module].SourceFiles.Where(x => x.EndsWith(".cs")));
}
sourceFiles.RemoveAll(x => x.EndsWith(BuildFilesPostfix));
foreach (var target in targets)
{
foreach (var configurationData in mainProject.Configurations)
{
if (target != configurationData.Target)
{
continue;
}
foreach (var q in configurationData.Modules)
{
if (!q.Key.FolderPath.StartsWith(target.FolderPath))
{
continue;
}
// Generated C# bindings source files (per-target, per-platform, per-configuration)
var intermediateFolder = Path.Combine(q.Value.WorkingDirectory, Configuration.IntermediateFolder, target.Name, configurationData.PlatformName, configurationData.ArchitectureName, configurationData.ConfigurationName);
var path = Path.Combine(intermediateFolder, q.Key.Name, q.Key.Name + ".Bindings.Gen.cs");
if (!File.Exists(path))
{
Directory.CreateDirectory(Path.GetDirectoryName(path));
File.WriteAllText(path, string.Empty, new UTF8Encoding());
}
generatedSourceFiles.Add(path);
}
}
}
sourceFiles.Add(Path.Combine(targets[0].FolderPath, binaryModuleName + ".Gen.cs"));
if (mainSolutionProject == null)
{
// Add shaders sources to C# bindings project if not using C++ project
var shadersSourcePath = Path.Combine(projectInfo.ProjectFolderPath, "Source/Shaders");
if (Directory.Exists(shadersSourcePath))
{
sourceFiles.AddRange(Directory.GetFiles(shadersSourcePath, "*", SearchOption.AllDirectories));
}
}
sourceFiles.Sort();
// Create project description
var project = dotNetProjectGenerator.CreateProject();
project.Type = TargetType.DotNet;
project.Name = binaryModuleName;
project.OutputType = TargetOutputType.Library;
project.Targets = targets;
project.SearchPaths = new string[0];
project.WorkspaceRootPath = mainProject.WorkspaceRootPath;
project.GroupName = mainProject.GroupName;
if (project.WorkspaceRootPath.StartsWith(workspaceRoot))
{
// Place project targets binary modules bindings in the Source folder of the project (Visual Studio handles C# source files better in that way)
project.Path = Path.Combine(project.WorkspaceRootPath, "Source", project.Name + '.' + dotNetProjectGenerator.ProjectFileExtension);
}
else
{
// Default project files location
project.Path = Path.Combine(projectsRoot, project.Name + '.' + dotNetProjectGenerator.ProjectFileExtension);
}
project.SourceFiles = sourceFiles;
project.GeneratedSourceFiles = generatedSourceFiles;
project.CSharp.UseFlaxVS = true;
project.Configurations.AddRange(mainProject.Configurations);
projectToBinaryModule.Add(project, binaryModule);
projectToModulesBuildOptions.Add(project, modulesBuildOptions);
projects.Add(project);
if (mainSolutionProject == null && projectInfo == rootProject)
{
mainSolutionProject = project;
}
}
}
}
}
// Setup cross-project references
using (new ProfileEventScope("ProjectReferences"))
{
foreach (var project in projects)
{
if (!projectToBinaryModule.TryGetValue(project, out var binaryModule) ||
!projectToModulesBuildOptions.TryGetValue(project, out var modulesBuildOptions))
{
continue;
}
foreach (var module in binaryModule.Value)
{
if (!modulesBuildOptions.TryGetValue(module, out var moduleBuildOptions))
{
continue;
}
// Combine build options from this module
project.CSharp.SystemReferences.AddRange(moduleBuildOptions.ScriptingAPI.SystemReferences);
project.CSharp.FileReferences.AddRange(moduleBuildOptions.ScriptingAPI.FileReferences);
// Find references based on the modules dependencies (external or from projects)
foreach (var dependencyName in moduleBuildOptions.PublicDependencies.Concat(moduleBuildOptions.PrivateDependencies))
{
var dependencyModule = rules.GetModule(dependencyName);
if (dependencyModule != null &&
!string.IsNullOrEmpty(dependencyModule.BinaryModuleName) &&
dependencyModule.BinaryModuleName != binaryModule.Key)
{
var dependencyProject = projects.Find(x => x != null && x.Generator.Type == project.Generator.Type && x.Name == dependencyModule.BinaryModuleName);
if (dependencyProject != null)
{
// Reference that project
project.Dependencies.Add(dependencyProject);
}
else if (dependencyModule.BinaryModuleName == "FlaxEngine")
{
// TODO: instead of this hack find a way to reference the prebuilt target bindings binary (example: game C# project references FlaxEngine C# prebuilt dll)
project.CSharp.FileReferences.Add(Path.Combine(Globals.EngineRoot, "Binaries/Editor/Win64/Development/FlaxEngine.CSharp.dll"));
}
}
}
}
}
}
// Setup custom projects
GenerateCustomProjects?.Invoke(projects);
nativeProjectGenerator.GenerateCustomProjects(projects);
// Generate projects
using (new ProfileEventScope("GenerateProjects"))
{
foreach (var project in projects)
{
Log.Verbose(project.Name + " -> " + project.Path);
project.Generate();
}
}
// Generate C# project for build scripts files
string rulesProjectName = "BuildScripts";
using (new ProfileEventScope(rulesProjectName))
{
// Create dummy target
var target = new Target
{
Name = rulesProjectName,
ProjectName = rulesProjectName,
FilePath = null,
FolderPath = null,
Type = TargetType.DotNet,
OutputType = TargetOutputType.Library,
Platforms = new[] { Platform.BuildPlatform.Target },
Configurations = new[] { TargetConfiguration.Debug },
Architectures = new[] { TargetArchitecture.AnyCPU },
};
// Create project description
Project project;
using (new ProfileEventScope("CreateProject"))
{
project = dotNetProjectGenerator.CreateProject();
project.Type = TargetType.DotNet;
project.Name = rulesProjectName;
project.Targets = new[] { target };
project.SearchPaths = new string[0];
project.WorkspaceRootPath = workspaceRoot;
project.Path = Path.Combine(projectsRoot, project.Name + '.' + dotNetProjectGenerator.ProjectFileExtension);
project.CSharp.OutputPath = Path.Combine(Environment.CurrentDirectory, "Cache", "Intermediate", "Unused");
project.SourceFiles = new List <string>();
foreach (var e in rules.Targets)
{
project.SourceFiles.Add(e.FilePath);
}
foreach (var e in rules.Modules)
{
project.SourceFiles.Add(e.FilePath);
}
project.CSharp.SystemReferences = new HashSet <string>
{
"System",
"System.Core",
};
SetupProjectConfigurations(project, rootProject);
if (project.Configurations.Count == 0)
{
// Hardcoded dummy configuration even if platform tools are missing for this platform
var platform = Platform.BuildPlatform;
var architecture = TargetArchitecture.x64;
var configuration = TargetConfiguration.Debug;
project.Configurations.Add(new Project.ConfigurationData
{
Platform = platform.Target,
PlatformName = platform.Target.ToString(),
Architecture = architecture,
ArchitectureName = architecture.ToString(),
Configuration = configuration,
ConfigurationName = configuration.ToString(),
Target = target,
TargetBuildOptions = GetBuildOptions(target, platform, null, architecture, configuration, project.WorkspaceRootPath),
Modules = new Dictionary <Module, BuildOptions>(),
});
}
var c = project.Configurations[0];
c.Name = "Debug|AnyCPU";
c.Text = "Debug";
project.Configurations[0] = c;
// Add reference to Flax.Build so rules can be validated in the IDE
project.CSharp.FileReferences.Add(Assembly.GetEntryAssembly().Location);
}
// Generate project
using (new ProfileEventScope("GenerateProject"))
{
Log.Verbose("Project " + rulesProjectName + " -> " + project.Path);
dotNetProjectGenerator.GenerateProject(project);
}
projects.Add(project);
}
// Generate solution
using (new ProfileEventScope("Solution"))
{
Solution solution;
using (new ProfileEventScope("CreateSolution"))
{
solution = nativeProjectGenerator.CreateSolution();
solution.Name = rootProject.Name;
solution.WorkspaceRootPath = workspaceRoot;
solution.Path = Path.Combine(workspaceRoot, solution.Name + '.' + nativeProjectGenerator.SolutionFileExtension);
solution.Projects = projects.ToArray();
solution.MainProject = mainSolutionProject;
}
using (new ProfileEventScope("GenerateSolution"))
{
Log.Verbose("Solution -> " + solution.Path);
nativeProjectGenerator.GenerateSolution(solution);
}
}
}
}