private LayoutInfo GetLayoutInfo(SerializedFileScheme serialized)
{
if (SerializedFileMetadata.HasPlatform(serialized.Header.Version))
{
SerializedFileMetadata metadata = serialized.Metadata;
return(new LayoutInfo(metadata.UnityVersion, metadata.TargetPlatform, serialized.Flags));
}
else
{
const Platform DefaultPlatform = Platform.StandaloneWinPlayer;
const TransferInstructionFlags DefaultFlags = TransferInstructionFlags.SerializeGameRelease;
BundleFileScheme bundle = GetBundleFile();
if (bundle == null)
{
Logger.Log(LogType.Warning, LogCategory.Import, "Unable to determine layout for provided files. Tring default one");
Version version = GetDefaultGenerationVersions(serialized.Header.Version);
return(new LayoutInfo(version, DefaultPlatform, DefaultFlags));
}
else
{
Logger.Log(LogType.Warning, LogCategory.Import, "Unable to precisly determine layout for provided files. Tring default one");
return(new LayoutInfo(bundle.Header.EngineVersion, DefaultPlatform, DefaultFlags));
}
}
}
private SerializedFileScheme(SmartStream stream, long offset, long size, string filePath, string fileName, TransferInstructionFlags flags) :
base(stream, offset, size, filePath, fileName)
{
Flags = flags;
Header = new SerializedFileHeader(Name);
Metadata = new SerializedFileMetadata(Name);
}
public static void CombineFormats(FileGeneration generation, SerializedFileMetadata origin)
{
RTTIClassHierarchyDescriptorConverter.CombineFormats(generation, ref origin.Hierarchy);
if (AssetEntry.HasTypeIndex(generation))
{
for (int i = 0; i < origin.Entries.Length; i++)
{
ref AssetEntry entry = ref origin.Entries[i];
ref RTTIBaseClassDescriptor type = ref origin.Hierarchy.Types[entry.TypeIndex];
entry.TypeID = type.ClassID == ClassIDType.MonoBehaviour ? (-type.ScriptID - 1) : (int)type.ClassID;
entry.ClassID = type.ClassID;
entry.ScriptID = type.ScriptID;
}
private void ReadScheme()
{
using (EndianReader reader = new EndianReader(Stream, EndianType.BigEndian))
{
Header.Read(reader);
}
if (SerializedFileMetadata.IsMetadataAtTheEnd(Header.Version))
{
Stream.Position = Header.FileSize - Header.MetadataSize;
}
Metadata.Read(Stream, Header);
SerializedFileMetadataConverter.CombineFormats(Header.Version, Metadata);
UpdateFlags();
}
private void UpdateFileVersion()
{
if (!SerializedFileMetadata.HasSignature(Header.Version) && BuildSettings.HasVersion(Version))
{
foreach (Object asset in FetchAssets())
{
if (asset.ClassID == ClassIDType.BuildSettings)
{
BuildSettings settings = (BuildSettings)asset;
Metadata.UnityVersion = Version.Parse(settings.Version);
return;
}
}
}
}
private static AssetLayout GetLayout(GameCollection collection, SerializedFileScheme scheme, string name)
{
if (!SerializedFileMetadata.HasPlatform(scheme.Header.Version))
{
return(collection.Layout);
}
if (FilenameUtils.IsDefaultResource(name))
{
return(collection.Layout);
}
LayoutInfo info = new LayoutInfo(scheme.Metadata.UnityVersion, scheme.Metadata.TargetPlatform, scheme.Flags);
return(collection.GetLayout(info));
}
private void ReadScheme()
{
using (PartialStream stream = new PartialStream(m_stream, m_offset, m_size))
{
using (EndianReader reader = new EndianReader(stream, EndianType.BigEndian))
{
Header.Read(reader);
}
EndianType endianess = EndianType.LittleEndian;
if (SerializedFileHeader.HasEndian(Header.Generation))
{
endianess = Header.SwapEndianess ? EndianType.BigEndian : EndianType.LittleEndian;
}
using (SerializedReader reader = new SerializedReader(stream, endianess, Name, Header.Generation))
{
if (SerializedFileMetadata.IsMetadataAtTheEnd(reader.Generation))
{
reader.BaseStream.Position = Header.FileSize - Header.MetadataSize;
reader.BaseStream.Position++;
}
Metadata.Read(reader);
}
}
SerializedFileMetadataConverter.CombineFormats(Header.Generation, Metadata);
RTTIClassHierarchyDescriptorConverter.FixResourceVersion(Name, ref Metadata.Hierarchy);
#warning TEMP HACK
if (Metadata.Hierarchy.Platform == Platform.NoTarget)
{
Flags = TransferInstructionFlags.NoTransferInstructionFlags;
}
if (FilenameUtils.IsEngineResource(Name) || Header.Generation < FileGeneration.FG_500a1 && FilenameUtils.IsBuiltinExtra(Name))
{
Flags |= TransferInstructionFlags.IsBuiltinResourcesFile;
}
if (Header.SwapEndianess)
{
Flags |= TransferInstructionFlags.SwapEndianess;
}
}
private void ReadScheme()
{
using (EndianReader reader = new EndianReader(Stream, EndianType.BigEndian))
{
Header.Read(reader);
}
if (SerializedFileMetadata.IsMetadataAtTheEnd(Header.Generation))
{
Stream.Position = Header.FileSize - Header.MetadataSize;
Stream.Position++;
}
using (SerializedReader reader = new SerializedReader(Stream, Header.GetEndianType(), Name, Header.Generation))
{
Metadata.Read(reader);
}
SerializedFileMetadataConverter.CombineFormats(Header.Generation, Metadata);
RTTIClassHierarchyDescriptorConverter.FixResourceVersion(Name, ref Metadata.Hierarchy);
UpdateFlags();
}
public static void CombineFormats(FormatVersion generation, SerializedFileMetadata origin)
{
if (!SerializedFileMetadata.HasEnableTypeTree(generation))
{
origin.EnableTypeTree = true;
}
for (int i = 0; i < origin.Types.Length; i++)
{
SerializedTypeConverter.CombineFormats(generation, ref origin.Types[i]);
}
if (generation >= FormatVersion.RefactorTypeData)
{
for (int i = 0; i < origin.Object.Length; i++)
{
ref ObjectInfo entry = ref origin.Object[i];
ref SerializedType type = ref origin.Types[entry.TypeID];
entry.ClassID = type.TypeID;
entry.ScriptTypeIndex = type.ScriptTypeIndex;
entry.Stripped = type.IsStrippedType;
}
private void ReadAssets(EndianReader reader)
{
AssemblyManager.Version = Version;
HashSet <int> preloaded = new HashSet <int>();
using (AssetReader assetReader = new AssetReader(reader, Version, Platform, Flags))
{
if (SerializedFileMetadata.HasPreload(Header.Generation))
{
foreach (ObjectPtr ptr in Metadata.Preloads)
{
if (ptr.FileID == 0)
{
int index = m_assetEntryLookup[ptr.PathID];
ReadAsset(assetReader, ref Metadata.Entries[index]);
preloaded.Add(index);
}
}
}
for (int i = 0; i < Metadata.Entries.Length; i++)
{
if (Metadata.Entries[i].ClassID == ClassIDType.MonoScript)
{
if (preloaded.Add(i))
{
ReadAsset(assetReader, ref Metadata.Entries[i]);
}
}
}
for (int i = 0; i < Metadata.Entries.Length; i++)
{
if (!preloaded.Contains(i))
{
ReadAsset(assetReader, ref Metadata.Entries[i]);
}
}
}
}
private void ReadAssets(EndianReader reader)
{
HashSet <long> preloaded = new HashSet <long>();
using (AssetReader assetReader = new AssetReader(reader, Version, Platform, Flags))
{
if (SerializedFileMetadata.IsReadPreload(Header.Generation))
{
foreach (ObjectPtr ptr in Metadata.Preloads)
{
if (ptr.FileID == 0)
{
AssetEntry info = Metadata.Entries[ptr.PathID];
ReadAsset(assetReader, info);
preloaded.Add(ptr.PathID);
}
}
}
foreach (KeyValuePair <long, AssetEntry> infoPair in Metadata.Entries)
{
if (infoPair.Value.ClassID == ClassIDType.MonoScript)
{
if (!preloaded.Contains(infoPair.Key))
{
ReadAsset(assetReader, infoPair.Value);
preloaded.Add(infoPair.Key);
}
}
}
foreach (AssetEntry info in Metadata.Entries.Values)
{
if (!preloaded.Contains(info.PathID))
{
ReadAsset(assetReader, info);
}
}
}
}
internal void ReadData(Stream stream)
{
using (AssetReader assetReader = new AssetReader(stream, GetEndianType(), Layout))
{
if (SerializedFileMetadata.HasPreload(Header.Generation))
{
foreach (ObjectPtr ptr in Metadata.Preloads)
{
if (ptr.FileID == 0)
{
int index = m_assetEntryLookup[ptr.PathID];
ReadAsset(assetReader, ref Metadata.Entries[index]);
}
}
}
for (int i = 0; i < Metadata.Entries.Length; i++)
{
if (Metadata.Entries[i].ClassID == ClassIDType.MonoScript)
{
if (!m_assets.ContainsKey(Metadata.Entries[i].PathID))
{
ReadAsset(assetReader, ref Metadata.Entries[i]);
}
}
}
for (int i = 0; i < Metadata.Entries.Length; i++)
{
if (!m_assets.ContainsKey(Metadata.Entries[i].PathID))
{
ReadAsset(assetReader, ref Metadata.Entries[i]);
}
}
}
}
private void UpdateFlags()
{
Flags = TransferInstructionFlags.SerializeGameRelease;
if (SerializedFileMetadata.HasPlatform(Header.Version))
{
if (Metadata.TargetPlatform == Platform.NoTarget)
{
Flags = TransferInstructionFlags.NoTransferInstructionFlags;
if (FilePath.EndsWith(".unity", StringComparison.Ordinal))
{
Flags |= TransferInstructionFlags.SerializeEditorMinimalScene;
}
}
}
if (FilenameUtils.IsEngineResource(Name) || Header.Version < FormatVersion.Unknown_10 && FilenameUtils.IsBuiltinExtra(Name))
{
Flags |= TransferInstructionFlags.IsBuiltinResourcesFile;
}
if (Header.Endianess || Metadata.SwapEndianess)
{
Flags |= TransferInstructionFlags.SwapEndianess;
}
}
internal void ReadData(Stream stream)
{
using (AssetReader assetReader = new AssetReader(stream, GetEndianType(), Layout))
{
if (SerializedFileMetadata.HasScriptTypes(Header.Version))
{
foreach (LocalSerializedObjectIdentifier ptr in Metadata.ScriptTypes)
{
if (ptr.LocalSerializedFileIndex == 0)
{
int index = m_assetEntryLookup[ptr.LocalIdentifierInFile];
ReadAsset(assetReader, ref Metadata.Object[index]);
}
}
}
for (int i = 0; i < Metadata.Object.Length; i++)
{
if (Metadata.Object[i].ClassID == ClassIDType.MonoScript)
{
if (!m_assets.ContainsKey(Metadata.Object[i].FileID))
{
ReadAsset(assetReader, ref Metadata.Object[i]);
}
}
}
for (int i = 0; i < Metadata.Object.Length; i++)
{
if (!m_assets.ContainsKey(Metadata.Object[i].FileID))
{
ReadAsset(assetReader, ref Metadata.Object[i]);
}
}
}
}
