public UnrealModuleInfo(UPackage package, string name, string path)
{
Package = package;
Name = name;
Path = path;
Type = GetModuleType(path);
}
public UnrealModuleInfo(UPackage package, string name, string path, UnrealModuleType type)
{
Package = package;
Name = name;
Path = path;
Type = type;
}
public UnrealModuleInfo(UPackage package, string name, string path)
: this(package, name, path, UnrealModuleType.Unknown)
{
IPlugin[] plugins = IPluginManager.Instance.GetDiscoveredPlugins();
Type = GetModuleType(name, path, plugins);
IPlugin.Dispose(plugins);
}
/// <summary>
/// Loads a package and all contained objects that match context flags.
/// </summary>
/// <param name="outer">Package to load new package into (usually NULL or ULevel->GetOuter())</param>
/// <param name="longPackageName">Long package name to load</param>
/// <param name="loadFlags">Flags controlling loading behavior</param>
/// <returns>Loaded package if successful, NULL otherwise</returns>
public static UPackage LoadPackage(UPackage outer, string longPackageName, ELoadFlags loadFlags)
{
using (FStringUnsafe longPackageNameUnsafe = new FStringUnsafe(longPackageName))
{
return(GCHelper.Find <UPackage>(Native_UObjectGlobals.LoadPackage(
outer == null ? IntPtr.Zero : outer.Address, ref longPackageNameUnsafe.Array, loadFlags)));
}
}
/// <summary>
/// Converts package name to short name.
/// </summary>
/// <param name="package">Package which name to convert.</param>
/// <returns>Short package name.</returns>
public static string GetShortName(UPackage package)
{
using (FStringUnsafe resultUnsafe = new FStringUnsafe())
{
Native_FPackageName.GetShortNameFromPackage(package == null ? IntPtr.Zero : package.Address, ref resultUnsafe.Array);
return(resultUnsafe.Value);
}
}
public UPackage GetPackage()
{
if (PackageName == FName.None)
{
return(null);
}
UPackage package = UObject.FindPackage(null, PackageName.ToString());
if (package != null)
{
package.FullyLoad();
}
else
{
package = UObject.LoadPackage(null, PackageName.ToString(), ELoadFlags.None);
}
return(package);
}
public void GenerateCodeForModule(string moduleName, bool loadModule)
{
string longPackageName = FPackageName.ConvertToLongScriptPackageName(moduleName);
UPackage package = UObject.FindObjectFast <UPackage>(null, new FName(longPackageName), false, false);
if (package == null && !FModuleManager.Instance.IsModuleLoaded(new FName(moduleName)))
{
// package is almost always non-null even when IsModuleLoaded returns false - if the package is non-null it
// seems the module types are available so we don't have to call LoadModule (check if this is always true)
if (!loadModule)
{
return;
}
EModuleLoadResult loadResult;
FModuleManager.Instance.LoadModuleWithFailureReason(new FName(moduleName), out loadResult);
if (loadResult != EModuleLoadResult.Success)
{
FMessage.Log("Failed to load module '" + moduleName + "'. Reason: " + loadResult);
return;
}
package = UObject.FindObjectFast <UPackage>(null, new FName(longPackageName), false, false);
}
if (package != null)
{
Dictionary <FName, string> modulePaths = FModulesPaths.FindModulePaths("*");
string modulePath;
if (!modulePaths.TryGetValue(new FName(moduleName), out modulePath))
{
return;
}
BeginGenerateModules();
GenerateCodeForModule(new UnrealModuleInfo(package, moduleName, modulePath));
EndGenerateModules();
}
}
private string GetModuleName(UField field, out UnrealModuleType moduleType, out UnrealModuleType moduleAssetType)
{
moduleType = UnrealModuleType.Unknown;
moduleAssetType = UnrealModuleType.Unknown;
UPackage package = field.GetOutermost();
if (package != null)
{
CachedNamespace cachedNamespace;
if (!namespaceCache.TryGetValue(package, out cachedNamespace))
{
GetModuleNamespace(field);
namespaceCache.TryGetValue(package, out cachedNamespace);
}
if (cachedNamespace != null)
{
moduleType = cachedNamespace.ModuleType;
moduleAssetType = cachedNamespace.ModuleAssetType;
return(cachedNamespace.ModuleName);
}
}
return(null);
}
private static UPackage FindOrLoadPackage(string pathName)
{
// If there is a dot, remove it.
int packageDelimPos = pathName.IndexOf('.');
if (packageDelimPos != -1)
{
pathName = pathName.Remove(packageDelimPos, 1);
}
// Find the package in memory.
UPackage package = UObject.FindPackage(null, pathName);
if (package == null)
{
// If it is not in memory, try to load it.
package = UObject.LoadPackage(null, pathName, ELoadFlags.None);
}
if (package != null)
{
package.AddToRoot();
}
return(package);
}
public void GenerateCodeForModules(UnrealModuleType[] moduleTypes)
{
BeginGenerateModules();
HashSet <string> moduleNamesWhitelistToLower = new HashSet <string>();
foreach (string moduleName in ModulesNamesWhitelist)
{
moduleNamesWhitelistToLower.Add(moduleName.ToLower());
}
HashSet <string> moduleNamesBlacklistToLower = new HashSet <string>();
foreach (string moduleName in ModulesNamesBlacklist)
{
moduleNamesBlacklistToLower.Add(moduleName.ToLower());
}
Dictionary <UPackage, List <UStruct> > structsByPackage = new Dictionary <UPackage, List <UStruct> >();
Dictionary <UPackage, List <UEnum> > enumsByPackage = new Dictionary <UPackage, List <UEnum> >();
Dictionary <UPackage, List <UFunction> > globalFunctionsByPackage = new Dictionary <UPackage, List <UFunction> >();
foreach (UStruct unrealStruct in new TObjectIterator <UStruct>())
{
if (!unrealStruct.IsA <UFunction>() && CanExportStruct(unrealStruct) && IsAvailableType(unrealStruct))
{
UPackage package = unrealStruct.GetOutermost();
if (package != null)
{
List <UStruct> structs;
if (!structsByPackage.TryGetValue(package, out structs))
{
structsByPackage.Add(package, structs = new List <UStruct>());
}
structs.Add(unrealStruct);
}
}
}
foreach (UEnum unrealEnum in new TObjectIterator <UEnum>())
{
if (CanExportEnum(unrealEnum) && IsAvailableType(unrealEnum))
{
UPackage package = unrealEnum.GetOutermost();
if (package != null)
{
List <UEnum> enums;
if (!enumsByPackage.TryGetValue(package, out enums))
{
enumsByPackage.Add(package, enums = new List <UEnum>());
}
enums.Add(unrealEnum);
}
}
}
UClass packageClass = UClass.GetClass <UPackage>();
foreach (UFunction function in new TObjectIterator <UFunction>())
{
UObject outer = function.GetOuter();
if (outer == null || outer.GetClass() != packageClass)
{
continue;
}
if (function.HasAnyFunctionFlags(EFunctionFlags.Delegate | EFunctionFlags.MulticastDelegate))
{
UPackage package = function.GetOutermost();
if (package != null)
{
List <UFunction> functions;
if (!globalFunctionsByPackage.TryGetValue(package, out functions))
{
globalFunctionsByPackage.Add(package, functions = new List <UFunction>());
}
functions.Add(function);
}
}
else
{
FMessage.Log(ELogVerbosity.Error, string.Format("Global function which isn't a delegate '{0}'", function.GetName()));
}
}
Dictionary <FName, string> modulePaths = FModulesPaths.FindModulePaths("*");
// Make sure ModulePaths and ModuleNames are the same. Based on comments FindModules may be changed/removed in the
// future so we will want to just use FindModulePaths. For now make sure they are synced up.
FName[] moduleNames = FModuleManager.Get().FindModules("*");
if (moduleNames.Length != modulePaths.Count)
{
FMessage.Log(ELogVerbosity.Warning, string.Format("Module count invalid (update FModulePaths). FindModules:{0} FindModulePaths:{1}",
moduleNames.Length, modulePaths.Count));
List <FName> additionalNames = new List <FName>();
foreach (KeyValuePair <FName, string> module in modulePaths)
{
if (moduleNames.Contains(module.Key))
{
FMessage.Log(ELogVerbosity.Warning, "Module: " + module.Key + " - " + module.Value);
}
else
{
FMessage.Log(ELogVerbosity.Warning, "Additional module: " + module.Key + " - " + module.Value);
}
}
List <FName> missingNames = new List <FName>();
foreach (FName moduleName in moduleNames)
{
if (!modulePaths.ContainsKey(moduleName))
{
FMessage.Log(ELogVerbosity.Warning, "Missing module: " + moduleName);
}
}
}
IPlugin[] plugins = IPluginManager.Instance.GetDiscoveredPlugins();
SlowTaskSetModuleCount(modulePaths.Count);
foreach (KeyValuePair <FName, string> modulePath in modulePaths)
{
SlowTaskBeginModule(modulePath.Key.PlainName);
string moduleName = modulePath.Key.PlainName;
string longPackageName = FPackageName.ConvertToLongScriptPackageName(moduleName);
UPackage package = UObject.FindObjectFast <UPackage>(null, new FName(longPackageName), false, false);
if (package != null)
{
UnrealModuleInfo moduleInfo = new UnrealModuleInfo(package, moduleName, modulePath.Value,
UnrealModuleInfo.GetModuleType(moduleName, modulePath.Value, plugins));
if (moduleInfo.Type == UnrealModuleType.Unknown)
{
FMessage.Log(ELogVerbosity.Error, string.Format("Unknown module type on module '{0}' '{1}'",
moduleInfo.Name, moduleInfo.Package));
}
else if (!moduleTypes.Contains(moduleInfo.Type) || moduleNamesBlacklistToLower.Contains(moduleInfo.Name.ToLower()) ||
(moduleNamesWhitelistToLower.Count > 0 && !moduleNamesWhitelistToLower.Contains(moduleInfo.Name.ToLower())))
{
continue;
}
List <UStruct> structs;
if (!structsByPackage.TryGetValue(package, out structs))
{
structs = new List <UStruct>();
}
List <UEnum> enums;
if (!enumsByPackage.TryGetValue(package, out enums))
{
enums = new List <UEnum>();
}
List <UFunction> globalFunctions;
if (!globalFunctionsByPackage.TryGetValue(package, out globalFunctions))
{
globalFunctions = new List <UFunction>();
}
SlowTaskUpdateTarget(structs.Count + enums.Count + globalFunctions.Count);
GenerateCodeForModule(moduleInfo, structs.ToArray(), enums.ToArray(), globalFunctions.ToArray());
}
}
IPlugin.Dispose(plugins);
EndGenerateModules();
}
private string GetModuleNamespace(UField field, out UnrealModuleType moduleAssetType, bool allowFoldersAsNamespace = true)
{
moduleAssetType = UnrealModuleType.Unknown;
UPackage package = field.GetOutermost();
if (package != null)
{
CachedNamespace cachedNamespace;
if (namespaceCache.TryGetValue(package, out cachedNamespace))
{
moduleAssetType = cachedNamespace.ModuleAssetType;
return(cachedNamespace.Namespace);
}
UnrealModuleType moduleType = UnrealModuleType.Unknown;
moduleAssetType = UnrealModuleType.Unknown;
string packageFilename = package.FileName.ToString();
if (string.IsNullOrEmpty(packageFilename.ToString()) || packageFilename == FName.None.ToString())
{
packageFilename = field.GetPathName();
}
string moduleName = FPackageName.GetShortName(package.GetName());
if (packageFilename.StartsWith("/Script"))
{
if (!modulesByName.TryGetValue(new FName(moduleName), out moduleType))
{
moduleType = UnrealModuleType.Unknown;
FMessage.Log(ELogVerbosity.Error, string.Format("Failed to find module for module '{0}'", moduleName));
}
}
else if (packageFilename.StartsWith("/Game/"))
{
moduleType = UnrealModuleType.Game;
moduleAssetType = UnrealModuleType.Game;
moduleName = FPaths.GetBaseFilename(FPaths.ProjectFilePath);// {Module} same as {Game}
}
else if (packageFilename.StartsWith("/Engine/"))
{
moduleType = UnrealModuleType.Game;
moduleAssetType = UnrealModuleType.Engine;
moduleName = Settings.Namespaces.Default;
}
else
{
string rootName = null;
if (packageFilename.Length > 1 && packageFilename[0] == '/')
{
int slashIndex = packageFilename.IndexOf('/', 1);
if (slashIndex >= 0)
{
rootName = packageFilename.Substring(1, slashIndex - 1);
moduleName = rootName;// Update ModuleName for {Module}
if (!modulesByName.TryGetValue(new FName(rootName), out moduleAssetType))
{
moduleAssetType = UnrealModuleType.Unknown;
}
}
}
if (moduleAssetType == UnrealModuleType.Unknown)
{
FMessage.Log(ELogVerbosity.Error, string.Format("Unknown module asset type root:'{0}' path:'{1}' name:'{2}' path2:'{3}'",
rootName, packageFilename, field.GetName(), field.GetPathName()));
}
moduleType = UnrealModuleType.Game;
}
if (moduleType != UnrealModuleType.Unknown)
{
string namespaceName = GetModuleNamespace(moduleType, moduleName, moduleAssetType, allowFoldersAsNamespace, packageFilename);
namespaceCache[package] = new CachedNamespace(namespaceName, moduleName, moduleType, moduleAssetType);
return(namespaceName);
}
else
{
FMessage.Log(ELogVerbosity.Error, string.Format("Unknown module type {0} {1}", packageFilename, moduleName));
}
}
return(null);
}