FilesExpand file tree

 main

/

Program.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

228 lines (189 loc) · 8.19 KB

 main

/

Program.cs

Copy path

Top

File metadata and controls

• Code
• Blame

228 lines (189 loc) · 8.19 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

using System;

using System.CommandLine;

using System.IO;

using UnityDataTools.Analyzer;

using UnityDataTools.Analyzer.SQLite.Handlers;

using UnityDataTools.ReferenceFinder;

using UnityDataTools.TextDumper;

using UnityDataTools.FileSystem;

namespace UnityDataTools.UnityDataTool;

public static class Program

{

public static int Main(string[] args)

{

UnityFileSystem.Init();

var rootCommand = new RootCommand();

{

var pathArg = new Argument<DirectoryInfo>("path", "The path to the directory containing the files to analyze").ExistingOnly();

var oOpt = new Option<string>(aliases: new[] { "--output-file", "-o" }, description: "Filename of the output database", getDefaultValue: () => "database.db");

var rOpt = new Option<bool>(aliases: new[] { "--extract-references", "-r" }, description: "Extract all object references and add them in the 'refs' table");

var pOpt = new Option<string>(aliases: new[] { "--search-pattern", "-p" }, description: "File search pattern", getDefaultValue: () => "*");

var analyzeCommand = new Command("analyze", "Analyze AssetBundles or SerializedFiles.")

{

pathArg,

oOpt,

rOpt,

pOpt,

};

analyzeCommand.AddAlias("analyse");

analyzeCommand.SetHandler(

(DirectoryInfo di, string o, bool r, string p) => HandleAnalyze(di, o, r, p),

pathArg, oOpt, rOpt, pOpt);

rootCommand.AddCommand(analyzeCommand);

}

{

var pathArg = new Argument<FileInfo>("databasePath", "The path to the database generated by the 'analyze' command using --extract-references").ExistingOnly();

var oOpt = new Option<string>(aliases: new[] { "--output-file", "-o" }, description: "Output file", getDefaultValue: () => "references.txt");

var iOpt = new Option<long?>(aliases: new[] { "--object-id", "-i" }, description: "Object id ('id' column in the database)");

var nOpt = new Option<string>(aliases: new[] { "--object-name", "-n" }, description: "Object name");

var tOpt = new Option<string>(aliases: new[] { "--object-type", "-t" }, description: "Optional object type when searching by name");

var aOpt = new Option<bool>(aliases: new[] { "--find-all", "-a" }, description: "Find all reference chains originating from the same asset (instead of only one), can be very slow");

var findRefsCommand = new Command("find-refs", "Find reference chains to specified object(s).")

{

pathArg,

oOpt,

aOpt,

nOpt,

tOpt,

iOpt,

};

findRefsCommand.SetHandler(

(FileInfo fi, string o, long? i, string n, string t, bool a) => HandleFindReferences(fi, o, i, n, t, a),

pathArg, oOpt, iOpt, nOpt, tOpt, aOpt);

rootCommand.Add(findRefsCommand);

}

{

var pathArg = new Argument<FileInfo>("filename", "The path of the file to dump").ExistingOnly();

var fOpt = new Option<DumpFormat>(aliases: new[] { "--output-format", "-f" }, description: "Output format", getDefaultValue: () => DumpFormat.Text);

var sOpt = new Option<bool>(aliases: new[] { "--skip-large-arrays", "-s" }, description: "Do not dump large arrays of basic data types");

var oOpt = new Option<DirectoryInfo>(aliases: new[] { "--output-path", "-o"}, description: "Output folder", getDefaultValue: () => new DirectoryInfo(Environment.CurrentDirectory));

var dumpCommand = new Command("dump", "Dump the content of an AssetBundle or SerializedFile.")

{

pathArg,

fOpt,

sOpt,

oOpt,

};

dumpCommand.SetHandler(

(FileInfo fi, DumpFormat f, bool s, DirectoryInfo o) => HandleDump(fi, f, s, o),

pathArg, fOpt, sOpt, oOpt);

rootCommand.AddCommand(dumpCommand);

}

{

var pathArg = new Argument<FileInfo>("filename", "The path of the archive file").ExistingOnly();

var extractArchiveCommand = new Command("extract", "Extract the archive.")

{

pathArg,

};

extractArchiveCommand.SetHandler(

(FileInfo fi) => HandleExtractArchive(fi),

pathArg);

var listArchiveCommand = new Command("list", "List the content of an archive.")

{

pathArg,

};

listArchiveCommand.SetHandler(

(FileInfo fi) => HandleListArchive(fi),

pathArg);

var archiveCommand = new Command("archive", "Unity Archive (AssetBundle) functions.")

{

extractArchiveCommand,

listArchiveCommand,

};

rootCommand.AddCommand(archiveCommand);

}

var r = rootCommand.Invoke(args);

UnityFileSystem.Cleanup();

return r;

}

enum DumpFormat

{

Text,

}

static int HandleAnalyze(DirectoryInfo path, string outputFile, bool extractReferences, string searchPattern)

{

var analyzer = new AnalyzerTool();

return analyzer.Analyze(path.FullName, outputFile, searchPattern, extractReferences);

}

static int HandleFindReferences(FileInfo databasePath, string outputFile, long? objectId, string objectName, string objectType, bool findAll)

{

var finder = new ReferenceFinderTool();

if ((objectId != null && objectName != null) || (objectId == null && objectName == null))

{

Console.Error.WriteLine("A value must be provided for either --object-id or --object-name.");

return 1;

}

if (objectId != null)

{

return finder.FindReferences(objectId.Value, databasePath.FullName, outputFile, findAll);

}

else

{

return finder.FindReferences(objectName, objectType, databasePath.FullName, outputFile, findAll);

}

}

static int HandleDump(FileInfo filename, DumpFormat format, bool skipLargeArrays, DirectoryInfo outputFolder)

{

switch (format)

{

case DumpFormat.Text:

{

var textDumper = new TextDumperTool();

return textDumper.Dump(filename.FullName, outputFolder.FullName, skipLargeArrays);

}

}

return 1;

}

static int HandleExtractArchive(FileInfo filename)

{

try

{

using var archive = UnityFileSystem.MountArchive(filename.FullName, "/");

foreach (var node in archive.Nodes)

{

Console.WriteLine($"Extracting {node.Path}...");

CopyFile("/" + node.Path, Path.GetFileName(node.Path));

}

}

catch (NotSupportedException)

{

Console.Error.WriteLine("Error opening archive!");

return 1;

}

return 0;

}

static int HandleListArchive(FileInfo filename)

{

try

{

using var archive = UnityFileSystem.MountArchive(filename.FullName, "/");

foreach (var node in archive.Nodes)

{

Console.WriteLine($"{node.Path}");

Console.WriteLine($" Size: {node.Size}");

Console.WriteLine($" Flags: {node.Flags}");

Console.WriteLine();

}

}

catch (NotSupportedException)

{

Console.Error.WriteLine("Error opening archive!");

return 1;

}

return 0;

}

static void CopyFile(string source, string dest)

{

using var sourceFile = UnityFileSystem.OpenFile(source);

using var destFile = new FileStream(dest, FileMode.Create);

const int blockSize = 256 * 1024;

var buffer = new byte[blockSize];

long actualSize;

do

{

actualSize = sourceFile.Read(blockSize, buffer);

destFile.Write(buffer, 0, (int)actualSize);

}

while (actualSize == blockSize);

}

}