public static Animation Load(IArchiveFile animationFile)
{
string label = Path.GetFileNameWithoutExtension(animationFile.Name);
List <Pose> posesByFrame = Persistance.Load <List <Pose> >(animationFile);
return(new Animation(label, posesByFrame));
}
public void FillList(IArchiveFile file)
{
archiveFile = file;
UpdateFiles();
treeViewCustom1.BeginUpdate();
treeViewCustom1.Nodes.Clear();
if (Files.Count > 0)
{
var lookup = Files.OrderBy(f => f.FileName.TrimStart('/', '\\')).ToLookup(f => System.IO.Path.GetDirectoryName(f.FileName.TrimStart('/', '\\')));
// Build directory tree
var root = treeViewCustom1.Nodes.Add("root", ((IFileFormat)file).FileName, "tree-archive-file", "tree-archive-file");
foreach (var dir in lookup.Select(g => g.Key))
{
dir.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries)
.Aggregate(root, (node, part) => node.Nodes[part] ?? node.Nodes.Add(part, part))
.Tag = lookup[dir];
}
root.Expand();
treeViewCustom1.SelectedNode = root;
}
treeViewCustom1.EndUpdate();
}
public void LoadFile(ObjectView parent, ArchiveFileInfo archiveFileInfo, IArchiveFile archiveFile)
{
ParentObjectView = parent;
ArchiveFileInfo = archiveFileInfo;
ArchiveFile = archiveFile;
UpdateEditor();
}
public void CopyVfsSubtree(IArchiveFile subTree, string baseDirectory, bool excludeRootNode)
{
if (subTree == null)
{
return;
}
if (FileSystem.Current.DirectoryExists(baseDirectory))
{
if (excludeRootNode)
{
foreach (var file in subTree.Children.Values)
{
bool cancel = CopyVfsSubtreeRecursive(file, baseDirectory);
if (cancel)
{
break;
}
}
}
else
{
CopyVfsSubtreeRecursive(subTree, baseDirectory);
}
}
else
{
throw new Exception("base directory does not exist");
}
}
//Create a combination of all the archive files in multiple archives
//All files in this list are supported formats
public List <ArchiveFileInfo> OpenFileFormats(IArchiveFile ArchiveFile)
{
var Files = new List <ArchiveFileInfo>();
foreach (var file in ArchiveFile.Files)
{
if (file.FileFormat == null)
{
file.FileFormat = file.OpenFile();
if (file.FileFormat != null)
{
if (file.FileFormat is IArchiveFile)
{
return(OpenFileFormats((IArchiveFile)file.FileFormat));
}
else
{
Files.Add(file);
}
}
}
else
{
Files.Add(file);
}
}
return(Files);
}
public ArchiveFileWrapper(string text, ArchiveFileInfo archiveFileInfo, IArchiveFile archiveFile) : base(archiveFile)
{
Text = text;
ReloadMenus(archiveFile);
ArchiveFileInfo = archiveFileInfo;
if (archiveFileInfo.FileData != null)
{
string Extension = FindMatch(archiveFileInfo.FileData);
switch (Extension)
{
case ".bntx": SetImageKey("bntx"); break;
case ".byaml": SetImageKey("byaml"); break;
case ".aamp": SetImageKey("aamp"); break;
case ".bfres": SetImageKey("bfres"); break;
case ".sbfres": SetImageKey("sbfres"); break;
default: SetImageKey("fileBlank"); break;
}
}
}
public void LoadArchive(IArchiveFile archiveFile, string fileName)
{
TreeNode currentNode = new TreeNode();
TreeNode root = new TreeNode(fileName);
treeView1.Nodes.Add(root);
foreach (var file in archiveFile.Files)
{
currentNode = null;
string nodeString = file.FileName;
var roots = nodeString.Split(new char[] { '/' },
StringSplitOptions.RemoveEmptyEntries);
var parentNode = root;
var sb = new System.Text.StringBuilder(fileName, nodeString.Length + fileName.Length);
for (int rootIndex = 0; rootIndex < roots.Length; rootIndex++)
{
// Build the node name
var parentName = roots[rootIndex];
sb.Append("/");
sb.Append(parentName);
var nodeName = sb.ToString();
// Search for the node
var index = parentNode.Nodes.IndexOfKey(nodeName);
if (index == -1)
{
var folder = new TreeNode(parentName)
{
Name = nodeName, Checked = true,
};
if (rootIndex == roots.Length - 1)
{
var fileNode = new TreeNode(parentName)
{
Name = nodeName, Checked = true,
};
parentNode.Nodes.Add(fileNode);
parentNode = fileNode;
}
else
{
parentNode.Nodes.Add(folder);
parentNode = folder;
}
}
else
{
parentNode = parentNode.Nodes[index];
}
}
}
root.ExpandAll();
}
public ArchiveHiearchy(IArchiveFile archiveFile, ObjectTreeNode node)
{
if (node.Tag is ArchiveFileInfo)
{
ArchiveFileInfo = (ArchiveFileInfo)node.Tag;
}
ArchiveFile = archiveFile;
ReferenceNode = node;
Label = node.Label;
Tag = node.Tag;
ImageKey = node.ImageKey;
if (node.ChildCount > 0)
{
ImageKey = "Folder";
Children.Add(new ObjectTreeNode("dummy"));
}
if (ArchiveFileInfo != null)
{
foreach (var loader in FileManager.GetFileIconLoaders())
{
string key = loader.Identify(Label, ArchiveFileInfo.FileData);
if (key != string.Empty)
{
ImageKey = key;
}
}
}
}
public void AddArchive(IArchiveFile archive)
{
if (!PartArchives.ContainsKey(((IFileFormat)archive).FileName))
{
PartArchives.Add(((IFileFormat)archive).FileName, archive);
}
}
public IOccluder Load(IArchiveDirectory occlusionDirectory)
{
bool isMainFigure = channelSystem.Parent == null;
if (isMainFigure)
{
IArchiveFile occluderParametersFile = occlusionDirectory.File("occluder-parameters.dat");
if (occluderParametersFile == null)
{
throw new InvalidOperationException("expected main figure to have occlusion system");
}
var occluderParameters = Persistance.Load <OccluderParameters>(occluderParametersFile);
OcclusionInfo[] unmorphedOcclusionInfos = OcclusionInfo.UnpackArray(unmorphedOcclusionDirectory.File("occlusion-infos.array").ReadArray <uint>());
var occluder = new DeformableOccluder(device, shaderCache, channelSystem, unmorphedOcclusionInfos, occluderParameters);
return(occluder);
}
else
{
OcclusionInfo[] figureOcclusionInfos = OcclusionInfo.UnpackArray(occlusionDirectory.File("occlusion-infos.array").ReadArray <uint>());
OcclusionInfo[] parentOcclusionInfos = OcclusionInfo.UnpackArray(occlusionDirectory.File("parent-occlusion-infos.array").ReadArray <uint>());
var occluder = new StaticOccluder(device, figureOcclusionInfos, parentOcclusionInfos);
return(occluder);
}
}
public Entry(TextureCache loader, IArchiveFile key, ShaderResourceView resource)
{
this.loader = loader;
this.key = key;
this.resource = resource;
referenceCount = 0;
}
public static void AddFiles(TreeNode parentNode, IArchiveFile archiveFile, string[] Files)
{
if (Files == null || Files.Length <= 0 || !archiveFile.CanAddFiles)
{
return;
}
for (int i = 0; i < Files.Length; i++)
{
var File = ArchiveFileWrapper.FromPath(Files[i], archiveFile);
string FileName = Path.GetFileName(Files[i]);
//Don't add the root file name
if (parentNode.FullPath != string.Empty || !(parentNode is ArchiveRootNodeWrapper))
{
File.ArchiveFileInfo.FileName = Path.Combine(parentNode.FullPath, FileName);
}
else
{
File.ArchiveFileInfo.FileName = FileName;
}
bool HasAddedFile = archiveFile.AddFile(File.ArchiveFileInfo);
if (HasAddedFile)
{
parentNode.Nodes.Add(File);
}
}
}
//when loaded from an install package
public Game(IArchiveFile gameFile)
: base(gameFile)
{
if (ErrorCollection.Count == 0)
{
LoadImageFromArchive(gameFile);
}
}
public ArchiveFolderNodeWrapper(string text, IArchiveFile archiveFile) : base(archiveFile)
{
Text = text;
PropertyDisplay = new GenericFolderProperties();
((GenericFolderProperties)PropertyDisplay).Name = Text;
ReloadMenus(archiveFile);
}
//when loaded from an install package
public Game(IArchiveFile gameFile)
: base(gameFile)
{
if (ErrorCollection.Count == 0)
{
LoadImageFromArchive(gameFile);
}
}
public static ArchiveFileWrapper FromPath(string FilePath, IArchiveFile archiveFile)
{
var ArchiveFileInfo = new ArchiveFileInfo();
ArchiveFileInfo.FileName = FilePath;
ArchiveFileInfo.FileData = File.ReadAllBytes(FilePath);
return(new ArchiveFileWrapper(Path.GetFileName(FilePath), ArchiveFileInfo, archiveFile));
}
private static ShaderResourceView LoadTexture(Device device, IArchiveFile file)
{
using (var dataView = file.OpenDataView()) {
DdsLoader.CreateDDSTextureFromMemory(device, dataView.DataPointer, out Resource texture, out ShaderResourceView view);
texture.Dispose();
return(view);
}
}
private ShaderResourceView Load(IArchiveFile file)
{
using (var dataView = file.OpenDataView()) {
DdsLoader.CreateDDSTextureFromMemory(device, dataView.DataPointer, out var texture, out var textureView);
texture.Dispose();
return(textureView);
}
}
private Entry AddEntry(IArchiveFile key)
{
//Console.WriteLine($"loading {key.Name}");
ShaderResourceView resource = Load(key);
var entry = new Entry(this, key, resource);
dict.Add(key, entry);
return(entry);
}
public void CopyVfsFile(IArchiveFile vfsFile, string filename)
{
if (vfsFile == null)
{
return;
}
CopyVfsFileInternal(vfsFile, filename);
}
/// <summary>
/// Removes the current file.
/// </summary>
/// <param name="file">File to remove.</param>
public static bool Remove(this IArchiveFile file)
{
if (file.Parent is IArchiveDirectory directory)
{
return(directory.RemoveFile(file.Name));
}
return(false);
}
public Archive(ZipFile file, IArchiveFile parent, string name)
{
Parent = parent;
Name = name;
IsFolder = true;
_file = file;
Children = new Dictionary <string, IArchiveFile>();
}
/// <summary>
/// Deletes an existing file inside this directory.
/// </summary>
public void DeleteFile(IArchiveFile file)
{
var found = this.directory.Files.Find(e => e.Name == file.Name);
if (found != null)
{
this.directory.Files.Remove(found);
}
}
public Task(Main aOwner, ArchiveItem aItem, FileInfo aFile, Guid aFormat, ThreadIOPriority aPriority)
{
file = new ArchiveFile(aFile, aFormat, aPriority);
item = aItem;
owner = aOwner;
file.ExtractFile += OnExtractFile;
file.ExtractProgress += OnExtractProgress;
file.PasswordAttempt += OnPasswordAttempt;
}
internal ProjectResourceImporter(ProjectExplorer projectExplorer, ProjectDirectory directory, IArchiveFile archiveEntry, string projectKey)
{
ProjectExplorer = projectExplorer;
Directory = directory;
ArchiveEntry = archiveEntry;
ProjectKey = projectKey;
ImporterTags = new HashSet <string>();
Dependencies = new ProjectResourceImporterDependencyCollection(this);
}
public Archive(ZipFile file, IArchiveFile parent, string name, ZipEntry entry)
{
Parent = parent;
Name = name;
IsFolder = false;
_entry = entry;
_file = file;
Children = new Dictionary <string, IArchiveFile>();
}
public static SubTreeData GetSubTreeData(IArchiveFile vfsSubtree)
{
var result = new SubTreeData();
if (vfsSubtree != null)
{
GetSubTreeDataRecursive(vfsSubtree, result);
}
return(result);
}
public SharedTexture Get(IArchiveFile file)
{
lock (this) {
if (!dict.TryGetValue(file, out var cacheEntry))
{
cacheEntry = AddEntry(file);
}
return(new SharedTexture(cacheEntry));
}
}
/// <summary>
/// Should we exclude this entry?
/// </summary>
private bool ExcludeEntry(Project project, IArchiveFile entry)
{
if (entry.FullPath.EndsWith(".project") &&
!entry.FullPath.EndsWith($"{project.Name}/.project"))
{
return(true);
}
return(false);
}
public static SubTreeData GetSubTreeData(IArchiveFile vfsSubtree)
{
var result = new SubTreeData();
if (vfsSubtree != null)
{
GetSubTreeDataRecursive(vfsSubtree, result);
}
return result;
}
private static void WriteJsonDocument(IArchiveFile entry, object value)
{
using var zipStream = entry.OpenWrite();
using var sr = new StreamWriter(zipStream);
using var writer = new JsonTextWriter(sr);
var serializer = new JsonSerializer();
serializer.Serialize(writer, value);
}
static NodeBase CreateObjectHiearchy(NodeBase parent, IArchiveFile archiveFile)
{
// build a TreeNode collection from the file list
foreach (var file in archiveFile.Files)
{
string[] paths = file.FileName.Split('/');
ProcessTree(parent, file, paths, 0);
}
return(parent);
}
public MockArchiveFile(IArchiveFile parent,string name)
{
Parent = parent;
Name = name;
IsFolder = true;
Children = new Dictionary<string, IArchiveFile>();
if (parent!=null)
{
parent.Children.Add(name.ToLowerInvariant(), this);
}
}
/// <summary>
/// Returns the file's contents, with any applicable
/// transformations applied.
/// </summary>
public byte[] GetFileContents(
Project project,
ClassroomMembership student,
IArchiveFile entry)
{
if (entry.FullPath.EndsWith(".project"))
{
var newContents = entry.GetEncodedData().Replace
(
$"<name>{project.Name}</name>",
$"<name>{project.Name}_{student.GitHubTeam}</name>"
);
using (var memoryStream = new MemoryStream())
using (var streamWriter = new StreamWriter(memoryStream))
{
streamWriter.Write(newContents);
streamWriter.Flush();
return memoryStream.ToArray();
}
}
else if (entry.FullPath.EndsWith(".classpath"))
{
var jUnitPath = "org.eclipse.jdt.junit.JUNIT_CONTAINER/4";
using (var stream = new MemoryStream(entry.GetRawData()))
{
var projectNode = XElement.Load(stream);
var hasJUnit = projectNode
.Elements(XName.Get("classpathentry"))
.Any
(
elt => elt.Attribute(XName.Get("path")) != null
&& elt.Attribute(XName.Get("path")).Value == jUnitPath
);
if (!hasJUnit)
projectNode.Add(XElement.Parse($"<classpathentry kind=\"con\" path=\"{jUnitPath}\"/>"));
using (var newStream = new MemoryStream())
{
projectNode.Save(newStream);
newStream.Flush();
return newStream.ToArray();
}
}
}
else
{
return entry.GetRawData();
}
}
private static void GetSubTreeDataRecursive(IArchiveFile vfsSubtree, SubTreeData data)
{
if (vfsSubtree.IsFolder) {
foreach (var file in vfsSubtree.Children.Values) {
GetSubTreeDataRecursive(file, data);
}
}
else {
data.FileCount++;
data.BytesCount += vfsSubtree.Size;
}
}
public MockArchiveFile(IArchiveFile parent,string name,string data)
{
Parent = parent;
Name = name;
IsFolder = false;
_data = data;
Children= new Dictionary<string, IArchiveFile>();
Size = data.Length;
if (parent != null)
{
parent.Children.Add(name.ToLowerInvariant(), this);
}
}
public Update(Game upgadeTarget, IArchiveFile updateFile)
: base(updateFile)
{
_updateTarget = upgadeTarget;
if (UpdateMinVersion >= upgadeTarget.Version || UpdateMaxVersion >= upgadeTarget.Version)
{
ErrorCollection.Add("UpdateMinVersion and UpdateMaxVersion must be less than the upgraded game version");
}
else if (UpdateMinVersion > UpdateMaxVersion)
{
ErrorCollection.Add("UpdateMinVersion must be less than or equal to UpdateMaxVersion");
}
}
protected JsonEntity(IArchiveFile file)
{
try
{
using (var stream = file.OpenStream())
{
using (var reader = new StreamReader(stream))
{
var json = JObject.Parse(reader.ReadToEnd());
DoLoad(json);
}
}
}
catch (Exception ex)
{
_errorCollection.Add("Unable to load data from " + file.Name + " - " + ex);
Logger.Current.Write(ex, "Unable to load data from " + file.Name);
}
}
public void CopyVfsSubtree(IArchiveFile subTree, string baseDirectory, bool excludeRootNode)
{
if (subTree == null) return;
if (FileSystem.Current.DirectoryExists(baseDirectory)) {
if (excludeRootNode) {
foreach (var file in subTree.Children.Values)
{
bool cancel = CopyVfsSubtreeRecursive(file,baseDirectory);
if (cancel) break;
}
}
else
{
CopyVfsSubtreeRecursive(subTree, baseDirectory);
}
}
else {
throw new Exception("base directory does not exist");
}
}
/// <summary>
/// Exports a file.
/// </summary>
public void Export(IArchiveFile file, string fileName)
{
if (file is IArchiveBinaryFile)
{
var binFile = (IArchiveBinaryFile)file;
// export
var ms = new MemoryStream();
file.Export(ms);
ms.Position = 0;
var buf = new byte[ms.Length];
ms.Position = 0;
ms.Read(buf, 0, buf.Length);
// decrypt...
if (binFile.IsEncrypted)
{
var qq = GTA5Hash.CalculateHash(binFile.Name);
var gg = (qq + (uint)binFile.UncompressedSize + (101 - 40)) % 0x65;
// TODO: if archive encrypted with AES, use AES key...
buf = GTA5Crypto.Decrypt(buf, GTA5Constants.PC_NG_KEYS[gg]);
}
// decompress...
if (binFile.IsCompressed)
{
var def = new DeflateStream(new MemoryStream(buf), CompressionMode.Decompress);
var bufnew = new byte[binFile.UncompressedSize];
def.Read(bufnew, 0, (int)binFile.UncompressedSize);
buf = bufnew;
}
File.WriteAllBytes(fileName, buf);
}
else
{
file.Export(fileName);
}
}
public ResourceFileViewModel(IArchiveFile file)
{
this.file = file;
}
private bool CopyVfsFileInternal(IArchiveFile vfsFile, string filename)
{
CopyProgressEventArgs args = new CopyProgressEventArgs
{
CurrentFileSize = vfsFile.Size,
CurrentFile = vfsFile.Name,
BytesCopied = 0,
TotalBytesCopied = 0
};
using (Stream inStream = vfsFile.OpenStream())
{
using (Stream outStream = FileSystem.Current.GetFile(filename).OpenStreamWithTimeout(FileMode.Create,FileAccess.Write,FileShare.None))
{
long bytesRemaining = vfsFile.Size;
byte[] buffer = new byte[BUFFER_SIZE];
while (bytesRemaining > 0)
{
int bytesRead = (int)(bytesRemaining < BUFFER_SIZE ? bytesRemaining : BUFFER_SIZE);
inStream.Read(buffer, 0, bytesRead);
outStream.Write(buffer, 0, bytesRead);
bytesRemaining -= bytesRead;
args.TotalBytesCopied += bytesRead;
args.BytesCopied += bytesRead;
if (OnCopyProgress != null && (args.BytesCopied % PROGRESS_INCREMENT_SIZE == 0))
{
OnCopyProgress(this, args);
args.BytesCopied = 0;
if (args.Cancel)
{
Cancel();
return true;
}
}
}
}
}
if (OnCopyProgress != null)
{
OnCopyProgress(this, args);
}
return false;
}
public static FileType DetermineType(IArchiveFile file)
{
return file is RageArchiveBinaryFileWrapper7 ? FileType.Binary : FileType.Resource;
}
public void CopyVfsFile(IArchiveFile vfsFile, string filename)
{
if (vfsFile == null) return;
CopyVfsFileInternal(vfsFile, filename);
}
private bool CopyVfsSubtreeRecursive(IArchiveFile vfsSubtree, string baseDirectory)
{
if (vfsSubtree.IsFolder)
{
var directory = FileSystem.Current.GetDirectory(baseDirectory + "/" + vfsSubtree.Name);
directory.Create();
foreach (var file in vfsSubtree.Children.Values)
{
bool cancel = CopyVfsSubtreeRecursive(file, baseDirectory + "/" + vfsSubtree.Name);
if (cancel) return true;
}
}
else
{
string filename = baseDirectory + "/" + vfsSubtree.Name;
return CopyVfsFileInternal(vfsSubtree, filename);
}
return false;
}
//when loaded from an install package
public FrameworkDependancies(IArchiveFile depsFile)
: base(depsFile)
{
}
public BinaryFileViewModel(IArchiveFile file)
{
this.file = (IArchiveBinaryFile)file;
}
public Archive(ZipFile file, IArchiveFile parent, string name, ZipEntry entry)
{
Parent = parent;
Name = name;
IsFolder = false;
_entry = entry;
_file = file;
Children = new Dictionary<string, IArchiveFile>();
}
public Archive(ZipFile file, IArchiveFile parent, string name)
{
Parent = parent;
Name = name;
IsFolder = true;
_file = file;
Children = new Dictionary<string, IArchiveFile>();
}
/// <summary>
/// Should we exclude this entry?
/// </summary>
private bool ExcludeEntry(Project project, IArchiveFile entry)
{
if (entry.FullPath.EndsWith(".project")
&& !entry.FullPath.EndsWith($"{project.Name}/.project"))
{
return true;
}
return false;
}
private void LoadImageFromArchive(IArchiveFile GameFile)
{
if (GameFile.Parent.Children.ContainsKey(Resources.GameIcon))
{
try
{
IArchiveFile file = GameFile.Parent.Children[Resources.GameIcon];
using (var stream = file.OpenStream())
{
_gameIconData =new byte[stream.Length];
stream.Read(_gameIconData,0, (int)stream.Length);
}
}
catch (Exception)
{
_gameIconData = null;
}
}
}
/// <summary>
/// Deletes an existing file inside this directory.
/// </summary>
public void DeleteFile(IArchiveFile file)
{
var rf = file as RageArchiveResourceFileWrapper7;
if (rf != null)
{
this.directory.Files.Remove(rf.file);
return;
}
var bf = file as RageArchiveBinaryFileWrapper7;
if (bf != null)
{
this.directory.Files.Remove(bf.file);
return;
}
throw new NotImplementedException();
}
/// <summary>
/// Deletes an existing file inside this directory.
/// </summary>
public void DeleteFile(IArchiveFile file)
{
throw new NotImplementedException();
}
private static IArchiveFile CreateDirectories(ZipFile file, IArchiveFile root,string[] components,int length)
{
IArchiveFile parent = root;
for (int i = 0; i < length; ++i)
{
if (!parent.Children.ContainsKey(components[i].ToLowerInvariant()))
{
var child = new Archive(file,parent, components[i]);
parent.Children.Add(child.Name.ToLowerInvariant(), child);
parent = child;
}
else
{
parent = parent.Children[components[i].ToLowerInvariant()];
}
}
return parent;
}
public Task(Main aOwner, ArchiveItem aItem, FileInfo aFile, Guid aFormat, ThreadIOPriority aPriority)
{
file = new ArchiveFile(aFile, aFormat, aPriority);
item = aItem;
owner = aOwner;
file.ExtractFile += OnExtractFile;
file.ExtractProgress += OnExtractProgress;
file.PasswordAttempt += OnPasswordAttempt;
}
