public void Read(SerializedFileStream stream) { ClassID = (ClassIDType)stream.ReadInt32(); if (IsReadUnknown(stream.Generation)) { Unknown = stream.ReadByte(); ScriptID = stream.ReadInt16(); } if (IsReadHash(stream.Generation)) { if (IsOldHashType(stream.Generation)) { if ((int)ClassID <= -1) { ScriptHash.Read(stream); } } else { if (ClassID == ClassIDType.MonoBehaviour) { ScriptHash.Read(stream); } } TypeHash.Read(stream); } // isSerializeTypeTrees if (Tree != null) { Tree.Read(stream); } }
public void Read(SerializedFileStream stream) { if (IsReadSignature(stream.Generation)) { string signature = stream.ReadStringZeroTerm(); Version.Parse(signature); } if (IsReadAttributes(stream.Generation)) { Platform = (Platform)stream.ReadUInt32(); if (!Enum.IsDefined(typeof(Platform), Platform)) { throw new Exception($"Unsuported platform {Platform} for asset file '{Name}'"); } } if (IsReadSerializeTypeTrees(stream.Generation)) { SerializeTypeTrees = stream.ReadBoolean(); } else { SerializeTypeTrees = true; } m_types = stream.ReadArray(() => new RTTIBaseClassDescriptor(SerializeTypeTrees)); if (IsReadUnknown(stream.Generation)) { Unknown = stream.ReadInt32(); } }
public void Read(SerializedFileStream stream) { if (IsRead5Format(stream.Generation)) { int nodesCount = stream.ReadInt32(); if (nodesCount < 0) { throw new Exception($"Invalid type tree's node count {nodesCount}"); } int stringSize = stream.ReadInt32(); if (stringSize < 0) { throw new Exception($"Invalid type tree's string size {stringSize}"); } m_nodes = new TypeTreeNode[nodesCount]; long stringPosition = stream.BaseStream.Position + nodesCount * TypeTreeNode.NodeSize; for (int i = 0; i < nodesCount; i++) { TypeTreeNode node = new TypeTreeNode(); node.Read(stream, stringPosition); m_nodes[i] = node; } stream.BaseStream.Position += stringSize; } else { List <TypeTreeNode> nodes = new List <TypeTreeNode>(); ReadTreeNode(stream, nodes, 0); m_nodes = nodes.ToArray(); } }
public void Read(SerializedFileStream stream) { Type = stream.ReadStringZeroTerm(); Name = stream.ReadStringZeroTerm(); ByteSize = stream.ReadInt32(); Index = stream.ReadInt32(); IsArray = stream.ReadInt32() != 0; Version = stream.ReadInt32(); MetaFlag = stream.ReadUInt32(); }
public void Read(Stream baseStream, Action <string> requestDependencyCallback) { using (EndianStream stream = new EndianStream(baseStream, baseStream.Position, EndianType.BigEndian)) { long startPosition = baseStream.Position; Header.Read(stream); stream.EndianType = Header.Endianess ? EndianType.BigEndian : EndianType.LittleEndian; if (IsTableAtTheEnd(Header.Generation)) { stream.BaseStream.Position = startPosition + Header.FileSize - Header.MetadataSize; stream.BaseStream.Position++; } using (SerializedFileStream fileStream = new SerializedFileStream(stream, Header.Generation)) { Metadata.Read(fileStream); } foreach (FileIdentifier dependency in Dependencies) { requestDependencyCallback?.Invoke(dependency.FilePath); } if (RTTIClassHierarchyDescriptor.IsReadSignature(Header.Generation)) { ReadAssets(stream, startPosition); } else { Logger.Log(LogType.Warning, LogCategory.Import, $"Can't determine file version for generation {Header.Generation} for file '{Name}'"); string[] versions = GetGenerationVersions(Header.Generation); for (int i = 0; i < versions.Length; i++) { string version = versions[i]; Logger.Log(LogType.Debug, LogCategory.Import, $"Try parse {nameof(SerializedFile)} as {version} version"); Version.Parse(version); try { ReadAssets(stream, startPosition); break; } catch { Logger.Log(LogType.Debug, LogCategory.Import, "Faild"); if (i == versions.Length - 1) { throw; } } } } } }
public void Read(SerializedFileStream stream) { if (IsReadAssetName(stream.Generation)) { AssetPath = stream.ReadStringZeroTerm(); } if (IsReadHash(stream.Generation)) { Hash.Read(stream); Type = (AssetType)stream.ReadInt32(); } FilePath = stream.ReadStringZeroTerm(); }
public void Read(SerializedFileStream stream) { if (IsReadAssetName(stream.Generation)) { AssetPath = stream.ReadStringZeroTerm(); } if (IsReadHash(stream.Generation)) { Hash.Read(stream); Type = (AssetType)stream.ReadInt32(); } FilePathOrigin = stream.ReadStringZeroTerm(); FilePath = FilenameUtils.FixFileIdentifier(FilePathOrigin); }
private static void ReadTreeNode(SerializedFileStream stream, ICollection <TypeTreeNode> nodes, byte depth) { TypeTreeNode node = new TypeTreeNode(depth); node.Read(stream); nodes.Add(node); int childCount = stream.ReadInt32(); for (int i = 0; i < childCount; i++) { ReadTreeNode(stream, nodes, (byte)(depth + 1)); } }
public void Read(SerializedFileStream stream, long stringPosition) { Version = stream.ReadUInt16(); Depth = stream.ReadByte(); IsArray = stream.ReadBoolean(); uint type = stream.ReadUInt32(); uint name = stream.ReadUInt32(); ByteSize = stream.ReadInt32(); Index = stream.ReadInt32(); MetaFlag = stream.ReadUInt32(); Type = ReadString(stream, stringPosition, type); Name = ReadString(stream, stringPosition, name); }
private static string ReadString(SerializedFileStream stream, long stringPosition, uint value) { bool isCustomType = (value & 0x80000000) == 0; if (isCustomType) { long position = stream.BaseStream.Position; stream.BaseStream.Position = stringPosition + value; string stringValue = stream.ReadStringZeroTerm(); stream.BaseStream.Position = position; return(stringValue); } else { uint type = value & 0x7FFFFFFF; TreeNodeType nodeType = (TreeNodeType)type; if (!Enum.IsDefined(typeof(TreeNodeType), nodeType)) { throw new Exception($"Unsupported asset class type name '{nodeType}''"); } return(nodeType.ToTypeString()); } }
public void Read(SerializedFileStream stream) { Hierarchy.Read(stream); int count = stream.ReadInt32(); m_objects = new Dictionary <long, ObjectInfo>(count); for (int i = 0; i < count; i++) { ObjectInfo objectInfo = new ObjectInfo(); objectInfo.Read(stream); m_objects.Add(objectInfo.PathID, objectInfo); } if (IsReadPreload(stream.Generation)) { m_preloads = stream.ReadArray <ObjectPtr>(); } m_dependencies = stream.ReadArray <FileIdentifier>(); if (IsReadUnknown(stream.Generation)) { Unknown = stream.ReadStringZeroTerm(); } }