/// <summary>
/// Constructor.
/// </summary>
/// <param name="packageObj">The package object.</param>
public Package(GenericTypes.UEObject packageObj)
{
_packageObj = packageObj;
_dependencies = new List <GenericTypes.UEObject>();
Constants = new List <Constant>();
Classes = new List <Class>();
ScriptStructs = new List <ScriptStruct>();
Enums = new List <Enum>();
ProcessedObjects = new Dictionary <IntPtr, bool>();
}
private bool AddDependency(GenericTypes.UEObject package)
{
if (package == _packageObj)
{
return(false);
}
lock (_dependencies)
_dependencies.Add(package);
return(true);
}
/// <summary>
/// Get all objects in this package
/// </summary>
public static Task <List <GenericTypes.UEObject> > GetObjsInPack(GenericTypes.UEObject packageObj)
{
return(Task.Run(() =>
{
var outPackages = new List <GenericTypes.UEObject>();
var lockObj = new object();
foreach (var obj in ObjectsStore.GObjects.Objects)
{
if (packageObj != obj.GetPackageObject().Result)
{
continue;
}
lock (lockObj)
outPackages.Add(obj);
}
return outPackages;
}));
}
/// <summary>
/// Process All Packages
/// </summary>
private async Task ProcessPackages()
{
var uDiscord = UpdateDiscordState("State", "Collect **Packages**. !!");
_packageObjects = CollectPackages();
// Update Information
await uDiscord; uDiscord = UpdateDiscordState("Packages", $"*{_packageObjects.Count}*", true);
#region CoreUObject
{
/*
* First we must complete Core Package.
* It's contains all important stuff, (like we need it in 'StaticClass' function)
* So before go parallel we must get 'CoreUObject'
* Some times CoreUObject not the first Package
*/
// Get CoreUObject
var coreUObject = new GenericTypes.UEObject();
int coreUObjectIndex = 0;
for (int i = 0; i < _packageObjects.Count; ++i)
{
var packPtr = _packageObjects[i];
if (await packPtr.GetName() != "CoreUObject")
{
continue;
}
coreUObject = packPtr;
coreUObjectIndex = i;
break;
}
await uDiscord; uDiscord = UpdateDiscordState("State", "Dumping **CoreUObject**.");
// Process CoreUObject
var package = new Package(coreUObject);
await package.Process();
_donePackagesCount++;
if (await package.Save())
{
Package.PackageMap[coreUObject] = package;
_packages.Add(package);
}
// Remove CoreUObject Package to not dump it twice
_packageObjects.RemoveAt(coreUObjectIndex);
}
#endregion
// Don't wait
#pragma warning disable 4014
DiscordMessageUpdater();
#pragma warning restore 4014
#region Packages
// Update Information
await uDiscord; uDiscord = UpdateDiscordState("State", $"Dumping **Packages** ( {_packages.Count}/{_packageObjects.Count + 1} ).");
// Process Packages
var lockObj = new object();
Parallel.ForEach(_packageObjects, packObj =>
{
var package = new Package(packObj);
// Async in Parallel => Loot of problems !!
package.Process().GetAwaiter().GetResult();
_donePackagesCount++;
if (!package.Save().Result)
{
return;
}
lock (lockObj)
{
Package.PackageMap[packObj] = package;
_packages.Add(package);
}
Utils.ConsoleText("Dump", package.GetName().Result, ConsoleColor.Red);
});
if (!_packages.Empty())
{
for (int i = 0; i < _packages.Count - 1; i++)
{
for (int j = 0; j < _packages.Count - i - 1; j++)
{
if (!Package.PackageDependencyComparer(_packages[j], _packages[j + 1]))
{
_packages = _packages.Swap(j, j + 1);
}
}
}
}
#endregion
await SdkAfterFinish(_packages);
_sdkWork = false;
await uDiscord; await UpdateDiscordState("State", $"FINIIIISHED !!");
}
/// <summary>
/// Checks and generates the prerequisites of the object.
/// Should be a UEClass or UEScriptStruct.
/// </summary>
/// <param name="obj">The object.</param>
/// <returns>Return Processed Objects</returns>
private async Task GeneratePrerequisites(GenericTypes.UEObject obj)
{
if (!obj.IsValid())
{
return;
}
var isClassT = obj.IsA <GenericTypes.UEClass>();
var isScriptStructT = obj.IsA <GenericTypes.UEScriptStruct>();
if (!await isClassT && !await isScriptStructT)
{
return;
}
string name = await obj.GetName();
if (name.Contains("Default__") ||
name.Contains("<uninitialized>") ||
name.Contains("PLACEHOLDER-CLASS"))
{
return;
}
lock (_lockProcessedObjects)
{
if (!ProcessedObjects.ContainsKey(obj.GetAddress()))
{
ProcessedObjects[obj.GetAddress()] = false;
}
else
{
ProcessedObjects[obj.GetAddress()] = ProcessedObjects[obj.GetAddress()] | false;
}
}
var classPackage = await obj.GetPackageObject();
if (!classPackage.IsValid())
{
return;
}
if (AddDependency(classPackage))
{
return;
}
// Exit if package already processed
if (ProcessedObjects[obj.GetAddress()])
{
return;
}
lock (_lockProcessedObjects)
ProcessedObjects[obj.GetAddress()] = true;
// Outer
var outer = await obj.GetOuter();
if (outer.IsValid() && outer != obj)
{
await GeneratePrerequisites(outer);
}
// Super
var structObj = obj.Cast <GenericTypes.UEStruct>();
var super = await structObj.GetSuper();
if (super.IsValid() && super != obj)
{
await GeneratePrerequisites(super);
}
await GenerateMemberPrerequisites((await structObj.GetChildren()).Cast <GenericTypes.UEProperty>());
if (await isClassT)
{
await GenerateClass(obj.Cast <GenericTypes.UEClass>());
}
else
{
await GenerateScriptStruct(obj.Cast <GenericTypes.UEScriptStruct>());
}
}
