public void ReadSerializedFiles()
{
while (m_files.Count > 0)
{
SerializedFile file = m_files.First().Key;
ReadFile(file);
}
}
private bool IsSceneSerializedFile(SerializedFile file)
{
foreach (AssetEntry entry in file.Metadata.Entries)
{
if (entry.ClassID.IsSceneSettings())
{
return(true);
}
}
return(false);
}
private bool IsSceneSerializedFile(SerializedFile file)
{
foreach (ObjectInfo entry in file.Metadata.Object)
{
if (entry.ClassID.IsSceneSettings())
{
return(true);
}
}
return(false);
}
internal void AddFile(FileScheme scheme, IFileCollection collection, IAssemblyManager manager)
{
switch (scheme.SchemeType)
{
case FileEntryType.Serialized:
{
SerializedFileScheme serializedScheme = (SerializedFileScheme)scheme;
SerializedFile file = serializedScheme.ReadFile(collection, manager);
m_serializedFiles.Add(file);
OnSerializedFileAdded(file);
}
break;
case FileEntryType.Bundle:
{
BundleFileScheme bundleScheme = (BundleFileScheme)scheme;
BundleFile bundle = bundleScheme.ReadFile(collection, manager);
m_fileLists.Add(bundle);
OnFileListAdded(bundle);
}
break;
case FileEntryType.Archive:
{
ArchiveFileScheme archiveScheme = (ArchiveFileScheme)scheme;
ArchiveFile archive = archiveScheme.ReadFile(collection, manager);
m_fileLists.Add(archive);
OnFileListAdded(archive);
}
break;
case FileEntryType.Web:
{
WebFileScheme webScheme = (WebFileScheme)scheme;
WebFile webFile = webScheme.ReadFile(collection, manager);
m_fileLists.Add(webFile);
OnFileListAdded(webFile);
}
break;
case FileEntryType.Resource:
{
ResourceFileScheme resourceScheme = (ResourceFileScheme)scheme;
ResourceFile resource = resourceScheme.ReadFile();
m_resourceFiles.Add(resource);
OnResourceFileAdded(resource);
}
break;
default:
throw new NotSupportedException(scheme.SchemeType.ToString());
}
}
public SerializedFile ReadFile(IFileCollection collection, IAssemblyManager manager)
{
SerializedFile file = new SerializedFile(collection, manager, this);
using (PartialStream stream = new PartialStream(m_stream, m_offset, m_size))
{
EndianType endianess = Header.SwapEndianess ? EndianType.BigEndian : EndianType.LittleEndian;
using (EndianReader reader = new EndianReader(stream, endianess, stream.Position))
{
file.Read(reader);
}
}
return(file);
}
internal void ReadSerializedFile(Stream stream, string filePath, string fileName, TransferInstructionFlags flags)
{
SerializedFile.Parameters pars = new SerializedFile.Parameters()
{
FileCollection = this,
AssemblyManager = AssemblyManager,
FilePath = filePath,
Name = fileName,
DependencyCallback = OnRequestDependency,
Flags = flags,
};
SerializedFile file = SerializedFile.Load(pars);
AddSerializedFile(file);
}
internal void ReadSerializedFile(Stream stream, string filePath, string fileName, Action <string> dependencyCallback)
{
SerializedFile.Parameters pars = new SerializedFile.Parameters()
{
FileCollection = this,
AssemblyManager = AssemblyManager,
FilePath = filePath,
Name = fileName,
DependencyCallback = dependencyCallback,
Flags = TransferInstructionFlags.LoadAndUnloadAssetsDuringBuild | TransferInstructionFlags.SerializeGameRelease,
};
SerializedFile file = SerializedFile.Read(stream, pars);
AddSerializedFile(file);
}
public void LoadSerializedFile(string filePath, TransferInstructionFlags flags)
{
SerializedFile.Parameters pars = new SerializedFile.Parameters()
{
FileCollection = this,
AssemblyManager = AssemblyManager,
FilePath = filePath,
Name = Path.GetFileName(filePath),
DependencyCallback = OnRequestDependency,
Flags = flags,
};
SerializedFile file = SerializedFile.Load(pars);
AddSerializedFile(file);
}
public void LoadSerializedFile(string filePath)
{
SerializedFile.Parameters pars = new SerializedFile.Parameters()
{
FileCollection = this,
AssemblyManager = AssemblyManager,
FilePath = filePath,
Name = Path.GetFileName(filePath),
DependencyCallback = OnRequestDependency,
Flags = TransferInstructionFlags.LoadAndUnloadAssetsDuringBuild | TransferInstructionFlags.SerializeGameRelease,
};
SerializedFile file = SerializedFile.Load(pars);
AddSerializedFile(file);
}
internal void AddFile(GameProcessorContext context, FileScheme scheme)
{
switch (scheme.SchemeType)
{
case FileEntryType.Serialized:
{
SerializedFileScheme serializedScheme = (SerializedFileScheme)scheme;
SerializedFile file = serializedScheme.ReadFile(context);
AddSerializedFile(file);
}
break;
case FileEntryType.Bundle:
{
BundleFileScheme bundleScheme = (BundleFileScheme)scheme;
BundleFile bundle = bundleScheme.ReadFile(context);
AddFileList(bundle);
}
break;
case FileEntryType.Archive:
{
ArchiveFileScheme archiveScheme = (ArchiveFileScheme)scheme;
ArchiveFile archive = archiveScheme.ReadFile(context);
AddFileList(archive);
}
break;
case FileEntryType.Web:
{
WebFileScheme webScheme = (WebFileScheme)scheme;
WebFile webFile = webScheme.ReadFile(context);
AddFileList(webFile);
}
break;
case FileEntryType.Resource:
{
ResourceFileScheme resourceScheme = (ResourceFileScheme)scheme;
ResourceFile resource = resourceScheme.ReadFile();
AddResourceFile(resource);
}
break;
default:
throw new NotSupportedException(scheme.SchemeType.ToString());
}
}
private void SetVersion(SerializedFile file)
{
if (file.Version.IsSet)
{
return;
}
foreach (Object asset in file.FetchAssets())
{
if (asset.ClassID == ClassIDType.BuildSettings)
{
BuildSettings settings = (BuildSettings)asset;
file.Metadata.Hierarchy.Version.Parse(settings.Version);
break;
}
}
}
public static FileScheme ReadScheme(SmartStream stream, string filePath, string fileName)
{
if (BundleFile.IsBundleFile(stream))
{
return(BundleFile.ReadScheme(stream, filePath, fileName));
}
if (ArchiveFile.IsArchiveFile(stream))
{
return(ArchiveFile.ReadScheme(stream, filePath, fileName));
}
if (WebFile.IsWebFile(stream))
{
return(WebFile.ReadScheme(stream, filePath));
}
if (SerializedFile.IsSerializedFile(stream))
{
return(SerializedFile.ReadScheme(stream, filePath, fileName));
}
return(ResourceFile.ReadScheme(stream, filePath, fileName));
}
protected override void OnSerializedFileAdded(SerializedFile file)
{
if (m_files.ContainsKey(file.Name))
{
throw new ArgumentException($"{nameof(SerializedFile)} with name '{file.Name}' already presents in the collection", nameof(file));
}
if (file.Platform != Layout.Info.Platform)
{
Logger.Log(LogType.Warning, LogCategory.Import, $"'{file.Name}' is incompatible with platform of the game collection");
}
if (file.Version != Layout.Info.Version)
{
Logger.Log(LogType.Warning, LogCategory.Import, $"'{file.Name}' is incompatible with version of the game collection");
}
m_files.Add(file.Name, file);
if (IsSceneSerializedFile(file))
{
m_scenes.Add(file);
}
}
protected override void OnSerializedFileAdded(SerializedFile file)
{
if (m_files.ContainsKey(file.Name))
{
throw new ArgumentException($"{nameof(SerializedFile)} with name '{file.Name}' already presents in the collection", nameof(file));
}
/*if (file.Platform != Platform)
* {
* throw new ArgumentException($"{nameof(SerializedFile)} '{file.Name}' is incompatible with platform of other asset files {file.Platform} ", nameof(file));
* }
* if (file.Version != Version)
* {
* throw new ArgumentException($"{nameof(SerializedFile)} '{file.Name}' is incompatible with version of other asset files {file.Platform} ", nameof(file));
* }*/
m_files.Add(file.Name, file);
if (IsSceneSerializedFile(file))
{
m_scenes.Add(file);
}
}
public void Unload(string filepath)
{
for (int i = 0; i > m_files.Count; i++)
{
SerializedFile file = m_files[i];
if (file.FilePath == filepath)
{
m_files.RemoveAt(i);
i--;
}
}
for (int i = 0; i > m_resources.Count; i++)
{
ResourcesFile file = m_resources[i];
if (file.FilePath.StartsWith(filepath, StringComparison.Ordinal))
{
file.Dispose();
m_resources.RemoveAt(i);
i--;
}
}
}
public static FileScheme ReadScheme(byte[] buffer, string filePath, string fileName)
{
using (MemoryStream stream = new MemoryStream(buffer, 0, buffer.Length, false))
{
if (BundleFile.IsBundleFile(stream))
{
return(BundleFile.ReadScheme(buffer, filePath, fileName));
}
if (ArchiveFile.IsArchiveFile(stream))
{
return(ArchiveFile.ReadScheme(buffer, filePath, fileName));
}
if (WebFile.IsWebFile(stream))
{
return(WebFile.ReadScheme(buffer, filePath));
}
if (SerializedFile.IsSerializedFile(stream))
{
return(SerializedFile.ReadScheme(buffer, filePath, fileName));
}
return(ResourceFile.ReadScheme(buffer, filePath, fileName));
}
}
private void ReadFile(SerializedFile file)
{
#warning TODO: fix cross dependencies
m_knownFiles.Add(file.Name);
foreach (FileIdentifier dependency in file.Metadata.Externals)
{
if (!m_knownFiles.Contains(dependency.PathName))
{
if (Collection.GameFiles.TryGetValue(dependency.PathName, out SerializedFile dependencyFile))
{
ReadFile(dependencyFile);
}
else
{
m_knownFiles.Add(dependency.PathName);
}
}
}
SerializedFileScheme scheme = m_files[file];
file.ReadData(scheme.Stream);
scheme.Dispose();
m_files.Remove(file);
}
public static FileScheme ReadScheme(SmartStream stream, long offset, long size, string filePath, string fileName)
{
if (BundleFile.IsBundleFile(stream, offset, size))
{
return(BundleFile.ReadScheme(stream, offset, size, filePath, fileName));
}
if (ArchiveFile.IsArchiveFile(stream, offset, size))
{
return(ArchiveFile.ReadScheme(stream, offset, size, filePath, fileName));
}
if (WebFile.IsWebFile(stream, offset, size))
{
return(WebFile.ReadScheme(stream, offset, size, filePath, fileName));
}
if (ResourceFile.IsDefaultResourceFile(fileName))
{
return(ResourceFile.ReadScheme(stream, offset, size, filePath, fileName));
}
if (SerializedFile.IsSerializedFile(stream, offset, size))
{
return(SerializedFile.ReadScheme(stream, offset, size, filePath, fileName));
}
return(ResourceFile.ReadScheme(stream, offset, size, filePath, fileName));
}
internal void AddSerializedFile(SerializedFile file)
{
#if DEBUG
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 (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));
}
#endif
if (!RTTIClassHierarchyDescriptor.IsReadSignature(file.Header.Generation))
{
SetVersion(file);
}
m_files.Add(file);
if (SerializedFileIsScene(file))
{
m_scenes.Add(file);
}
}
public void AddSerializedFile(SerializedFile file, SerializedFileScheme scheme)
{
m_files.Add(file, scheme);
}
public void AddSerializedFile(SerializedFile file)
{
m_serializedFiles.Add(file);
OnSerializedFileAdded(file);
}
protected virtual void OnSerializedFileAdded(SerializedFile file)
{
}
