internal void Read(EndianReader reader)
{
if (RTTIClassHierarchyDescriptor.HasSignature(Header.Generation))
{
ReadAssets(reader);
}
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 {Name} as {version} version");
Metadata.Hierarchy.Version.Parse(version);
m_assets.Clear();
try
{
ReadAssets(reader);
UpdateFileVersion();
break;
}
catch
{
Logger.Log(LogType.Debug, LogCategory.Import, "Faild");
if (i == versions.Length - 1)
{
throw;
}
}
}
}
}
private LayoutInfo GetLayoutInfo(SerializedFileScheme serialized)
{
if (RTTIClassHierarchyDescriptor.HasPlatform(serialized.Header.Generation))
{
RTTIClassHierarchyDescriptor hierarchy = serialized.Metadata.Hierarchy;
return(new LayoutInfo(hierarchy.Version, hierarchy.Platform, 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.Generation);
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));
}
}
}
public void Read(SerializedFileReader reader, RTTIClassHierarchyDescriptor heirarchy)
{
if (IsReadLongID(reader.Generation))
{
reader.AlignStream(AlignType.Align4);
PathID = reader.ReadInt64();
}
else
{
PathID = reader.ReadInt32();
}
Offset = reader.ReadUInt32();
Size = reader.ReadInt32();
if (IsReadTypeIndex(reader.Generation))
{
int TypeIndex = reader.ReadInt32();
RTTIBaseClassDescriptor type = heirarchy.Types[TypeIndex];
TypeID = type.ClassID == ClassIDType.MonoBehaviour ? (-type.ScriptID - 1) : (int)type.ClassID;
ClassID = type.ClassID;
ScriptID = type.ScriptID;
}
else
{
TypeID = reader.ReadInt32();
ClassID = (ClassIDType)reader.ReadInt16();
ScriptID = reader.ReadInt16();
}
if (IsReadUnknown(reader.Generation))
{
IsStripped = reader.ReadBoolean();
}
}
public static void FixResourceVersion(string name, ref RTTIClassHierarchyDescriptor origin)
{
if (origin.Version == new Version(5, 6, 4, VersionType.Patch, 1))
{
if (FilenameUtils.IsDefaultResource(name))
{
origin.Version = new Version(5, 6, 5, VersionType.Final);
}
}
}
public static void CombineFormats(FileGeneration generation, ref RTTIClassHierarchyDescriptor origin)
{
if (!RTTIClassHierarchyDescriptor.HasSerializeTypeTrees(generation))
{
origin.SerializeTypeTrees = true;
}
for (int i = 0; i < origin.Types.Length; i++)
{
RTTIBaseClassDescriptorConverter.CombineFormats(generation, ref origin.Types[i]);
}
}
private static AssetLayout GetLayout(GameCollection collection, SerializedFileScheme scheme, string name)
{
if (!RTTIClassHierarchyDescriptor.HasPlatform(scheme.Header.Generation))
{
return(collection.Layout);
}
if (FilenameUtils.IsDefaultResource(name))
{
return(collection.Layout);
}
LayoutInfo info = new LayoutInfo(scheme.Metadata.Hierarchy.Version, scheme.Metadata.Hierarchy.Platform, scheme.Flags);
return(collection.GetLayout(info));
}
private void UpdateFileVersion()
{
if (!RTTIClassHierarchyDescriptor.HasSignature(Header.Generation) && BuildSettings.HasVersion(Version))
{
foreach (Object asset in FetchAssets())
{
if (asset.ClassID == ClassIDType.BuildSettings)
{
BuildSettings settings = (BuildSettings)asset;
Metadata.Hierarchy.Version = Version.Parse(settings.Version);
return;
}
}
}
}
private void AddSerializedFile(SerializedFile file)
{
if (m_files.Any(t => t.Name == file.Name))
{
throw new ArgumentException($"Assets file with name '{file.Name}' already presents in collection", nameof(file));
}
if (!RTTIClassHierarchyDescriptor.IsReadSignature(file.Header.Generation))
{
SetVersion(file);
}
if (m_files.Any(t => !t.Platform.IsCompatible(file.Platform)))
{
throw new ArgumentException($"Assets file '{file.Name}' has incompatible with other assets files platform {file.Platform} ", nameof(file));
}
m_files.Add(file);
}
private void UpdateFlags()
{
Flags = TransferInstructionFlags.SerializeGameRelease;
if (RTTIClassHierarchyDescriptor.HasPlatform(Header.Generation))
{
if (Metadata.Hierarchy.Platform == Platform.NoTarget)
{
Flags = TransferInstructionFlags.NoTransferInstructionFlags;
if (FilePath.EndsWith(".unity", StringComparison.Ordinal))
{
Flags |= TransferInstructionFlags.SerializeEditorMinimalScene;
}
}
}
if (FilenameUtils.IsEngineResource(Name) || Header.Generation < FileGeneration.FG_500a1 && FilenameUtils.IsBuiltinExtra(Name))
{
Flags |= TransferInstructionFlags.IsBuiltinResourcesFile;
}
if (Header.SwapEndianess || Metadata.SwapEndianess)
{
Flags |= TransferInstructionFlags.SwapEndianess;
}
}
