/// <summary> /// Constructor /// </summary> /// <param name="outer">value for LimitOuter</param> /// <param name="requireDirectOuter">Determines whether nested objects contained within LimitOuter are considered.</param> /// <param name="shouldIgnoreArchetype">whether to disable serialization of ObjectArchetype references</param> /// <param name="serializeRecursively">only applicable when LimitOuter != NULL && bRequireDirectOuter==true; /// serializes each object encountered looking for subobjects of referenced /// objects that have LimitOuter for their Outer (i.e. nested subobjects/components)</param> /// <param name="shouldIgnoreTransient">true to skip serialization of transient properties</param> public FReferenceFinder(IntPtr outer, bool requireDirectOuter = true, bool shouldIgnoreArchetype = false, bool serializeRecursively = false, bool shouldIgnoreTransient = false) { objArray = new TArrayUnsafe <IntPtr>(); address = Native_FReferenceFinder.New(objArray.Address, outer, requireDirectOuter, shouldIgnoreArchetype, serializeRecursively, shouldIgnoreTransient); }
/// <summary> /// Get the localization paths for all enabled plugins. /// </summary> /// <returns>The localization paths for all enabled plugins.</returns> public string[] GetLocalizationPathsForEnabledPlugins() { using (TArrayUnsafe <string> resultUnsafe = new TArrayUnsafe <string>()) { Native_IPluginManager.GetLocalizationPathsForEnabledPlugins(Address, resultUnsafe.Address); return(resultUnsafe.ToArray()); } }
/// <summary> /// Uses the TArchiveObjectReferenceCollector to build a list of all components referenced by this object which have this object as the outer /// </summary> /// <param name="includeNestedSubobjects">controls whether subobjects which are contained by this object, but do not have this object /// as its direct Outer should be included</param> /// <returns>the array that should be populated with the default subobjects "owned" by this object</returns> public UObject[] CollectDefaultSubobjects(bool includeNestedSubobjects = false) { using (TArrayUnsafe <UObject> result = new TArrayUnsafe <UObject>()) { Native_UObject.CollectDefaultSubobjects(Address, result.Address, includeNestedSubobjects); return(result.ToArray()); } }
/// <summary> /// Gets an array of plugins that loaded their own content pak file /// </summary> public IPlugin[] GetPluginsWithPakFile() { using (TArrayUnsafe <FSharedPtr> resultUnsafe = new TArrayUnsafe <FSharedPtr>()) { Native_IPluginManager.GetPluginsWithPakFile(Address, resultUnsafe.Address); return(GetPluginArray(resultUnsafe)); } }
/// <summary> /// Gets all default instanced objects (often components). /// </summary> /// <param name="outDefaultSubobjects">An array to be filled with default subobjects.</param> public void GetDefaultObjectSubobjects(out UObject[] outDefaultSubobjects) { using (TArrayUnsafe <UObject> defaultSubobjectsUnsafe = new TArrayUnsafe <UObject>()) { Native_UClass.GetDefaultObjectSubobjects(Address, defaultSubobjectsUnsafe.Address); outDefaultSubobjects = defaultSubobjectsUnsafe.ToArray(); } }
/// <summary> /// Returns an array of classes that were derived from the specified class. /// </summary> /// <param name="classToLookFor">The parent class of the classes to return.</param> /// <param name="recursive">If true, the results will include children of the children classes, recursively. Otherwise, only direct decedents will be included.</param> /// <returns></returns> public static UClass[] GetDerivedClasses(UClass classToLookFor, bool recursive = true) { using (TArrayUnsafe <UClass> result = new TArrayUnsafe <UClass>()) { Native_UObjectHash.GetDerivedClasses(classToLookFor.Address, result.Address, recursive); return(result.ToArray()); } }
/// <summary> /// Finds the common base class that parents the array of classes passed in. /// </summary> /// <param name="inClasses">the array of classes to find the common base for</param> /// <returns>the common base class or NULL</returns> public static UClass FindCommonBase(UClass[] inClasses) { using (TArrayUnsafe <UClass> inClassesUnsafe = new TArrayUnsafe <UClass>()) { inClassesUnsafe.AddRange(inClasses); return(GCHelper.Find <UClass>(Native_UClass.FindCommonBaseMany(inClassesUnsafe.Address))); } }
/// <summary> /// Queries all of the root content paths, like "/Game/", "/Engine/", and any dynamically added paths /// </summary> /// <returns>List of content paths</returns> public static string[] QueryRootContentPaths() { using (TArrayUnsafe <string> resultUnsafe = new TArrayUnsafe <string>()) { Native_FPackageName.QueryRootContentPaths(resultUnsafe.Address); return(resultUnsafe.ToArray()); } }
public void Execute(string[] args, UObject world, IntPtr outputDevice) { using (TArrayUnsafe <string> argsUnsafe = new TArrayUnsafe <string>()) { argsUnsafe.AddRange(args); Native_IConsoleCommand.Execute(Address, argsUnsafe.Address, world == null ? IntPtr.Zero : world.Address, outputDevice); } }
/// <summary> /// Return all objects with a given outer /// </summary> /// <param name="outer">Outer to search for</param> /// <param name="includeNestedObjects">If true, then things whose outers directly or indirectly have Outer as an outer are included, these are the nested objects.</param> /// <param name="exclusionFlags">Specifies flags to use as a filter for which objects to return</param> /// <param name="exclusionInternalFlags">Specifies internal flags to use as a filter for which objects to return</param> /// <returns></returns> public static UObject[] GetObjectsWithOuter(UObject outer, bool includeNestedObjects = true, EObjectFlags exclusionFlags = EObjectFlags.NoFlags, EInternalObjectFlags exclusionInternalFlags = EInternalObjectFlags.None) { using (TArrayUnsafe <UObject> result = new TArrayUnsafe <UObject>()) { Native_UObjectHash.GetObjectsWithOuter(outer.Address, result.Address, includeNestedObjects, exclusionFlags, exclusionInternalFlags); return(result.ToArray()); } }
/// <summary> /// Returns an array of objects of a specific class. Optionally, results can include objects of derived classes as well. /// </summary> /// <param name="classToLookFor">Class of the objects to return.</param> /// <param name="includeDerivedClasses">If true, the results will include objects of child classes as well.</param> /// <param name="additionalExcludeFlags">Objects with any of these flags will be excluded from the results.</param> /// <param name="exclusionInternalFlags">Specifies internal flags to use as a filter for which objects to return</param> /// <returns></returns> public static UObject[] GetObjectsOfClass(UClass classToLookFor, bool includeDerivedClasses = true, EObjectFlags additionalExcludeFlags = EObjectFlags.ClassDefaultObject, EInternalObjectFlags exclusionInternalFlags = EInternalObjectFlags.None) { using (TArrayUnsafe <UObject> result = new TArrayUnsafe <UObject>()) { Native_UObjectHash.GetObjectsOfClass(classToLookFor.Address, result.Address, includeDerivedClasses, additionalExcludeFlags, exclusionInternalFlags); return(result.ToArray()); } }
private static void SetAllMetaData(IntPtr obj, ManagedUnrealReflectionBase field, UMeta.Target target) { if (!FBuild.WithEditor || !metaDataEnabled || field == null || string.IsNullOrEmpty(field.Path)) { return; } IntPtr outermost = Native_UObjectBaseUtility.GetOutermost(obj); IntPtr metadata = outermost == IntPtr.Zero ? IntPtr.Zero : Native_UPackage.GetMetaData(outermost); if (metadata == IntPtr.Zero) { return; } Dictionary <FName, string> values = null; if (!metaDataMap.TryGetValue(field.Path.ToLower(), out values)) { values = new Dictionary <FName, string>(); } switch (target) { // Class / interface case UMeta.Target.Class: case UMeta.Target.Interface: // See GetMetadataKeyword (Engine\Source\Programs\UnrealHeaderTool\Private\BaseParser.cpp) // "NotBlueprintable" removes "NotBlueprintable" and adds "IsBlueprintBase=false" // "Blueprintable" and adds "IsBlueprintBase=true" // "BlueprintInternalUseOnly" adds "BlueprintType" if (!values.ContainsKey(UMeta.GetKeyName(MDClass.IsBlueprintBase))) { if (values.ContainsKey(UMeta.GetKeyName(MDClass.Blueprintable))) { values[UMeta.GetKeyName(MDClass.IsBlueprintBase)] = "true"; } else if (values.ContainsKey(UMeta.GetKeyName(MDClass.NotBlueprintable))) { values[UMeta.GetKeyName(MDClass.IsBlueprintBase)] = "false"; } } MetaDataMergeClassCategories(metadata, obj, values); break; } SetMetaDataBlueprintability(values, target, field as ManagedUnrealTypeInfo); using (TArrayUnsafe <FName> keysUnsafe = new TArrayUnsafe <FName>()) using (TArrayUnsafe <string> valuesUnsafe = new TArrayUnsafe <string>()) { keysUnsafe.AddRange(values.Keys.ToArray()); valuesUnsafe.AddRange(values.Values.ToArray()); Native_UMetaData.SetObjectValues(metadata, obj, keysUnsafe.Address, valuesUnsafe.Address); } }
/// <summary> /// Utility functions to query the object name redirects list for previous names for a class /// </summary> /// <param name="currentClassPath">The current name of the class, with a full path</param> /// <param name="isInstance">If true, we're an instance, so check instance only maps as well</param> /// <returns>Names without path of all classes that were redirected to this name. Empty if none found.</returns> public static unsafe FName[] FindPreviousNamesForClass(string currentClassPath, bool isInstance) { using (FStringUnsafe currentClassPathUnsafe = new FStringUnsafe(currentClassPath)) using (TArrayUnsafe <FName> resultUnsafe = new TArrayUnsafe <FName>()) { Native_FLinkerLoad.FindPreviousNamesForClass(ref currentClassPathUnsafe.Array, isInstance, resultUnsafe.Address); return(resultUnsafe.ToArray()); } }
/// <summary> /// Finds module files on the disk for loadable modules matching the specified wildcard. /// </summary> /// <param name="wildcardWithoutExtension">Filename part (no path, no extension, no build config info) to search for.</param> /// <returns>List of modules found.</returns> public FName[] FindModules(string wildcardWithoutExtension) { using (FStringUnsafe wildcardWithoutExtensionUnsafe = new FStringUnsafe(wildcardWithoutExtension)) using (TArrayUnsafe <FName> modulesUnsafe = new TArrayUnsafe <FName>()) { Native_FModuleManager.FindModules(Address, ref wildcardWithoutExtensionUnsafe.Array, modulesUnsafe.Address); return(modulesUnsafe.ToArray()); } }
public string[] GetConsoleHistory(string key) { using (FStringUnsafe keyUnsafe = new FStringUnsafe(key)) using (TArrayUnsafe <string> result = new TArrayUnsafe <string>()) { Native_IConsoleManager.GetConsoleHistory(Address, ref keyUnsafe.Array, result.Address); return(result.ToArray()); } }
/// <summary> /// Sets the array of enums. /// </summary> /// <param name="names">List of enum names.</param> /// <param name="inCppForm">The form of enum.</param> /// <param name="addMaxKeyIfMissing">Should a default Max item be added.</param> /// <returns>true unless the MAX enum already exists and isn't the last enum.</returns> public bool SetEnums(Dictionary <FName, long> names, UEnum.ECppForm inCppForm, bool addMaxKeyIfMissing = true) { using (TArrayUnsafe <FName> namesUnsafe = new TArrayUnsafe <FName>()) using (TArrayUnsafe <long> valuesUnsafe = new TArrayUnsafe <long>()) { namesUnsafe.AddRange(names.Keys.ToArray()); valuesUnsafe.AddRange(names.Values.ToArray()); return(Native_UEnum.SetEnums(Address, namesUnsafe.Address, valuesUnsafe.Address, inCppForm, addMaxKeyIfMissing)); } }
/// <summary> /// This will recurse over a directory structure looking for packages. /// </summary> /// <param name="rootDir">The root of the directory structure to recurse through</param> /// <param name="packages">The output array that is filled out with a file paths</param> /// <returns>Returns true if any packages have been found, otherwise false</returns> public static bool FindPackagesInDirectory(string rootDir, out string[] packages) { using (FStringUnsafe rootDirUnsafe = new FStringUnsafe(rootDir)) using (TArrayUnsafe <string> packagesUnsafe = new TArrayUnsafe <string>()) { bool result = Native_FPackageName.FindPackagesInDirectory(packagesUnsafe.Address, ref rootDirUnsafe.Array); packages = packagesUnsafe.ToArray(); return(result); } }
/// <summary> /// Returns list of names it may have been before /// </summary> public static bool FindPreviousNames(ECoreRedirectFlags type, FCoreRedirectObjectName newObjectName, out FCoreRedirectObjectName[] previousNames) { using (TArrayUnsafe <FCoreRedirectObjectName> previousNamesUnsafe = new TArrayUnsafe <FCoreRedirectObjectName>()) { bool result = Native_FCoreRedirects.FindPreviousNames(type, ref newObjectName, previousNamesUnsafe.Address); previousNames = previousNamesUnsafe.ToArray(); return(result); } }
/// <summary> /// Set the key/value pair in the Property's metadata /// </summary> /// <param name="obj">the object to set the metadata for</param> /// <param name="value">The metadata key/value pairs</param> public void SetObjectValues(UObject obj, Dictionary <FName, string> value) { using (TArrayUnsafe <FName> keysUnsafe = new TArrayUnsafe <FName>()) using (TArrayUnsafe <string> valuesUnsafe = new TArrayUnsafe <string>()) { keysUnsafe.AddRange(value.Keys.ToArray()); valuesUnsafe.AddRange(value.Values.ToArray()); Native_UMetaData.SetObjectValues(Address, obj == null ? IntPtr.Zero : obj.Address, keysUnsafe.Address, valuesUnsafe.Address); } }
/// <summary> /// Gets an array of all blueprints used to generate this class and its parents. 0th elements is the BP used to generate InClass /// </summary> /// <param name="inClass">The class to get the blueprint lineage for</param> /// <param name="outBlueprintParents">Array with the blueprints used to generate this class and its parents. 0th = this, Nth = least derived BP-based parent</param> /// <returns>true if there were no status errors in any of the parent blueprints, otherwise false</returns> public static bool GetBlueprintHierarchyFromClass(UClass inClass, UBlueprint[] outBlueprintParents) { using (TArrayUnsafe <UBlueprint> outBlueprintParentsUnsafe = new TArrayUnsafe <UBlueprint>()) { bool result = Native_UBlueprint.GetBlueprintHierarchyFromClass( inClass == null ? IntPtr.Zero : inClass.Address, outBlueprintParentsUnsafe.Address); outBlueprintParents = outBlueprintParentsUnsafe.ToArray(); return(result); } }
public void Dispose() { if (address != IntPtr.Zero) { Native_FReferenceFinder.Delete(address); address = IntPtr.Zero; } if (objArray != null) { objArray.Dispose(); objArray = null; } }
/// <summary> /// Returns true if this property, or in the case of e.g. array or struct properties any sub- property, contains a /// UObject reference. /// </summary> /// <returns>true if property (or sub- properties) contain a UObject reference, false otherwise</returns> public bool ContainsObjectReference(List <UStructProperty> encounteredStructProps) { using (TArrayUnsafe <UStructProperty> encounteredStructPropsUnsafe = new TArrayUnsafe <UStructProperty>()) { bool result = Native_UProperty.ContainsObjectReference(Address, encounteredStructPropsUnsafe.Address); if (encounteredStructProps != null) { encounteredStructProps.Clear(); encounteredStructProps.AddRange(encounteredStructPropsUnsafe); } return(result); } }
/// <summary> /// Emits tokens used by realtime garbage collection code to passed in ReferenceTokenStream. The offset emitted is relative /// to the passed in BaseOffset which is used by e.g. arrays of structs. /// </summary> /// <param name="unrealClass"></param> /// <param name="baseOffset"></param> /// <param name="encounteredStructProps"></param> public void EmitReferenceInfo(UClass unrealClass, int baseOffset, List <UStructProperty> encounteredStructProps) { using (TArrayUnsafe <UStructProperty> encounteredStructPropsUnsafe = new TArrayUnsafe <UStructProperty>()) { Native_UProperty.EmitReferenceInfo(Address, unrealClass == null ? IntPtr.Zero : unrealClass.Address, baseOffset, encounteredStructPropsUnsafe.Address); if (encounteredStructProps != null) { encounteredStructProps.Clear(); encounteredStructProps.AddRange(encounteredStructPropsUnsafe); } } }
public IntPtr GetAddress() { if (address == IntPtr.Zero) { return(address); } using (TArrayUnsafe <FName> packageNamesUnsafe = new TArrayUnsafe <FName>()) { packageNamesUnsafe.AddRange(PackageNames.ToArray()); Native_FARFilter.Set_PackageNames(address, packageNamesUnsafe.Address); } using (TArrayUnsafe <FName> packagePathsUnsafe = new TArrayUnsafe <FName>()) { packagePathsUnsafe.AddRange(PackagePaths.ToArray()); Native_FARFilter.Set_PackagePaths(address, packagePathsUnsafe.Address); } using (TArrayUnsafe <FName> objectPathsUnsafe = new TArrayUnsafe <FName>()) { objectPathsUnsafe.AddRange(ObjectPaths.ToArray()); Native_FARFilter.Set_ObjectPaths(address, objectPathsUnsafe.Address); } using (TArrayUnsafe <FName> classNamesUnsafe = new TArrayUnsafe <FName>()) { classNamesUnsafe.AddRange(ClassNames.ToArray()); Native_FARFilter.Set_ClassNames(address, classNamesUnsafe.Address); } using (TArrayUnsafe <FName> tagsUnsafe = new TArrayUnsafe <FName>()) using (TArrayUnsafe <string> valuesUnsafe = new TArrayUnsafe <string>()) { tagsUnsafe.AddRange(TagsAndValues.Keys.ToArray()); valuesUnsafe.AddRange(TagsAndValues.Values.ToArray()); Native_FARFilter.Set_TagsAndValues(address, tagsUnsafe.Address, valuesUnsafe.Address); } using (TArrayUnsafe <FName> recursiveClassesExclusionSet = new TArrayUnsafe <FName>()) { recursiveClassesExclusionSet.AddRange(RecursiveClassesExclusionSet.ToArray()); Native_FARFilter.Set_RecursiveClassesExclusionSet(address, recursiveClassesExclusionSet.Address); } Native_FARFilter.Set_bRecursivePaths(address, RecursivePaths); Native_FARFilter.Set_bRecursiveClasses(address, RecursiveClasses); Native_FARFilter.Set_bIncludeOnlyOnDiskAssets(address, IncludeOnlyOnDiskAssets); return(address); }
/// <summary> /// Queries information about all of the currently known modules. /// </summary> /// <returns>Status of all modules.</returns> public FModuleStatus[] QueryModules() { List <FModuleStatus> modules = new List <FModuleStatus>(); using (TArrayUnsafe <FModuleStatusNative> modulesUnsafe = new TArrayUnsafe <FModuleStatusNative>()) { Native_FModuleManager.QueryModules(Address, modulesUnsafe.Address); foreach (FModuleStatusNative moduleStatusUnsafe in modulesUnsafe) { modules.Add(new FModuleStatus(moduleStatusUnsafe)); } } return(modules.ToArray()); }
private IPlugin[] GetPluginArray(TArrayUnsafe <FSharedPtr> sharedPtrs) { int count = sharedPtrs.Count; IPlugin[] result = new IPlugin[count]; for (int i = 0; i < count; i++) { FSharedPtr sharedPtr = sharedPtrs[i]; if (sharedPtr.IsValid()) { result[i] = new IPlugin(sharedPtr); } } return(result); }
/// <summary> /// Checks whether modules for the enabled plug-ins are up to date. /// </summary> /// <param name="incompatibleModules">Incompatible module names.</param> /// <returns>true if the enabled plug-in modules are up to date.</returns> public bool CheckModuleCompatibility(out string[] incompatibleModules) { // !IS_MONOLITHIC if (Native_IPluginManager.CheckModuleCompatibility == null) { incompatibleModules = null; return(true); } using (TArrayUnsafe <string> incompatibleModulesUnsafe = new TArrayUnsafe <string>()) { bool result = Native_IPluginManager.CheckModuleCompatibility(Address, incompatibleModulesUnsafe.Address); incompatibleModules = incompatibleModulesUnsafe.ToArray(); return(result); } }
/// <summary> /// Find the name/value map for metadata for a specific object /// </summary> public static Dictionary <FName, string> GetMapForObject(UObject obj) { Dictionary <FName, string> result = new Dictionary <FName, string>(); using (TArrayUnsafe <FName> keysUnsafe = new TArrayUnsafe <FName>()) using (TArrayUnsafe <string> valuesUnsafe = new TArrayUnsafe <string>()) { Native_UMetaData.GetMapForObject(obj == null ? IntPtr.Zero : obj.Address, keysUnsafe.Address, valuesUnsafe.Address); if (keysUnsafe.Count == valuesUnsafe.Count) { int count = keysUnsafe.Count; for (int i = 0; i < count; i++) { result[keysUnsafe[i]] = valuesUnsafe[i]; } } } return(result); }
public static Dictionary <FName, string> FindModulePaths(string namePattern, bool canUseCache = true) { Dictionary <FName, string> result = new Dictionary <FName, string>(); using (FStringUnsafe namePatternUnsafe = new FStringUnsafe(namePattern)) using (TArrayUnsafe <FName> keysUnsafe = new TArrayUnsafe <FName>()) using (TArrayUnsafe <string> valuesUnsafe = new TArrayUnsafe <string>()) { Native_FModulePaths.FindModulePaths(ref namePatternUnsafe.Array, canUseCache, keysUnsafe.Address, valuesUnsafe.Address); if (keysUnsafe.Count == valuesUnsafe.Count) { int count = keysUnsafe.Count; for (int i = 0; i < count; i++) { result[keysUnsafe[i]] = valuesUnsafe[i]; } } } return(result); }
public void GenerateCodeForBlueprints(AssetLoadMode loadMode, bool clearAssetCache, bool skipLevels) { BeginGenerateModules(); string projectPath = FPaths.ProjectFilePath; string projectName = FPaths.GetBaseFilename(projectPath); UnrealModuleInfo module = new UnrealModuleInfo(null, projectName, projectPath); BeginGenerateModule(module); UClass worldClass = GCHelper.Find <UClass>(Classes.UWorld); AssetCache assetCache = new AssetCache(this); if (!clearAssetCache) { assetCache.Load(); } List <string> assetBlacklist = LoadAssetBlacklist(); AssetLogClear(); AssetLogLine("Load assets {0}", DateTime.Now); bool registeredCrashHandler = false; if (Settings.CatchCrashOnAssetLoading) { FCoreDelegates.OnHandleSystemError.Bind(OnAssetLoadingCrash); registeredCrashHandler = true; } using (FARFilter filter = new FARFilter()) { filter.RecursiveClasses = true; filter.ClassNames.Add(UClass.GetClass <UBlueprint>().GetFName()); filter.ClassNames.Add(UClass.GetClass <UBlueprintGeneratedClass>().GetFName()); filter.ClassNames.Add(UClass.GetClass <UUserDefinedStruct>().GetFName()); filter.ClassNames.Add(UClass.GetClass <UUserDefinedEnum>().GetFName()); if (!skipLevels && worldClass != null) { filter.ClassNames.Add(worldClass.GetFName()); } List <FAssetData> assets = FAssetData.Load(filter); SlowTaskSetModuleCount(1); SlowTaskBeginModule("Blueprints", assets.Count); foreach (FAssetData asset in assets) { SlowTaskStep(null); string assetFileName, assetFileNameError; if (!asset.TryGetFilename(out assetFileName, out assetFileNameError)) { FMessage.Log(string.Format("FAssetData.TryGetFilename failed. ObjectPath:'{0}' reason:'{1}'", asset.ObjectPath.ToString(), assetFileNameError)); continue; } bool isEngineAsset = FPaths.IsSameOrSubDirectory(FPaths.EngineContentDir, FPaths.GetPath(assetFileName)); if (loadMode != AssetLoadMode.All) { if ((isEngineAsset && loadMode != AssetLoadMode.Engine) || (!isEngineAsset && loadMode != AssetLoadMode.Game)) { continue; } } if (!assetCache.HasAssetChanged(asset, assetFileName)) { if (Settings.LogAssetLoadingVerbose) { AssetLogLine("'{0}' unchanged", assetFileName); } continue; } // Log that we are loading this asset so we know which assets crash on load AssetLog("'{0}' - ", asset.ObjectPath.ToString()); if (assetBlacklist.Contains(asset.ObjectPath.ToString())) { AssetLogLine("blacklisted"); continue; } loadingAsset = asset.ObjectPath.ToString(); UObject obj = asset.GetAsset(); loadingAsset = null; UClass unrealClass = asset.GetClass(); if (obj == null || unrealClass == null) { AssetLogLine("null"); continue; } AssetLogLine("done"); if (unrealClass.IsChildOf <UBlueprint>()) { UBlueprint blueprint = obj as UBlueprint; if (blueprint != null) { UBlueprintGeneratedClass blueprintGeneratedClass = blueprint.GeneratedClass as UBlueprintGeneratedClass; if (blueprintGeneratedClass != null) { GenerateCodeForStruct(module, blueprintGeneratedClass); } } } else if (unrealClass.IsChildOf <UBlueprintGeneratedClass>()) { UBlueprintGeneratedClass blueprintGeneratedClass = obj as UBlueprintGeneratedClass; if (blueprintGeneratedClass != null) { GenerateCodeForStruct(module, blueprintGeneratedClass); } } else if (unrealClass.IsChildOf <UUserDefinedStruct>()) { UUserDefinedStruct unrealStruct = obj as UUserDefinedStruct; if (unrealStruct != null) { GenerateCodeForStruct(module, unrealStruct); } } else if (unrealClass.IsChildOf <UUserDefinedEnum>()) { UUserDefinedEnum unrealEnum = obj as UUserDefinedEnum; if (unrealEnum != null) { GenerateCodeForEnum(module, unrealEnum); } } else if (unrealClass.IsChildOf(worldClass)) { TArrayUnsafeRef <UObject> levels = new TArrayUnsafeRef <UObject>(Native.Native_UWorld.GetLevels(obj.Address)); foreach (UObject level in levels) { using (TArrayUnsafe <UBlueprint> levelBlueprints = new TArrayUnsafe <UBlueprint>()) { Native.Native_ULevel.GetLevelBlueprints(level.Address, levelBlueprints.Address); foreach (UBlueprint blueprint in levelBlueprints) { UBlueprintGeneratedClass blueprintGeneratedClass = blueprint.GeneratedClass as UBlueprintGeneratedClass; if (blueprintGeneratedClass != null) { //GenerateCodeForStruct(blueprintGeneratedClass); } } } } } } } if (registeredCrashHandler) { FCoreDelegates.OnHandleSystemError.Unbind(OnAssetLoadingCrash); } assetCache.Save(); EndGenerateModule(module); EndGenerateModules(); }