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,
min_version=Versions.VER_UE4_REMOVED_STRIP_DATA):
if reader.version >= min_version:
self.globalStripFlags = reader.readByteToInt()
self.classStripFlags = reader.readByteToInt()
else:
self.globalStripFlags = 0
self.classStripFlags = 0
def __init__(self, reader: BinaryStream, readType,
tag): #TODO: handle enums
self.position = reader.base_stream.tell()
if readType == PropertyTagData.BaseProperty.ReadType.NORMAL:
self.Value = reader.readByteToInt()
elif readType == PropertyTagData.BaseProperty.ReadType.MAP:
self.Value = reader.readUInt32()
elif readType == PropertyTagData.BaseProperty.ReadType.ARRAY:
self.Value = reader.readByteToInt()
else:
raise Exception(f"hmm {readType.name}")
def __init__(self, reader: BinaryStream):
self.CookedSerialOffset = reader.readUInt64()
self.CookedSerialSize = reader.readUInt64()
self.ObjectName = FMappedName().read(reader)
self.OuterIndex = FPackageObjectIndex(reader)
self.ClassIndex = FPackageObjectIndex(reader)
self.SuperIndex = FPackageObjectIndex(reader)
self.TemplateIndex = FPackageObjectIndex(reader)
self.GlobalImportIndex = FPackageObjectIndex(reader)
self.ObjectFlags = reader.readUInt32()
try:
self.ObjectFlags = EObjectFlags(self.ObjectFlags)
except:
pass
self.FilterFlags = EExportFilterFlags(reader.readByteToInt())
reader.seek(3)
def __init__(self, reader: BinaryStream, tag: FPropertyTag, readType):
self.position = reader.base_stream.tell()
from .BaseProperty import ReadType
if readType == ReadType.ZERO: #ZERO
self.Value = FName(self.IndexToEnum(reader, tag, 0))
elif readType.value == 0:
byteValue = 0
innerType = getattr(tag, "InnerType", None)
if innerType is not None:
from .BaseProperty import ReadAsValue
byteValue = ReadAsValue(reader, tag.InnerData, innerType, 0)
else:
byteValue = reader.readByteToInt()
self.Value = FName(self.IndexToEnum(reader, tag, byteValue))
else:
self.Value = reader.readFName()
def __init__(self, reader: BinaryStream, tag: 'FPropertyTag', readType): # for later use
self.position = reader.base_stream.tell()
if not reader.has_unversioned_properties and readType == 0:
self.Value = getattr(tag, "BoolVal", True)
elif readType.value in [0, 1, 2]: # Normal, MAP and Array
self.Value = bool(reader.readByteToInt())
def __init__(self, reader: BinaryStream):
self.position = reader.base_stream.tell()
self.R = reader.readByteToInt()
self.G = reader.readByteToInt()
self.B = reader.readByteToInt()
self.A = reader.readByteToInt()
def __init__(self, reader: BinaryStream):
self.ChunkHash = FIoChunkHash(reader)
self.Flags = FIoStoreTocEntryMetaFlags(reader.readByteToInt())
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 __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
