/// <summary>
/// Validates this MergeFile. Throws an exception if the validation fails.
/// </summary>
public void Validate()
{
if (FileName == null)
{
throw new Exception(M3L.GetString(M3L.string_filenameCannotBeNullInAMergeManifestFile !));
}
var safeFiles = EntryImporter.FilesSafeToImportFrom(OwningMM.Game).ToList();
safeFiles.Add(@"EntryMenu.pcc"); // ME2+
safeFiles.Add(@"EntryMenu.SFM"); // ME1
if (!safeFiles.Any(x => FileName.StartsWith(Path.GetFileNameWithoutExtension(x), StringComparison.InvariantCultureIgnoreCase)))
{
// Does this catch DLC startups?
throw new Exception(M3L.GetString(M3L.string_interp_targetingNonStartupFile, FileName));
}
foreach (var mc in MergeChanges)
{
mc.Validate();
}
}
public static void ScanStuff(PackageEditorWPF pewpf)
{
//var filePaths = MELoadedFiles.GetOfficialFiles(MEGame.ME3);//.Concat(MELoadedFiles.GetOfficialFiles(MEGame.ME2));//.Concat(MELoadedFiles.GetOfficialFiles(MEGame.ME1));
//var filePaths = MELoadedFiles.GetAllFiles(game);
/*"Core.pcc", "Engine.pcc", "GameFramework.pcc", "GFxUI.pcc", "WwiseAudio.pcc", "SFXOnlineFoundation.pcc", "SFXGame.pcc" */
var filePaths = new[] { "Core.pcc", "Engine.pcc", "GameFramework.pcc", "GFxUI.pcc", "WwiseAudio.pcc", "SFXOnlineFoundation.pcc" }.Select(f => Path.Combine(ME3Directory.CookedPCPath, f));
var interestingExports = new List <EntryStringPair>();
var foundClasses = new HashSet <string>(); //new HashSet<string>(BinaryInterpreterWPF.ParsableBinaryClasses);
var foundProps = new Dictionary <string, string>();
var unkOpcodes = new List <int>();//Enumerable.Range(0x5B, 8).ToList();
unkOpcodes.Add(0);
unkOpcodes.Add(1);
var unkOpcodesInfo = unkOpcodes.ToDictionary(i => i, i => new OpcodeInfo());
var comparisonDict = new Dictionary <string, (byte[] original, byte[] newData)>();
var extraInfo = new HashSet <string>();
pewpf.IsBusy = true;
pewpf.BusyText = "Scanning";
Task.Run(() =>
{
//preload base files for faster scanning
using var baseFiles = MEPackageHandler.OpenMEPackages(EntryImporter.FilesSafeToImportFrom(MEGame.ME3)
.Select(f => Path.Combine(ME3Directory.CookedPCPath, f)));
baseFiles.Add(
MEPackageHandler.OpenMEPackage(Path.Combine(ME3Directory.CookedPCPath, "BIOP_MP_COMMON.pcc")));
foreach (string filePath in filePaths)
{
//ScanShaderCache(filePath);
//ScanMaterials(filePath);
//ScanStaticMeshComponents(filePath);
//ScanLightComponents(filePath);
//ScanLevel(filePath);
//if (findClass(filePath, "ShaderCache", true)) break;
//findClassesWithBinary(filePath);
ScanScripts2(filePath);
//if (interestingExports.Count > 0)
//{
// break;
//}
//if (resolveImports(filePath)) break;
}
}).ContinueWithOnUIThread(prevTask =>
{
pewpf.IsBusy = false;
interestingExports.Add(new EntryStringPair(null, string.Join("\n", extraInfo)));
var listDlg = new ListDialog(interestingExports, "Interesting Exports", "", pewpf)
{
DoubleClickEntryHandler = entryItem =>
{
if (entryItem?.Entry is IEntry entryToSelect)
{
PackageEditorWPF p = new PackageEditorWPF();
p.Show();
p.LoadFile(entryToSelect.FileRef.FilePath, entryToSelect.UIndex);
p.Activate();
if (comparisonDict.TryGetValue($"{entryToSelect.UIndex} {entryToSelect.FileRef.FilePath}", out (byte[] original, byte[] newData)val))
{
File.WriteAllBytes(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "original.bin"), val.original);
File.WriteAllBytes(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "new.bin"), val.newData);
}
}
}
};
listDlg.Show();
});
#region extra scanning functions
bool findClass(string filePath, string className, bool withBinary = false)
{
Debug.WriteLine($" {filePath}");
using (IMEPackage pcc = MEPackageHandler.OpenMEPackage(filePath))
{
//if (!pcc.IsCompressed) return false;
var exports = pcc.Exports.Where(exp => !exp.IsDefaultObject && exp.IsA(className));
foreach (ExportEntry exp in exports)
{
try
{
//Debug.WriteLine($"{exp.UIndex}: {filePath}");
var originalData = exp.Data;
exp.WriteBinary(ObjectBinary.From(exp));
var newData = exp.Data;
if (!originalData.SequenceEqual(newData))
{
interestingExports.Add(exp);
File.WriteAllBytes(
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"original.bin"), originalData);
File.WriteAllBytes(
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"new.bin"), newData);
return(true);
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
interestingExports.Add(new EntryStringPair(exp, $"{exception}"));
return(true);
}
}
}
return(false);
}
void findClassesWithBinary(string filePath)
{
using (IMEPackage pcc = MEPackageHandler.OpenMEPackage(filePath))
{
foreach (ExportEntry exp in pcc.Exports.Where(exp => !exp.IsDefaultObject))
{
try
{
if (!foundClasses.Contains(exp.ClassName) && exp.propsEnd() < exp.DataSize)
{
if (ObjectBinary.From(exp) != null)
{
foundClasses.Add(exp.ClassName);
}
else if (exp.GetBinaryData().Any(b => b != 0))
{
foundClasses.Add(exp.ClassName);
interestingExports.Add(exp);
}
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
interestingExports.Add(new EntryStringPair(exp, $"{exp.UIndex}: {filePath}\n{exception}"));
}
}
}
}
void ScanShaderCache(string filePath)
{
using (IMEPackage pcc = MEPackageHandler.OpenMEPackage(filePath))
{
ExportEntry shaderCache = pcc.Exports.FirstOrDefault(exp => exp.ClassName == "ShaderCache");
if (shaderCache == null)
{
return;
}
int oldDataOffset = shaderCache.DataOffset;
try
{
MemoryStream binData = new MemoryStream(shaderCache.Data);
binData.JumpTo(shaderCache.propsEnd() + 1);
int nameList1Count = binData.ReadInt32();
binData.Skip(nameList1Count * 12);
int namelist2Count = binData.ReadInt32(); //namelist2
binData.Skip(namelist2Count * 12);
int shaderCount = binData.ReadInt32();
for (int i = 0; i < shaderCount; i++)
{
binData.Skip(24);
int nextShaderOffset = binData.ReadInt32() - oldDataOffset;
binData.Skip(14);
if (binData.ReadInt32() != 1111577667) //CTAB
{
interestingExports.Add(new EntryStringPair(null,
$"{binData.Position - 4}: {filePath}"));
return;
}
binData.JumpTo(nextShaderOffset);
}
int vertexFactoryMapCount = binData.ReadInt32();
binData.Skip(vertexFactoryMapCount * 12);
int materialShaderMapCount = binData.ReadInt32();
for (int i = 0; i < materialShaderMapCount; i++)
{
binData.Skip(16);
int switchParamCount = binData.ReadInt32();
binData.Skip(switchParamCount * 32);
int componentMaskParamCount = binData.ReadInt32();
//if (componentMaskParamCount != 0)
//{
// interestingExports.Add($"{i}: {filePath}");
// return;
//}
binData.Skip(componentMaskParamCount * 44);
int normalParams = binData.ReadInt32();
if (normalParams != 0)
{
interestingExports.Add(new EntryStringPair(null, $"{i}: {filePath}"));
return;
}
binData.Skip(normalParams * 29);
int unrealVersion = binData.ReadInt32();
int licenseeVersion = binData.ReadInt32();
if (unrealVersion != 684 || licenseeVersion != 194)
{
interestingExports.Add(new EntryStringPair(null,
$"{binData.Position - 8}: {filePath}"));
return;
}
int nextMaterialShaderMapOffset = binData.ReadInt32() - oldDataOffset;
binData.JumpTo(nextMaterialShaderMapOffset);
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
interestingExports.Add(new EntryStringPair(null, $"{filePath}\n{exception}"));
}
}
}
void ScanScripts(string filePath)
{
using IMEPackage pcc = MEPackageHandler.OpenMEPackage(filePath);
foreach (ExportEntry exp in pcc.Exports.Where(exp => !exp.IsDefaultObject))
{
try
{
if ((exp.ClassName == "State" || exp.ClassName == "Function") &&
ObjectBinary.From(exp) is UStruct uStruct)
{
byte[] data = exp.Data;
(_, List <BytecodeSingularToken> tokens) = Bytecode.ParseBytecode(uStruct.ScriptBytes, exp);
foreach (var token in tokens)
{
if (token.CurrentStack.Contains("UNKNOWN") || token.OpCodeString.Contains("UNKNOWN"))
{
interestingExports.Add(exp);
}
if (unkOpcodes.Contains(token.OpCode))
{
int refUIndex = EndianReader.ToInt32(data, token.StartPos + 1, pcc.Endian);
IEntry entry = pcc.GetEntry(refUIndex);
if (entry != null && (entry.ClassName == "ByteProperty"))
{
var info = unkOpcodesInfo[token.OpCode];
info.Usages.Add(pcc.FilePath, exp.UIndex, token.StartPos);
info.PropTypes.Add(refUIndex switch
{
0 => "Null",
_ when entry != null => entry.ClassName,
_ => "Invalid"
});
if (entry != null)
{
if (entry.Parent == exp)
{
info.PropLocations.Add("Local");
}
else if (entry.Parent == (exp.Parent.ClassName == "State" ? exp.Parent.Parent : exp.Parent))
{
info.PropLocations.Add("ThisClass");
}
else if (entry.Parent.ClassName == "Function")
{
info.PropLocations.Add("OtherFunction");
}
else if (exp.Parent.IsA(entry.Parent.ObjectName))
{
info.PropLocations.Add("AncestorClass");
}
else
{
info.PropLocations.Add("OtherClass");
}
}
}
}
}
