public override bool IsNameStableForNetworking() => true; // For now, assume all packages have stable net names
public AbstractUePackage(string name, IFileProvider?provider, TypeMappings?mappings)
{
Name = name;
Provider = provider;
Mappings = mappings;
Flags |= EObjectFlags.RF_WasLoaded;
}
public Struct(TypeMappings?context, string name, string?superType, Dictionary <int, PropertyInfo> properties, int propertyCount) : this(context, name, propertyCount)
{
SuperType = superType;
Super = new Lazy <Struct?>(() =>
{
if (SuperType != null && Context != null && Context.Types.TryGetValue(SuperType, out var superStruct))
{
return(superStruct);
}
return(null);
});
Properties = properties;
}
public Struct(TypeMappings?context, string name, int propertyCount)
{
Context = context;
Name = name;
PropertyCount = propertyCount;
}
public AbstractUePackage(string name, IFileProvider?provider, TypeMappings?mappings)
{
Name = name;
Provider = provider;
Mappings = mappings;
}
public Package(FArchive uasset, FArchive uexp, Lazy <FArchive?>?ubulk = null, Lazy <FArchive?>?uptnl = null, IFileProvider?provider = null, TypeMappings?mappings = null)
: base(uasset.Name.SubstringBeforeLast(".uasset"), provider, mappings)
{
var uassetAr = new FAssetArchive(uasset, this);
Summary = new FPackageFileSummary(uassetAr);
if (Summary.Tag != PackageMagic)
{
throw new ParserException(uassetAr, $"Invalid uasset magic: {Summary.Tag} != {PackageMagic}");
}
uassetAr.Seek(Summary.NameOffset, SeekOrigin.Begin);
NameMap = new FNameEntrySerialized[Summary.NameCount];
uassetAr.ReadArray(NameMap, () => new FNameEntrySerialized(uassetAr));
uassetAr.Seek(Summary.ImportOffset, SeekOrigin.Begin);
ImportMap = new FObjectImport[Summary.ImportCount];
uassetAr.ReadArray(ImportMap, () => new FObjectImport(uassetAr));
uassetAr.Seek(Summary.ExportOffset, SeekOrigin.Begin);
ExportMap = new FObjectExport[Summary.ExportCount]; // we need this to get its final size in some case
uassetAr.ReadArray(ExportMap, () => new FObjectExport(uassetAr));
var uexpAr = new FAssetArchive(uexp, this, Summary.TotalHeaderSize);
if (ubulk != null)
{
//var offset = (int) (Summary.TotalHeaderSize + ExportMap.Sum(export => export.SerialSize));
var offset = Summary.BulkDataStartOffset;
uexpAr.AddPayload(PayloadType.UBULK, offset, ubulk);
}
if (uptnl != null)
{
var offset = Summary.BulkDataStartOffset;
uexpAr.AddPayload(PayloadType.UPTNL, offset, uptnl);
}
foreach (var it in ExportMap)
{
if (ResolvePackageIndex(it.ClassIndex)?.Object?.Value is not UStruct uStruct)
{
continue;
}
var export = ConstructObject(uStruct);
export.Name = it.ObjectName.Text;
export.Outer = (ResolvePackageIndex(it.OuterIndex) as ResolvedExportObject)?.Object?.Value ?? this;
export.Template = ResolvePackageIndex(it.TemplateIndex) as ResolvedExportObject;
export.Flags = (int)it.ObjectFlags;
it.ExportType = export.GetType();
it.ExportObject = new Lazy <UObject>(() =>
{
uexpAr.SeekAbsolute(it.RealSerialOffset, SeekOrigin.Begin);
var validPos = uexpAr.Position + it.SerialSize;
try
{
export.Deserialize(uexpAr, validPos);
#if DEBUG
if (validPos != uexpAr.Position)
{
Log.Warning("Did not read {0} correctly, {1} bytes remaining", export.ExportType, validPos - uexpAr.Position);
}
else
{
Log.Debug("Successfully read {0} at {1} with size {2}", export.ExportType, it.RealSerialOffset, it.SerialSize);
}
#endif
// TODO right place ???
export.PostLoad();
}
catch (Exception e)
{
Log.Error(e, "Could not read {0} correctly", export.ExportType);
}
return(export);
});
}
}
public Package(FArchive uasset, FArchive uexp, FArchive?ubulk = null, FArchive?uptnl = null,
IFileProvider?provider = null, TypeMappings?mappings = null)
: this(uasset, uexp, ubulk != null ? new Lazy <FArchive?>(() => ubulk) : null,
uptnl != null ? new Lazy <FArchive?>(() => uptnl) : null, provider, mappings)
{
}