use std::path::{Path, PathBuf};
use serde::Deserialize;
#[derive(Debug, Clone, Default, PartialEq, Eq, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UnrealSection {
#[serde(default)]
pub enable: bool,
#[serde(default)]
pub engine: Option<PathBuf>,
}
impl UnrealSection {
pub fn is_on(&self) -> bool {
self.enable || self.engine.is_some()
}
pub fn engine_root(&self, root: &Path) -> Option<PathBuf> {
if let Some(named) = self.engine.as_ref() {
let named = if named.is_absolute() {
named.clone()
} else {
root.join(named)
};
if named.join("Engine/Source/Runtime").is_dir() {
return Some(named);
}
if named.join("Source/Runtime").is_dir()
&& let Some(parent) = named.parent()
{
return Some(parent.to_path_buf());
}
return Some(named);
}
[root.to_path_buf(), root.parent()?.to_path_buf()]
.into_iter()
.find(|candidate| candidate.join("Engine/Source/Runtime").is_dir())
}
pub fn applied_to(
&self,
mut config: crate::include::config::CompilerConfig,
root: &Path,
) -> crate::include::config::CompilerConfig {
if !self.is_on() {
return config;
}
for include in generated_include_directories(root) {
config
.include_paths
.push(crate::include::config::IncludePath::system(include));
}
if let Some(engine) = self.engine_root(root) {
for include in engine_include_directories(&engine) {
config
.include_paths
.push(crate::include::config::IncludePath::system(include));
}
}
for (name, value) in engine_defines() {
define_if_absent(&mut config, name, value);
}
for module in game_modules(root) {
define_if_absent(&mut config, &format!("{}_API", module.to_uppercase()), "");
}
config
}
}
pub fn known_specifiers(macro_name: &str) -> Option<&'static [&'static str]> {
const UCLASS: &[&str] = &[
"Abstract",
"AdvancedClassDisplay",
"AutoCollapseCategories",
"AutoExpandCategories",
"Blueprintable",
"BlueprintType",
"ClassGroup",
"CollapseCategories",
"Config",
"Const",
"CustomConstructor",
"DefaultConfig",
"DefaultToInstanced",
"Deprecated",
"DontAutoCollapseCategories",
"DontCollapseCategories",
"EarlyAccessPreview",
"Experimental",
"HideCategories",
"Interface",
"MinimalAPI",
"NoExport",
"NonTransient",
"NotBlueprintable",
"NotPlaceable",
"PerObjectConfig",
"Placeable",
"ShowCategories",
"SparseClassDataType",
"Transient",
"Within",
"meta",
];
const USTRUCT: &[&str] = &[
"Atomic",
"BlueprintType",
"Immutable",
"NoExport",
"SparseClassDataType",
"meta",
];
const UENUM: &[&str] = &["BlueprintType", "Experimental", "meta"];
const UINTERFACE: &[&str] = &[
"Blueprintable",
"Experimental",
"MinimalAPI",
"NotBlueprintable",
"meta",
];
const UPROPERTY: &[&str] = &[
"AdvancedDisplay",
"AssetRegistrySearchable",
"BlueprintAssignable",
"BlueprintCallable",
"BlueprintGetter",
"BlueprintHidden",
"BlueprintReadOnly",
"BlueprintReadWrite",
"BlueprintSetter",
"Category",
"Config",
"DuplicateTransient",
"EditAnywhere",
"EditDefaultsOnly",
"EditFixedSize",
"EditInline",
"EditInstanceOnly",
"Export",
"GlobalConfig",
"HideAlphaChannel",
"HidePin",
"Instanced",
"Interp",
"Localized",
"NoClear",
"NoExport",
"NonPIEDuplicateTransient",
"NonTransactional",
"PersistentInstance",
"RepNotify",
"Replicated",
"ReplicatedUsing",
"SaveGame",
"SerializeText",
"SimpleDisplay",
"SkipSerialization",
"TextExportTransient",
"Transient",
"VisibleAnywhere",
"VisibleDefaultsOnly",
"VisibleInstanceOnly",
"ZeroConstructor",
"meta",
];
const UFUNCTION: &[&str] = &[
"BlueprintAuthorityOnly",
"BlueprintCallable",
"BlueprintCosmetic",
"BlueprintImplementableEvent",
"BlueprintNativeEvent",
"BlueprintPure",
"CallInEditor",
"Category",
"Client",
"CustomThunk",
"Exec",
"NetMulticast",
"Reliable",
"SealedEvent",
"Server",
"ServiceRequest",
"ServiceResponse",
"Unreliable",
"WithValidation",
"meta",
];
match macro_name {
"UCLASS" => Some(UCLASS),
"USTRUCT" => Some(USTRUCT),
"UENUM" => Some(UENUM),
"UINTERFACE" => Some(UINTERFACE),
"UPROPERTY" => Some(UPROPERTY),
"UFUNCTION" => Some(UFUNCTION),
_ => None,
}
}
pub fn generated_members(class_name: &str, bases: &[String]) -> Vec<(&'static str, String)> {
let mut members = vec![("ThisClass", class_name.to_string())];
if let Some(base) = bases.first() {
members.push(("Super", base.clone()));
}
members
}
fn generated_include_directories(root: &Path) -> Vec<PathBuf> {
let build = root.join("Intermediate/Build");
let Ok(platforms) = std::fs::read_dir(&build) else {
return Vec::new();
};
let mut platforms: Vec<PathBuf> = platforms
.filter_map(|entry| entry.ok().map(|entry| entry.path()))
.filter(|path| path.is_dir())
.collect();
platforms.sort();
let mut directories = Vec::new();
for platform in platforms {
let Ok(configurations) = std::fs::read_dir(&platform) else {
continue;
};
let mut configurations: Vec<PathBuf> = configurations
.filter_map(|entry| entry.ok().map(|entry| entry.path()))
.filter(|path| path.is_dir())
.collect();
configurations.sort();
for configuration in configurations {
let inc = configuration.join("Inc");
let Ok(modules) = std::fs::read_dir(&inc) else {
continue;
};
let mut modules: Vec<PathBuf> = modules
.filter_map(|entry| entry.ok().map(|entry| entry.path()))
.filter(|path| path.is_dir())
.collect();
modules.sort();
for module in modules {
let uht = module.join("UHT");
if uht.is_dir() {
directories.push(uht);
}
directories.push(module);
}
}
}
directories
}
fn engine_include_directories(engine: &Path) -> Vec<PathBuf> {
let runtime = engine.join("Engine/Source/Runtime");
if !runtime.is_dir() {
return vec![engine.to_path_buf()];
}
let mut modules: Vec<PathBuf> = std::fs::read_dir(&runtime)
.map(|entries| {
entries
.filter_map(|entry| entry.ok().map(|entry| entry.path()))
.filter(|path| path.is_dir())
.collect()
})
.unwrap_or_default();
modules.sort();
let mut directories = Vec::new();
for module in modules {
for relative in ["Public", "Classes"] {
let directory = module.join(relative);
if directory.is_dir() {
directories.push(directory);
}
}
}
directories
}
fn engine_defines() -> Vec<(&'static str, &'static str)> {
let mut defines = vec![
("WITH_EDITOR", "1"),
("WITH_EDITORONLY_DATA", "1"),
("WITH_ENGINE", "1"),
("UE_BUILD_DEVELOPMENT", "1"),
("UE_SERVER", "0"),
("IS_PROGRAM", "0"),
];
if cfg!(windows) {
defines.push(("PLATFORM_WINDOWS", "1"));
defines.push(("PLATFORM_DESKTOP", "1"));
} else if cfg!(target_os = "macos") {
defines.push(("PLATFORM_MAC", "1"));
defines.push(("PLATFORM_DESKTOP", "1"));
} else {
defines.push(("PLATFORM_LINUX", "1"));
defines.push(("PLATFORM_DESKTOP", "1"));
}
defines
}
fn define_if_absent(config: &mut crate::include::config::CompilerConfig, name: &str, value: &str) {
let taken = config
.defines
.iter()
.any(|defined| defined.name.as_ref() == name)
|| config
.undefines
.iter()
.any(|undefined| undefined.as_ref() == name);
if taken {
return;
}
let value = if value.is_empty() { None } else { Some(value) };
config.defines.push(match value {
Some(value) => {
crate::include::config::CommandLineMacro::with_value(name.to_string(), value)
}
None => crate::include::config::CommandLineMacro::with_value(name.to_string(), ""),
});
}
fn game_modules(root: &Path) -> Vec<String> {
let uproject = match std::fs::read_dir(root) {
Ok(entries) => entries
.filter_map(|entry| entry.ok().map(|entry| entry.path()))
.find(|path| {
path.extension()
.is_some_and(|extension| extension == "uproject")
}),
Err(_) => None,
};
let Some(uproject) = uproject else {
return Vec::new();
};
let Ok(text) = std::fs::read_to_string(&uproject) else {
return Vec::new();
};
module_names_in(&text)
}
fn module_names_in(text: &str) -> Vec<String> {
let mut names = Vec::new();
let Some(modules) = text.find("\"Modules\"") else {
return names;
};
let Some(open) = text[modules..].find('[').map(|at| modules + at) else {
return names;
};
let mut depth = 0usize;
let mut index = open;
let bytes = text.as_bytes();
while index < bytes.len() {
match bytes[index] {
b'[' => depth += 1,
b']' => {
depth -= 1;
if depth == 0 {
break;
}
}
b'"' => {
let start = index + 1;
let Some(end) = text[start..].find('"').map(|at| start + at) else {
break;
};
let word = &text[start..end];
if word == "Name" {
let rest = &text[end + 1..];
if let Some(value) = quoted_value_after_colon(rest) {
names.push(value);
}
}
index = end;
}
_ => {}
}
index += 1;
}
names
}
fn quoted_value_after_colon(rest: &str) -> Option<String> {
let rest = rest.trim_start();
let rest = rest.strip_prefix(':')?.trim_start();
let rest = rest.strip_prefix('"')?;
let end = rest.find('"')?;
Some(rest[..end].to_string())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_uprojects_modules_are_read() {
let text = "{\n \"FileVersion\": 3,\n \"Modules\": [\n { \"Name\": \"MyGame\", \"Type\": \"Runtime\" },\n \
{ \"Name\": \"MyGameEditor\", \"Type\": \"Editor\" }\n ]\n}\n";
assert_eq!(module_names_in(text), vec!["MyGame", "MyGameEditor"]);
}
#[test]
fn a_file_without_modules_names_none() {
assert!(module_names_in("{\"FileVersion\": 3}").is_empty());
assert!(module_names_in("").is_empty());
}
#[test]
fn an_engine_root_with_the_real_layout_offers_its_modules() {
let root = std::env::temp_dir().join(format!("cppls_ue_engine_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(root.join("Engine/Source/Runtime/Core/Public")).expect("a tree");
std::fs::create_dir_all(root.join("Engine/Source/Runtime/Engine/Public")).expect("a tree");
std::fs::create_dir_all(root.join("Engine/Source/Runtime/Engine/Classes")).expect("a tree");
let directories = engine_include_directories(&root);
assert_eq!(
directories,
vec![
root.join("Engine/Source/Runtime/Core/Public"),
root.join("Engine/Source/Runtime/Engine/Public"),
root.join("Engine/Source/Runtime/Engine/Classes"),
]
);
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn a_built_projects_generated_directories_are_found() {
let root = std::env::temp_dir().join(format!("cppls_ue_uht_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
let editor = root.join("Intermediate/Build/Win64/UnrealEditor/Inc/Game/UHT");
let development = root.join("Intermediate/Build/Win64/Development/Inc/Other");
std::fs::create_dir_all(&editor).expect("the UHT directory");
std::fs::create_dir_all(&development).expect("a second configuration");
let directories = generated_include_directories(&root);
assert!(directories.contains(&editor), "{directories:?}");
assert!(
directories.contains(&root.join("Intermediate/Build/Win64/Development/Inc/Other")),
"a module's own directory is offered too: {directories:?}"
);
let empty = std::env::temp_dir().join(format!("cppls_ue_unbuilt_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&empty);
std::fs::create_dir_all(&empty).expect("an empty project");
assert!(generated_include_directories(&empty).is_empty());
let _ = std::fs::remove_dir_all(&root);
let _ = std::fs::remove_dir_all(&empty);
}
#[test]
fn a_plain_header_directory_is_an_include_root() {
let root = std::env::temp_dir().join(format!("cppls_ue_stub_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).expect("a tree");
assert_eq!(engine_include_directories(&root), vec![root.clone()]);
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn a_project_that_names_the_engine_is_engine_code() {
let section = UnrealSection {
enable: false,
engine: Some(PathBuf::from("Engine")),
};
assert!(section.is_on());
let off = UnrealSection::default();
assert!(!off.is_on());
}
}