void FBlueprintNativeCodeGenModule::GenerateSingleAsset(UField* ForConversion, const TCHAR* PlatformName, TSharedPtr<FNativizationSummary> NativizationSummary)
{
IBlueprintCompilerCppBackendModule& BackEndModule = (IBlueprintCompilerCppBackendModule&)IBlueprintCompilerCppBackendModule::Get();
auto& BackendPCHQuery = BackEndModule.OnPCHFilenameQuery();
const IAssetRegistry& Registry = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry").Get();
FAssetData AssetInfo = Registry.GetAssetByObjectPath(*ForConversion->GetPathName());
FBlueprintNativeCodeGenPaths TargetPaths = GetManifest(PlatformName).GetTargetPaths();
BackendPCHQuery.BindLambda([TargetPaths]()->FString
{
return TargetPaths.RuntimePCHFilename();
});
FConvertedAssetRecord& ConversionRecord = GetManifest(PlatformName).CreateConversionRecord(*ForConversion->GetPathName(), AssetInfo);
TSharedPtr<FString> HeaderSource(new FString());
TSharedPtr<FString> CppSource(new FString());
FBlueprintNativeCodeGenUtils::GenerateCppCode(ForConversion, HeaderSource, CppSource, NativizationSummary);
bool bSuccess = !HeaderSource->IsEmpty() || !CppSource->IsEmpty();
// Run the cpp first, because we cue off of the presence of a header for a valid conversion record (see
// FConvertedAssetRecord::IsValid)
if (!CppSource->IsEmpty())
{
if (!FFileHelper::SaveStringToFile(*CppSource, *ConversionRecord.GeneratedCppPath, ForcedEncoding()))
{
bSuccess &= false;
ConversionRecord.GeneratedCppPath.Empty();
}
CppSource->Empty(CppSource->Len());
}
else
{
ConversionRecord.GeneratedCppPath.Empty();
}
if (bSuccess && !HeaderSource->IsEmpty())
{
if (!FFileHelper::SaveStringToFile(*HeaderSource, *ConversionRecord.GeneratedHeaderPath, ForcedEncoding()))
{
bSuccess &= false;
ConversionRecord.GeneratedHeaderPath.Empty();
}
HeaderSource->Empty(HeaderSource->Len());
}
else
{
ConversionRecord.GeneratedHeaderPath.Empty();
}
if (bSuccess)
{
GetManifest(PlatformName).GatherModuleDependencies(ForConversion->GetOutermost());
}
else
{
UE_LOG(LogBlueprintCodeGen, Error, TEXT("FBlueprintNativeCodeGenModule::GenerateSingleAsset error: %s"), *GetPathNameSafe(ForConversion));
}
BackendPCHQuery.Unbind();
}
//------------------------------------------------------------------------------
static bool BlueprintNativeCodeGenUtilsImpl::GeneratePluginDescFile(const FString& PluginName, const FBlueprintNativeCodeGenPaths& TargetPaths)
{
FPluginDescriptor PluginDesc;
PluginDesc.FriendlyName = PluginName;
PluginDesc.CreatedBy = TEXT("Epic Games, Inc.");
PluginDesc.CreatedByURL = TEXT("http://epicgames.com");
PluginDesc.Description = TEXT("A programatically generated plugin which contains source files produced from Blueprint assets. The aim of this is to help performance by eliminating script overhead for the converted assets (using the source files in place of thier coresponding assets).");
PluginDesc.DocsURL = TEXT("@TODO");
PluginDesc.SupportURL = TEXT("https://answers.unrealengine.com/");
PluginDesc.Category = TEXT("Intermediate");
PluginDesc.bEnabledByDefault = true;
PluginDesc.bCanContainContent = false;
PluginDesc.bIsBetaVersion = true; // @TODO: change once we're confident in the feature
FModuleDescriptor RuntimeModuleDesc;
RuntimeModuleDesc.Name = *TargetPaths.RuntimeModuleName();
RuntimeModuleDesc.Type = EHostType::Runtime;
// load at startup (during engine init), after game modules have been loaded
RuntimeModuleDesc.LoadingPhase = ELoadingPhase::Default;
PluginDesc.Modules.Add(RuntimeModuleDesc);
FText ErrorMessage;
bool bSuccess = PluginDesc.Save(TargetPaths.PluginFilePath(), ErrorMessage);
if (!bSuccess)
{
UE_LOG(LogBlueprintCodeGen, Error, TEXT("Failed to generate the plugin description file: %s"), *ErrorMessage.ToString());
}
return bSuccess;
}
//------------------------------------------------------------------------------
static bool BlueprintNativeCodeGenUtilsImpl::GenerateModuleSourceFiles(const FBlueprintNativeCodeGenPaths& TargetPaths)
{
FText FailureReason;
TArray<FString> PchIncludes;
PchIncludes.Add(EngineHeaderFile);
PchIncludes.Add(TEXT("GeneratedCodeHelpers.h"));
TArray<FString> FilesToIncludeInModuleHeader;
GConfig->GetArray(TEXT("BlueprintNativizationSettings"), TEXT("FilesToIncludeInModuleHeader"), FilesToIncludeInModuleHeader, GEditorIni);
PchIncludes.Append(FilesToIncludeInModuleHeader);
bool bSuccess = GameProjectUtils::GeneratePluginModuleHeaderFile(TargetPaths.RuntimeModuleFile(FBlueprintNativeCodeGenPaths::HFile), PchIncludes, FailureReason);
if (bSuccess)
{
const FString NoStartupCode = TEXT("");
bSuccess &= GameProjectUtils::GeneratePluginModuleCPPFile(TargetPaths.RuntimeModuleFile(FBlueprintNativeCodeGenPaths::CppFile),
TargetPaths.RuntimeModuleName(), NoStartupCode, FailureReason);
}
if (!bSuccess)
{
UE_LOG(LogBlueprintCodeGen, Error, TEXT("Failed to generate module source files: %s"), *FailureReason.ToString());
}
return bSuccess;
}
//------------------------------------------------------------------------------
bool FBlueprintNativeCodeGenUtils::FinalizePlugin(const FBlueprintNativeCodeGenManifest& Manifest)
{
bool bSuccess = true;
FBlueprintNativeCodeGenPaths TargetPaths = Manifest.GetTargetPaths();
bSuccess = bSuccess && BlueprintNativeCodeGenUtilsImpl::GenerateModuleBuildFile(Manifest);
bSuccess = bSuccess && BlueprintNativeCodeGenUtilsImpl::GenerateModuleSourceFiles(TargetPaths);
bSuccess = bSuccess && BlueprintNativeCodeGenUtilsImpl::GeneratePluginDescFile(TargetPaths.RuntimeModuleName(), TargetPaths);
return bSuccess;
}
//------------------------------------------------------------------------------
static bool BlueprintNativeCodeGenUtilsImpl::GenerateModuleBuildFile(const FBlueprintNativeCodeGenManifest& Manifest)
{
FModuleManager& ModuleManager = FModuleManager::Get();
TArray<FString> PublicDependencies;
// for IModuleInterface
PublicDependencies.Add(CoreModuleName);
// for Engine.h
PublicDependencies.Add(EngineModuleName);
if (GameProjectUtils::ProjectHasCodeFiles())
{
const FString GameModuleName = FApp::GetGameName();
if (ModuleManager.ModuleExists(*GameModuleName))
{
PublicDependencies.Add(GameModuleName);
}
}
TArray<FString> AdditionalPublicDependencyModuleNames;
GConfig->GetArray(TEXT("BlueprintNativizationSettings"), TEXT("AdditionalPublicDependencyModuleNames"), AdditionalPublicDependencyModuleNames, GEditorIni);
PublicDependencies.Append(AdditionalPublicDependencyModuleNames);
TArray<FString> PrivateDependencies;
const TArray<UPackage*>& ModulePackages = Manifest.GetModuleDependencies();
PrivateDependencies.Reserve(ModulePackages.Num());
for (UPackage* ModulePkg : ModulePackages)
{
const FString PkgModuleName = FPackageName::GetLongPackageAssetName(ModulePkg->GetName());
if (ModuleManager.ModuleExists(*PkgModuleName))
{
if (!PublicDependencies.Contains(PkgModuleName))
{
PrivateDependencies.Add(PkgModuleName);
}
}
else
{
UE_LOG(LogBlueprintCodeGen, Warning, TEXT("Failed to find module for package: %s"), *PkgModuleName);
}
}
FBlueprintNativeCodeGenPaths TargetPaths = Manifest.GetTargetPaths();
FText ErrorMessage;
bool bSuccess = GameProjectUtils::GenerateGameModuleBuildFile(TargetPaths.RuntimeBuildFile(), TargetPaths.RuntimeModuleName(),
PublicDependencies, PrivateDependencies, ErrorMessage);
if (!bSuccess)
{
UE_LOG(LogBlueprintCodeGen, Error, TEXT("Failed to generate module build file: %s"), *ErrorMessage.ToString());
}
return bSuccess;
}
//------------------------------------------------------------------------------
static bool BlueprintNativeCodeGenUtilsImpl::WipeTargetPaths(const FBlueprintNativeCodeGenPaths& TargetPaths)
{
IFileManager& FileManager = IFileManager::Get();
bool bSuccess = true;
bSuccess &= FileManager.Delete(*TargetPaths.PluginFilePath());
bSuccess &= FileManager.DeleteDirectory(*TargetPaths.PluginSourceDir(), /*RequireExists =*/false, /*Tree =*/true);
bSuccess &= FileManager.Delete(*TargetPaths.ManifestFilePath());
return bSuccess;
}
//------------------------------------------------------------------------------
static bool BlueprintNativeCodeGenUtilsImpl::GenerateModuleSourceFiles(const FBlueprintNativeCodeGenPaths& TargetPaths)
{
FText FailureReason;
TArray<FString> PchIncludes;
PchIncludes.Add(EngineHeaderFile);
bool bSuccess = GameProjectUtils::GeneratePluginModuleHeaderFile(TargetPaths.RuntimeModuleFile(FBlueprintNativeCodeGenPaths::HFile), PchIncludes, FailureReason);
if (bSuccess)
{
const FString NoStartupCode = TEXT("");
bSuccess &= GameProjectUtils::GeneratePluginModuleCPPFile(TargetPaths.RuntimeModuleFile(FBlueprintNativeCodeGenPaths::CppFile),
TargetPaths.RuntimeModuleName(), NoStartupCode, FailureReason);
}
if (!bSuccess)
{
UE_LOG(LogBlueprintCodeGen, Error, TEXT("Failed to generate module source files: %s"), *FailureReason.ToString());
}
return bSuccess;
}
