def Info(self, reader: BinaryStream, offset): self.EncryptionKeyGuid = FGuid(reader).read() self.bEncryptedIndex = reader.readByte() != b'\x00' magic = reader.readUInt32() if magic != self.PAK_FILE_MAGIC: self.Version = EPakVersion.INVALID self.SubVersion = 0 self.IndexOffset = 0 self.IndexSize = 0 self.IndexHash = None self.CompressionMethods = None return self self.Version = EPakVersion(reader.readInt32()) # FGame.Version = self.Version # FGame.SubVersion = self.SubVersion self.SubVersion = 1 if offset == self._SIZE8A and self.Version == EPakVersion.FNAME_BASED_COMPRESSION_METHOD else 0 self.IndexOffset = reader.readInt64() self.IndexSize = reader.readInt64() self.IndexHash = FSHAHash(reader) if self.Version == EPakVersion.FROZEN_INDEX: reader.readByte() # bIndexIsFrozen if self.Version.value < EPakVersion.FNAME_BASED_COMPRESSION_METHOD.value: self.CompressionMethods = ["Zlib", "Gzip", "Oodle", "LZ4"] else: BufferSize: int = self.COMPRESSION_METHOD_NAME_LEN * 4 Methods: bytes = reader.readBytes(BufferSize) MethodList = [] for i in range(4): if int(Methods[i * self.COMPRESSION_METHOD_NAME_LEN]) != 0: methods = Methods byteIndex = i * self.COMPRESSION_METHOD_NAME_LEN byteCount = self.COMPRESSION_METHOD_NAME_LEN decoded = methods[byteIndex:byteCount].decode("utf-8") MethodList.append(decoded) self.CompressionMethods = MethodList if self.Version.value < EPakVersion.INDEX_ENCRYPTION.value: self.bEncryptedIndex = False if self.Version.value < EPakVersion.ENCRYPTION_KEY_GUID.value: self.EncryptionKeyGuid = FGuid().construct(0, 0, 0, 0) return self
def __init__(self, reader: BinaryStream): magic = reader.readBytes(16) if magic != bytes(self._TocMagic, "utf-8"): raise Exceptions.InvalidMagic("invalid utoc magic") self.Version = EIoStoreTocVersion(reader.readByteToInt()) self.Reserved0 = reader.readByte() self.Reserved1 = reader.readUInt16() self.TocHeaderSize = reader.readUInt32() self.TocEntryCount = reader.readUInt32() self.TocCompressedBlockEntryCount = reader.readUInt32() self.TocCompressedBlockEntrySize = reader.readUInt32() self.CompressionMethodNameCount = reader.readUInt32() self.CompressionMethodNameLength = reader.readUInt32() self.CompressionBlockSize = reader.readUInt32() self.DirectoryIndexSize = reader.readUInt32() self.PartitionCount = reader.readUInt32() self.ContainerId = FIoContainerId(reader) self.EncryptionKeyGuid = FGuid(reader) self.ContainerFlags = reader.readByteToInt() try: self.ContainerFlags = EIoContainerFlags(self.ContainerFlags).value except: pass self.Reserved3 = reader.readByteToInt() self.Reserved4 = reader.readUInt16() self.Reserved5 = reader.readUInt32() self.PartitionSize = reader.readUInt64()
def __init__(self, reader: BinaryStream) -> None: self.position = reader.base_stream.tell() length = reader.readInt32() for _ in range(length): self.Map[FGuid( reader).read()] = FLevelSequenceLegacyObjectReference(reader)
def deserialize(self, validpos): # 7680 if self.reader.has_unversioned_properties: self.Dict = self.deserializeUnVersioned() else: self.Dict = self.deserializeVersioned() if self.structFallback: return pos = self.reader.tell() if pos + 4 <= validpos: val = self.reader.readInt32() if val not in [0, 1]: self.reader.seek(-4) return boolval = val != 0 if not self.flag & EObjectFlags.RF_ClassDefaultObject and boolval: self.ObjectGuid = FGuid(self.reader)
def __init__(self, reader: BinaryStream): self.key = FGuid(reader) self.Version = reader.readInt32()
def __init__(self, reader: BinaryStream, propMappings: StructProps = None): if propMappings: propdata = propMappings.data self.Name = FName(propMappings.Name) self.ArrayIndex = propMappings.ArraySize # data section for attr in [ "EnumName", "InnerType", "StructName", "ValueType", "Type" ]: val = getattr(propdata, attr, None) if val is None: continue if attr == "InnerType": self.InnerData = val #FPropertyTag2(**val) elif attr == "ValueType": self.ValueData = val #FPropertyTag2(val) if isinstance(val, str): val = FName(val) if isinstance(val, UsmapTag): val = FName(val.Type) setattr(self, attr, val) return self.Name = reader.readFName() if self.Name.isNone: return self.Type = reader.readFName() self.Size = reader.readInt32() self.ArrayIndex = reader.readInt32() self.position = reader.base_stream.tell() if self.Type.Number == 0: Type = self.Type.string if Type == "StructProperty": self.StructName = reader.readFName() if reader.version >= UE4Versions.VER_UE4_STRUCT_GUID_IN_PROPERTY_TAG: self.StructGuid = FGuid(reader) elif Type == "BoolProperty": self.BoolVal = reader.readByteToInt() elif Type == "ByteProperty" or Type == "EnumProperty": self.EnumName = reader.readFName() elif Type == "ArrayProperty": if reader.version >= UE4Versions.VAR_UE4_ARRAY_PROPERTY_INNER_TAGS: self.InnerType = reader.readFName() elif Type == "SetProperty": if reader.version >= UE4Versions.VER_UE4_PROPERTY_TAG_SET_MAP_SUPPORT: self.InnerType = reader.readFName() elif Type == "MapProperty": if reader.version >= UE4Versions.VER_UE4_PROPERTY_TAG_SET_MAP_SUPPORT: self.InnerType = reader.readFName() self.ValueType = reader.readFName() HasPropertyGuid = reader.readByteToInt() if HasPropertyGuid != 0: FGuid(reader) self.end_pos = reader.tell()
def ReadAsObject(reader, tag: FPropertyTag = None, type_: FName = None, readType: ReadType = None): type_ = type_.string if isinstance(type_, FName) else type_ if type_ != "EnumProperty" and readType == ReadType.ZERO: print(f"ReadType::Zero and it's not EnumProperty, {type_!r}") prop: object if switch("ByteProperty", type_): prop = ByteProperty(reader, readType,tag) elif switch("BoolProperty", type_): prop = BoolProperty(reader, tag, readType) elif switch("IntProperty", type_): prop = IntProperty(reader) elif switch("FloatProperty", type_): prop = FloatProperty(reader) elif switch("ObjectProperty", type_): prop = ObjectProperty(reader) elif switch("NameProperty", type_): prop = NameProperty(reader) elif switch("DelegateProperty", type_): prop = DelegateProperty(reader) elif switch("DoubleProperty", type_): prop = DoubleProperty(reader) elif switch("ArrayProperty", type_): prop = ArrayProperty(reader, tag) elif switch("StructProperty", type_): prop = StructProperty(reader, tag) elif switch("StrProperty", type_): prop = StrProperty(reader) elif switch("TextProperty", type_): prop = TextProperty(reader) # elif switch("InterfaceProperty", type_): # prop = InterfaceProperty(reader) # # elif switch("MulticastDelegateProperty", type_): # # prop = MulticastDelegateProperty(reader, tag) elif switch("LazyObjectProperty", type_): prop = LazyObjectProperty(reader, readType) # (reader, tag) elif switch("SoftObjectProperty", type_): prop = SoftObjectProperty(reader, readType) elif switch("AssetObjectProperty", type_): prop = SoftObjectProperty(reader, readType) elif switch("UInt64Property", type_): prop = UInt64Property(reader) elif switch("UInt32Property", type_): prop = UInt32Property(reader) elif switch("UInt16Property", type_): prop = UInt16Property(reader) elif switch("Int64Property", type_): prop = Int64Property(reader) elif switch("Int16Property", type_): prop = Int16Property(reader) elif switch("Int8Property", type_): prop = Int8Property(reader) elif switch("MapProperty", type_): prop = MapProperty(reader, tag) elif switch("SetProperty", type_): prop = SetProperty(reader, tag) elif switch("EnumProperty", type_): prop = EnumProperty(reader, tag, readType) elif switch("Guid", type_): prop = FGuid(reader) else: return None return prop
def __init__(self, reader: BinaryStream) -> None: Tag = reader.readUInt32() if Tag != PACKAGE_FILE_TAG and Tag != PACKAGE_FILE_TAG_SWAPPED: raise InvalidMagic("Not a UE package") if Tag == PACKAGE_FILE_TAG_SWAPPED: raise NotImplementedError( "Byte swapping for packages is not implemented") LegacyFileVersion = reader.readInt32() if LegacyFileVersion < 0: if LegacyFileVersion < -7: raise ParserException("Can not load UE3 packages.") if LegacyFileVersion != -4: reader.readInt32() # VersionUE3 version = reader.readInt32() self.FileVersionUE4 = EUnrealEngineObjectUE4Version( version) # version self.FileVersionLicenseeUE4 = EUnrealEngineObjectLicenseeUE4Version( reader.readInt32()) # Licensee Version if LegacyFileVersion <= -2: self.CustomVersionContainer = FCustomVersionContainer(reader) if self.FileVersionUE4.value != 0 and self.FileVersionLicenseeUE4.value != 0: self.bUnversioned = True else: raise ParserException("Can not load UE3 packages.") self.TotalHeaderSize = reader.readInt32() self.FolderName = reader.readFString() self.PackageFlags = reader.readUInt32() with suppress(ValueError): self.PackageFlags = EPackageFlags(self.PackageFlags) self.NameCount = reader.readInt32() self.NameOffset = reader.readInt32() if self.FileVersionUE4.value >= EUnrealEngineObjectUE4Version.VER_UE4_ADDED_PACKAGE_SUMMARY_LOCALIZATION_ID.value: self.LocalizationId = reader.readFString() if self.FileVersionUE4.value >= EUnrealEngineObjectUE4Version.VER_UE4_SERIALIZE_TEXT_IN_PACKAGES.value or self.FileVersionUE4.value == 0: self.GatherableTextDataCount = reader.readInt32() self.GatherableTextDataOffset = reader.readInt32() self.ExportCount = reader.readInt32() self.ExportOffset = reader.readInt32() self.ImportCount = reader.readInt32() self.ImportOffset = reader.readInt32() self.DependsOffset = reader.readInt32() if self.FileVersionUE4.value >= EUnrealEngineObjectUE4Version.VER_UE4_ADD_STRING_ASSET_REFERENCES_MAP.value or self.FileVersionUE4.value == 0: self.SoftPackageReferencesCount = reader.readInt32() self.SoftPackageReferencesOffset = reader.readInt32() if self.FileVersionUE4.value >= EUnrealEngineObjectUE4Version.VER_UE4_ADDED_SEARCHABLE_NAMES.value or self.FileVersionUE4.value == 0: self.SearchableNamesOffset = reader.readInt32() self.ThumbnailTableOffset = reader.readInt32() self.Guid = FGuid(reader) if reader.game == EUEVersion.GAME_VALORANT: reader.readInt64() # valorant self.GenerationCount = reader.readInt32() self.Generations = [] if self.GenerationCount > 0: for _ in range(self.GenerationCount): self.Generations.append(FGenerationInfo(reader)) if self.FileVersionUE4.value >= EUnrealEngineObjectUE4Version.VER_UE4_ENGINE_VERSION_OBJECT.value or self.FileVersionUE4.value == 0: self.SavedByEngineVersion = FEngineVersion(reader) if self.GetFileVersionUE4( ).value >= EUnrealEngineObjectUE4Version.VER_UE4_PACKAGE_SUMMARY_HAS_COMPATIBLE_ENGINE_VERSION.value or self.FileVersionUE4.value == 0: self.CompatibleWithEngineVersion = FEngineVersion(reader) self.CompressionFlags = ECompressionFlags(reader.readUInt32()) if self.CompressionFlags.name != "COMPRESS_None": raise ParserException( f"Incompatible compression flags {self.CompressionFlags.name}") self.CompressedChunks: List[FCompressedChunk] = reader.readTArray( FCompressedChunk) if len(self.CompressedChunks) != 0: # "CompressedChunks" raise ParserException("Package level compression is enabled") self.PackageSource = reader.readUInt32() self.AdditionalPackagesToCook = reader.readTArray( reader.readFString) # AdditionalPackagesToCook if LegacyFileVersion > -7: if reader.readInt32() != 0: # "NumTextureAllocations" raise ParserException("Can't load legacy UE3 file") # if reader.Ver >= VER_UE4_ASSET_REGISTRY_TAGS self.AssetRegistryDataOffset = reader.readInt32() self.BulkDataStartOffset = reader.readInt64() self.WorldTileInfoDataOffset = reader.readInt32() self.ChunkIDs = reader.readTArray(reader.readInt32) self.PreloadDependencyCount = reader.readInt32() self.PreloadDependencyOffset = reader.readInt32()
def __init__(self, reader: BinaryStream) -> None: self.Entries = {} magic = FGuid(reader) VersionNumber = ELocResVersion.Legacy if magic == self.LocResMagic: VersionNumber = ELocResVersion(reader.readByteToInt()) else: reader.seek(0) if VersionNumber > ELocResVersion.Latest: raise ParserException( f"LocRes is too new to be loaded (File Version: {VersionNumber.value}, Loader Version: {ELocResVersion.Latest.value})" ) LocalizedStringArray: List[FTextLocalizationResourceString] = [] if VersionNumber >= ELocResVersion.Compact: LocalizedStringArrayOffset = -1 LocalizedStringArrayOffset = reader.readInt64() CurrentFileOffset = reader.tell() reader.seek(LocalizedStringArrayOffset, 0) if LocalizedStringArrayOffset != -1: if VersionNumber >= ELocResVersion.Optimized_CRC32: LocalizedStringArray = reader.readTArray_W_Arg( FTextLocalizationResourceString, reader) reader.seek(CurrentFileOffset, 0) else: TmpLocalizedStringArray: List[str] TmpLocalizedStringArray = reader.readTArray(reader.readFString) reader.seek(CurrentFileOffset, 0) for LocalizedString in TmpLocalizedStringArray: LocalizedStringArray.append( FTextLocalizationResourceString().construct( LocalizedString, -1)) if VersionNumber >= ELocResVersion.Optimized_CRC32: reader.seek(4) # EntriesCount uint NamespaceCount = reader.readUInt32() for _ in range(NamespaceCount): if VersionNumber >= ELocResVersion.Optimized_CRC32: reader.seek(4) # StrHash uint Namespace = reader.readFString() KeyCount = reader.readUInt32() Entries: Dict[str, str] = {} for i in range(KeyCount): if VersionNumber >= ELocResVersion.Optimized_CRC32: reader.seek(4) # StrHash uint Key: str = reader.readFString() reader.seek(4) # SourceStringHash EntryLocalizedString: str if VersionNumber >= ELocResVersion.Compact: LocalizedStringIndex = reader.readInt32() if LocalizedStringIndex < len(LocalizedStringArray): LocalizedString = LocalizedStringArray[ LocalizedStringIndex] EntryLocalizedString = LocalizedString.String LocalizedString.RefCount -= 1 else: raise ParserException( f"LocRes has an invalid localized string index for namespace '{Namespace}' and key '{Key}'. This entry will have no translation." ) else: EntryLocalizedString = reader.readFString() Entries[Key] = EntryLocalizedString self.Entries[Namespace] = Entries
def deserialize(self, validpos) -> None: super().deserialize(validpos) reader = self.reader self.StripData = FStripDataFlags(reader) bCooked = reader.readBool() self.BodySetup = reader.readObject() if reader.version >= Versions.VER_UE4_STATIC_MESH_STORE_NAV_COLLISION: self.NavCollision = reader.readObject() if not self.StripData.isEditorDataStripped(): if reader.version < Versions.VER_UE4_DEPRECATED_STATIC_MESH_THUMBNAIL_PROPERTIES_REMOVED: FRotator(reader) # dummyThumbnailAngle reader.readFloat() # dummyThumbnailDistance highResSourceMeshName = reader.readString( ) # highResSourceMeshName highResSourceMeshCRC = reader.readUInt32() # self.LightingGuid = FGuid(reader) self.Sockets = reader.readTArray(reader.readObject) if not self.StripData.isEditorDataStripped: raise ParserException("Mesh with editor data not supported") # FStaticMeshRenderData if bCooked: if not bCooked: # how possible pass # https://github.com/FabianFG/JFortniteParse/blob/558fb2b96985aad5b90c96c8f28950021cf801a0/src/main/kotlin/me/fungames/jfortniteparse/ue4/assets/exports/UStaticMesh.kt#L59 # if unversioned MinMobileLODIdx int32 self.LODs = reader.readTArray_W_Arg(FStaticMeshLODResources, reader) #TODO fix this if reader.game >= GAME_UE4(23): NumInlinedLODs = reader.readUInt8() if bCooked: if reader.version >= Versions.VER_UE4_RENAME_CROUCHMOVESCHARACTERDOWN: isStripped = False if reader.version >= Versions.VER_UE4_RENAME_WIDGET_VISIBILITY: stripflag = FStripDataFlags(reader) isStripped = stripflag.isDataStrippedForServer() if reader.game >= GAME_UE4(21): # 4.21 uses additional strip flag for distance field distanceFieldDataStripFlag = 1 isStripped = isStripped | stripflag.isClassDataStripped( distanceFieldDataStripFlag) # ? if not isStripped: # serialize FDistanceFieldVolumeData for each LOD for _ in range(len(self.LODs) - 1): # wut why hasDistanceDataField = reader.readBool() if hasDistanceDataField: FDistanceFieldVolumeData(reader) # VolumeData self.Bounds = FBoxSphereBounds(reader) if reader.game != GAME_UE4(15): self.LODsShareStaticLighting = reader.readBool() if reader.game < GAME_UE4(15): reader.readBool() # bReducedBySimplygon if FRenderingObjectVersion().get( reader ) < FRenderingObjectVersion.TextureStreamingMeshUVChannelData: for _ in range( MAX_STATIC_UV_SETS_UE4): # StreamingTextureFactors reader.readFloat( ) # StreamingTextureFactor for each UV set reader.readFloat() # MaxStreamingTextureFactor if bCooked: maxNumLods = MAX_STATIC_LODS_UE4 if reader.game >= GAME_UE4( 9) else 4 for x in range(maxNumLods): if reader.game >= GAME_UE4(20): reader.readBool() # bFloatCooked self.ScreenSize.append(reader.readFloat()) # End of FStaticMeshRenderData if bCooked and reader.game >= GAME_UE4(20): hasOccluderData = reader.readBool() if hasOccluderData: reader.readTArray(FVector, reader) # Vertices reader.readTArray(reader.readUInt16) # Indics if reader.game >= GAME_UE4(14): hasSpeedTreeWind = reader.readBool() if hasSpeedTreeWind: pass # ignore else: if FEditorObjectVersion().get( reader ) >= FEditorObjectVersion.RefactorMeshEditorMaterials: # UE4.14+ - "Materials" are deprecated, added StaticMaterials self.StaticMaterials = reader.readTArray_W_Arg( FStaticMaterial, reader) if len(self.Materials) == 0 and len(self.StaticMaterials) > 0: material: FStaticMaterial for material in self.StaticMaterials: self.Materials.append(material.MaterialInterface)
def __init__(self, reader: BinaryStream) -> None: self.Guid = FGuid(reader).read()