public FZenPackageVersioningInfo(FArchive Ar)
{
ZenVersion = Ar.Read <EZenPackageVersion>();
PackageVersion = Ar.Read <FPackageFileVersion>();
LicenseeVersion = Ar.Read <int>();
CustomVersions = Ar.ReadArray <FCustomVersion>();
}
public FSkeletalMeshVertexBuffer(FAssetArchive Ar) : this()
{
var stripDataFlags = new FStripDataFlags(Ar, FPackageFileVersion.CreateUE4Version(EUnrealEngineObjectUE4Version.STATIC_SKELETAL_MESH_SERIALIZATION_FIX));
NumTexCoords = Ar.Read <int>();
bUseFullPrecisionUVs = Ar.ReadBoolean();
if (Ar.Ver >= EUnrealEngineObjectUE4Version.SUPPORT_GPUSKINNING_8_BONE_INFLUENCES &&
FSkeletalMeshCustomVersion.Get(Ar) < FSkeletalMeshCustomVersion.Type.UseSeparateSkinWeightBuffer)
{
bExtraBoneInfluences = Ar.ReadBoolean();
}
MeshExtension = Ar.Read <FVector>();
MeshOrigin = Ar.Read <FVector>();
if (!bUseFullPrecisionUVs)
{
VertsHalf = Ar.ReadBulkArray(() => new FGPUVertHalf(Ar, bExtraBoneInfluences, NumTexCoords));
}
else
{
VertsFloat = Ar.ReadBulkArray(() => new FGPUVertFloat(Ar, bExtraBoneInfluences, NumTexCoords));
}
}
public FAssetPackageData(FAssetRegistryArchive Ar, FAssetRegistryVersionType version)
{
PackageName = Ar.ReadFName();
DiskSize = Ar.Read <long>();
PackageGuid = Ar.Read <FGuid>();
if (version >= FAssetRegistryVersionType.AddedCookedMD5Hash)
{
CookedHash = new FMD5Hash(Ar);
}
if (version >= FAssetRegistryVersionType.WorkspaceDomain)
{
if (version >= FAssetRegistryVersionType.PackageFileSummaryVersionChange)
{
FileVersionUE = Ar.Read <FPackageFileVersion>();
}
else
{
var ue4Version = Ar.Read <int>();
FileVersionUE = FPackageFileVersion.CreateUE4Version(ue4Version);
}
FileVersionLicenseeUE = Ar.Read <int>();
Flags = Ar.Read <uint>();
CustomVersions = Ar.ReadArray <FCustomVersion>();
}
if (version >= FAssetRegistryVersionType.PackageImportedClasses)
{
ImportedClasses = Ar.ReadArray(Ar.ReadFName);
}
}
public FSkeletalMeshVertexClothBuffer(FArchive Ar)
{
var stripDataFlags = new FStripDataFlags(Ar, FPackageFileVersion.CreateUE4Version(EUnrealEngineObjectUE4Version.STATIC_SKELETAL_MESH_SERIALIZATION_FIX));
if (stripDataFlags.IsDataStrippedForServer())
{
return;
}
Ar.SkipBulkArrayData();
if (FSkeletalMeshCustomVersion.Get(Ar) >= FSkeletalMeshCustomVersion.Type.CompactClothVertexBuffer)
{
ClothIndexMapping = Ar.ReadArray <ulong>();
}
}
public FColorVertexBuffer(FArchive Ar)
{
var stripDataFlags = new FStripDataFlags(Ar, FPackageFileVersion.CreateUE4Version(EUnrealEngineObjectUE4Version.STATIC_SKELETAL_MESH_SERIALIZATION_FIX));
Stride = Ar.Read <int>();
NumVertices = Ar.Read <int>();
if (!stripDataFlags.IsDataStrippedForServer() & NumVertices > 0)
{
Data = Ar.ReadBulkArray <FColor>();
}
else
{
Data = Array.Empty <FColor>();
}
}
internal FPackageFileSummary(FArchive Ar)
{
Tag = Ar.Read <uint>();
/*
* The package file version number when this package was saved.
*
* Lower 16 bits stores the UE3 engine version
* Upper 16 bits stores the UE4/licensee version
* For newer packages this is -7
* -2 indicates presence of enum-based custom versions
* -3 indicates guid-based custom versions
* -4 indicates removal of the UE3 version. Packages saved with this ID cannot be loaded in older engine versions
* -5 indicates the replacement of writing out the "UE3 version" so older versions of engine can gracefully fail to open newer packages
* -6 indicates optimizations to how custom versions are being serialized
* -7 indicates the texture allocation info has been removed from the summary
* -8 indicates that the UE5 version has been added to the summary
*/
const int CurrentLegacyFileVersion = -8;
var legacyFileVersion = CurrentLegacyFileVersion;
if (Tag == PACKAGE_FILE_TAG_ONE) // SOD2, "one"
{
Ar.Game = EGame.GAME_StateOfDecay2;
Ar.Ver = Ar.Game.GetVersion();
legacyFileVersion = Ar.Read <int>(); // seems to be always int.MinValue
bUnversioned = true;
FileVersionUE = Ar.Ver;
CustomVersionContainer = Array.Empty <FCustomVersion>();
FolderName = "None";
PackageFlags = EPackageFlags.PKG_FilterEditorOnly;
goto afterPackageFlags;
}
if (Tag != PACKAGE_FILE_TAG && Tag != PACKAGE_FILE_TAG_SWAPPED)
{
throw new ParserException($"Invalid uasset magic: 0x{Tag:X8} != 0x{PACKAGE_FILE_TAG:X8}");
}
// The package has been stored in a separate endianness than the linker expected so we need to force
// endian conversion. Latent handling allows the PC version to retrieve information about cooked packages.
if (Tag == PACKAGE_FILE_TAG_SWAPPED)
{
// Set proper tag.
//Tag = PACKAGE_FILE_TAG;
// Toggle forced byte swapping.
throw new ParserException("Byte swapping for packages not supported");
}
legacyFileVersion = Ar.Read <int>();
if (legacyFileVersion < 0) // means we have modern version numbers
{
if (legacyFileVersion < CurrentLegacyFileVersion)
{
// we can't safely load more than this because the legacy version code differs in ways we can not predict.
// Make sure that the linker will fail to load with it.
FileVersionUE.Reset();
FileVersionLicenseeUE = 0;
throw new ParserException("Can't load legacy UE3 file");
}
if (legacyFileVersion != -4)
{
var legacyUE3Version = Ar.Read <int>();
}
FileVersionUE.FileVersionUE4 = Ar.Read <int>();
if (legacyFileVersion <= -8)
{
FileVersionUE.FileVersionUE5 = Ar.Read <int>();
}
FileVersionLicenseeUE = Ar.Read <EUnrealEngineObjectLicenseeUEVersion>();
CustomVersionContainer = legacyFileVersion <= -2 ? Ar.ReadArray <FCustomVersion>() : Array.Empty <FCustomVersion>();
if (Ar.Versions.CustomVersions == null && CustomVersionContainer.Length > 0)
{
Ar.Versions.CustomVersions = CustomVersionContainer.ToList();
}
if (FileVersionUE.FileVersionUE4 == 0 && FileVersionUE.FileVersionUE5 == 0 && FileVersionLicenseeUE == 0)
{
// this file is unversioned, remember that, then use current versions
bUnversioned = true;
FileVersionUE = Ar.Ver;
FileVersionLicenseeUE = EUnrealEngineObjectLicenseeUEVersion.VER_LIC_AUTOMATIC_VERSION;
}
else
{
bUnversioned = false;
// Only apply the version if an explicit version is not set
if (!Ar.Versions.bExplicitVer)
{
Ar.Ver = FileVersionUE;
}
}
}
else
{
// This is probably an old UE3 file, make sure that the linker will fail to load with it.
throw new ParserException("Can't load legacy UE3 file");
}
TotalHeaderSize = Ar.Read <int>();
FolderName = Ar.ReadFString();
PackageFlags = Ar.Read <EPackageFlags>();
/*if (PackageFlags.HasFlag(EPackageFlags.PKG_FilterEditorOnly))
* {
* TODO Ar.SetFilterEditorOnly(true);
* }*/
afterPackageFlags:
NameCount = Ar.Read <int>();
NameOffset = Ar.Read <int>();
if (!PackageFlags.HasFlag(EPackageFlags.PKG_FilterEditorOnly))
{
if (FileVersionUE >= EUnrealEngineObjectUE4Version.ADDED_PACKAGE_SUMMARY_LOCALIZATION_ID)
{
LocalizationId = Ar.ReadFString();
}
}
if (FileVersionUE >= EUnrealEngineObjectUE4Version.SERIALIZE_TEXT_IN_PACKAGES)
{
GatherableTextDataCount = Ar.Read <int>();
GatherableTextDataOffset = Ar.Read <int>();
}
ExportCount = Ar.Read <int>();
ExportOffset = Ar.Read <int>();
ImportCount = Ar.Read <int>();
ImportOffset = Ar.Read <int>();
DependsOffset = Ar.Read <int>();
if (FileVersionUE < EUnrealEngineObjectUE4Version.OLDEST_LOADABLE_PACKAGE || FileVersionUE > EUnrealEngineObjectUE4Version.AUTOMATIC_VERSION)
{
Generations = Array.Empty <FGenerationInfo>();
ChunkIds = Array.Empty <int>();
return; // we can't safely load more than this because the below was different in older files.
}
if (FileVersionUE >= EUnrealEngineObjectUE4Version.ADD_STRING_ASSET_REFERENCES_MAP)
{
SoftPackageReferencesCount = Ar.Read <int>();
SoftPackageReferencesOffset = Ar.Read <int>();
}
if (FileVersionUE >= EUnrealEngineObjectUE4Version.ADDED_SEARCHABLE_NAMES)
{
SearchableNamesOffset = Ar.Read <int>();
}
ThumbnailTableOffset = Ar.Read <int>();
if (Ar.Game == EGame.GAME_Valorant)
{
Ar.Position += 8;
}
Guid = Ar.Read <FGuid>();
if (!PackageFlags.HasFlag(EPackageFlags.PKG_FilterEditorOnly))
{
if (FileVersionUE >= EUnrealEngineObjectUE4Version.ADDED_PACKAGE_OWNER)
{
PersistentGuid = Ar.Read <FGuid>();
}
else
{
// By assigning the current package guid, we maintain a stable persistent guid, so we can reference this package even if it wasn't resaved.
PersistentGuid = Guid;
}
// The owner persistent guid was added in VER_UE4_ADDED_PACKAGE_OWNER but removed in the next version VER_UE4_NON_OUTER_PACKAGE_IMPORT
if (FileVersionUE >= EUnrealEngineObjectUE4Version.ADDED_PACKAGE_OWNER && FileVersionUE < EUnrealEngineObjectUE4Version.NON_OUTER_PACKAGE_IMPORT)
{
var ownerPersistentGuid = Ar.Read <FGuid>();
}
}
Generations = Ar.ReadArray <FGenerationInfo>();
if (FileVersionUE >= EUnrealEngineObjectUE4Version.ENGINE_VERSION_OBJECT)
{
SavedByEngineVersion = new FEngineVersion(Ar);
FixCorruptEngineVersion(FileVersionUE, SavedByEngineVersion);
}
else
{
var engineChangelist = Ar.Read <int>();
if (engineChangelist != 0)
{
SavedByEngineVersion = new FEngineVersion(4, 0, 0, (uint)engineChangelist, string.Empty);
}
}
if (FileVersionUE >= EUnrealEngineObjectUE4Version.PACKAGE_SUMMARY_HAS_COMPATIBLE_ENGINE_VERSION)
{
CompatibleWithEngineVersion = new FEngineVersion(Ar);
FixCorruptEngineVersion(FileVersionUE, CompatibleWithEngineVersion);
}
else
{
CompatibleWithEngineVersion = SavedByEngineVersion;
}
public FSkeletalMeshVertexColorBuffer(FAssetArchive Ar)
{
var stripDataFlags = new FStripDataFlags(Ar, FPackageFileVersion.CreateUE4Version(EUnrealEngineObjectUE4Version.STATIC_SKELETAL_MESH_SERIALIZATION_FIX));
Data = !stripDataFlags.IsDataStrippedForServer() ? Ar.ReadBulkArray <FColor>() : new FColor[0];
}
public readonly FStaticMeshUVItem[] UV; // TangentsData ?
public FStaticMeshVertexBuffer(FArchive Ar)
{
var stripDataFlags = new FStripDataFlags(Ar, FPackageFileVersion.CreateUE4Version(EUnrealEngineObjectUE4Version.STATIC_SKELETAL_MESH_SERIALIZATION_FIX));
// SerializeMetaData
NumTexCoords = Ar.Read <int>();
Strides = Ar.Game < EGame.GAME_UE4_19 ? Ar.Read <int>() : -1;
NumVertices = Ar.Read <int>();
UseFullPrecisionUVs = Ar.ReadBoolean();
UseHighPrecisionTangentBasis = Ar.Game >= EGame.GAME_UE4_12 && Ar.ReadBoolean();
if (!stripDataFlags.IsDataStrippedForServer())
{
if (Ar.Game < EGame.GAME_UE4_19)
{
UV = Ar.ReadBulkArray(() => new FStaticMeshUVItem(Ar, UseHighPrecisionTangentBasis, NumTexCoords, UseFullPrecisionUVs));
}
else
{
var tempTangents = Array.Empty <FPackedNormal[]>();
if (Ar.Game == EGame.GAME_StarWarsJediFallenOrder && Ar.ReadBoolean()) // bDropNormals
{
goto texture_coordinates;
}
// BulkSerialize
var itemSize = Ar.Read <int>();
var itemCount = Ar.Read <int>();
var position = Ar.Position;
if (itemCount != NumVertices)
{
throw new ParserException($"NumVertices={itemCount} != NumVertices={NumVertices}");
}
tempTangents = Ar.ReadArray(NumVertices, () => FStaticMeshUVItem.SerializeTangents(Ar, UseHighPrecisionTangentBasis));
if (Ar.Position - position != itemCount * itemSize)
{
throw new ParserException($"Read incorrect amount of tangent bytes, at {Ar.Position}, should be: {position + itemSize * itemCount} behind: {position + (itemSize * itemCount) - Ar.Position}");
}
texture_coordinates:
itemSize = Ar.Read <int>();
itemCount = Ar.Read <int>();
position = Ar.Position;
if (itemCount != NumVertices * NumTexCoords)
{
throw new ParserException($"NumVertices={itemCount} != {NumVertices * NumTexCoords}");
}
var uv = Ar.ReadArray(NumVertices, () => FStaticMeshUVItem.SerializeTexcoords(Ar, NumTexCoords, UseFullPrecisionUVs));
if (Ar.Position - position != itemCount * itemSize)
{
throw new ParserException($"Read incorrect amount of Texture Coordinate bytes, at {Ar.Position}, should be: {position + itemSize * itemCount} behind: {position + (itemSize * itemCount) - Ar.Position}");
}
UV = new FStaticMeshUVItem[NumVertices];
for (var i = 0; i < NumVertices; i++)
{
if (Ar.Game == EGame.GAME_StarWarsJediFallenOrder && tempTangents.Length == 0)
{
UV[i] = new FStaticMeshUVItem(new [] { new FPackedNormal(0), new FPackedNormal(0), new FPackedNormal(0) }, uv[i]);
}
else
{
UV[i] = new FStaticMeshUVItem(tempTangents[i], uv[i]);
}
}
}
}
else
{
UV = Array.Empty <FStaticMeshUVItem>();
}
}
