|
public static getArrayType ( |
||
| p | ||
| return | ArrayType | |
/// <summary>
/// Gets the type of an array
/// </summary>
/// <param name="game">What game we are looking info for</param>
/// <param name="propName">Name of the array property</param>
/// <param name="className">Name of the class that should contain the information. If contained in a struct, this will be the name of the struct type</param>
/// <param name="parsingEntry">Entry that is being parsed. Used for dynamic lookup if it's not in the DB</param>
/// <returns></returns>
public static ArrayType GetArrayType(Mod.MEGame game, string propName, string className, IEntry parsingEntry = null)
{
switch (game)
{
case Mod.MEGame.ME1:
return(ME1UnrealObjectInfo.getArrayType(className, propName, export: parsingEntry as ExportEntry));
case Mod.MEGame.ME2:
var res2 = ME2UnrealObjectInfo.getArrayType(className, propName, export: parsingEntry as ExportEntry);
#if DEBUG
//For debugging only!
if (res2 == ArrayType.Int && ME2UnrealObjectInfo.ArrayTypeLookupJustFailed)
{
ME2UnrealObjectInfo.ArrayTypeLookupJustFailed = false;
Debug.WriteLine("[ME2] Array type lookup failed for " + propName + " in class " + className + " in export " + parsingEntry.FileRef.GetEntryString(parsingEntry.UIndex));
}
#endif
return(res2);
case Mod.MEGame.ME3:
var res = ME3UnrealObjectInfo.getArrayType(className, propName, export: parsingEntry as ExportEntry);
#if DEBUG
//For debugging only!
if (res == ArrayType.Int && ME3UnrealObjectInfo.ArrayTypeLookupJustFailed)
{
Debug.WriteLine("[ME3] Array type lookup failed for " + propName + " in class " + className + " in export " + parsingEntry.FileRef.GetEntryString(parsingEntry.UIndex));
ME3UnrealObjectInfo.ArrayTypeLookupJustFailed = false;
}
#endif
return(res);
}
return(ArrayType.Int);
}
public static ArrayType GetArrayType(MEGame game, string propName, string typeName)
{
switch (game)
{
case MEGame.ME1:
return(ME1UnrealObjectInfo.getArrayType(typeName, propName));
case MEGame.ME2:
return(ME2UnrealObjectInfo.getArrayType(typeName, propName));
case MEGame.ME3:
return(ME3UnrealObjectInfo.getArrayType(typeName, propName));
}
return(ArrayType.Int);
}
public static void ImportProperty(IMEPackage pcc, IMEPackage importpcc, Property p, string className, MemoryStream m, bool inStruct = false)
{
string name = importpcc.getNameEntry(p.Name);
int idxname = pcc.FindNameOrAdd(name);
m.Write(BitConverter.GetBytes(idxname), 0, 4);
m.Write(new byte[4], 0, 4);
if (name == "None")
{
return;
}
string type = importpcc.getNameEntry(BitConverter.ToInt32(p.raw, 8));
int idxtype = pcc.FindNameOrAdd(type);
m.Write(BitConverter.GetBytes(idxtype), 0, 4);
m.Write(new byte[4], 0, 4);
string name2;
int idxname2;
int size, count, pos;
List <Property> Props;
switch (type)
{
case "IntProperty":
case "FloatProperty":
case "ObjectProperty":
case "StringRefProperty":
m.Write(BitConverter.GetBytes(4), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(p.Value.IntValue), 0, 4);
break;
case "NameProperty":
m.Write(BitConverter.GetBytes(8), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(pcc.FindNameOrAdd(importpcc.getNameEntry(p.Value.IntValue))), 0, 4);
//preserve index or whatever the second part of a namereference is
m.Write(p.raw, 28, 4);
break;
case "BoolProperty":
m.Write(new byte[8], 0, 8);
m.WriteByte((byte)p.Value.IntValue);
if (pcc.Game != MEGame.ME3)
{
m.Write(new byte[3], 0, 3);
}
break;
case "BioMask4Property":
m.Write(BitConverter.GetBytes(p.Size), 0, 4);
m.Write(new byte[4], 0, 4);
m.WriteByte((byte)p.Value.IntValue);
break;
case "ByteProperty":
m.Write(BitConverter.GetBytes(p.Size), 0, 4);
m.Write(new byte[4], 0, 4);
if (pcc.Game == MEGame.ME3)
{
name2 = importpcc.getNameEntry(BitConverter.ToInt32(p.raw, 24));
idxname2 = pcc.FindNameOrAdd(name2);
m.Write(BitConverter.GetBytes(idxname2), 0, 4);
m.Write(new byte[4], 0, 4);
}
if (p.Size != 1)
{
m.Write(BitConverter.GetBytes(pcc.FindNameOrAdd(importpcc.getNameEntry(p.Value.IntValue))), 0, 4);
m.Write(new byte[4], 0, 4);
}
else
{
m.WriteByte(Convert.ToByte(p.Value.IntValue));
}
break;
case "DelegateProperty":
size = BitConverter.ToInt32(p.raw, 16);
if (size == 0xC)
{
name2 = importpcc.getNameEntry(BitConverter.ToInt32(p.raw, 28));
idxname2 = pcc.FindNameOrAdd(name2);
m.Write(BitConverter.GetBytes(0xC), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(idxname2), 0, 4);
m.Write(new byte[4], 0, 4);
}
else
{
m.Write(BitConverter.GetBytes(size), 0, 4);
m.Write(new byte[4], 0, 4);
for (int i = 0; i < size; i++)
{
m.WriteByte(p.raw[24 + i]);
}
}
break;
case "StrProperty":
name2 = p.Value.StringValue;
if (p.Value.StringValue.Length > 0)
{
name2 += '\0';
}
if (p.Value.len < 0)
{
//unicode
m.Write(BitConverter.GetBytes(4 + name2.Length * 2), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(-name2.Length), 0, 4);
foreach (char c in name2)
{
m.WriteByte((byte)c);
m.WriteByte(0);
}
}
else
{
//ascii
m.Write(BitConverter.GetBytes(4 + name2.Length), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(name2.Length), 0, 4);
foreach (char c in name2)
{
m.WriteByte((byte)c);
}
}
break;
case "StructProperty":
size = BitConverter.ToInt32(p.raw, 16);
name2 = importpcc.getNameEntry(BitConverter.ToInt32(p.raw, 24));
idxname2 = pcc.FindNameOrAdd(name2);
pos = 32;
Props = new List <Property>();
try
{
Props = ReadProp(importpcc, p.raw, pos);
}
catch (Exception)
{
}
m.Write(BitConverter.GetBytes(size), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(idxname2), 0, 4);
m.Write(new byte[4], 0, 4);
if (Props.Count == 0 || Props[0].TypeVal == PropertyType.Unknown)
{
for (int i = 0; i < size; i++)
{
m.WriteByte(p.raw[32 + i]);
}
}
else
{
foreach (Property pp in Props)
{
ImportProperty(pcc, importpcc, pp, className, m, inStruct);
}
}
break;
case "ArrayProperty":
size = BitConverter.ToInt32(p.raw, 16);
count = BitConverter.ToInt32(p.raw, 24);
PropertyInfo info = ME3UnrealObjectInfo.getPropertyInfo(className, name, inStruct);
ArrayType arrayType = ME3UnrealObjectInfo.getArrayType(info);
pos = 28;
List <Property> AllProps = new List <Property>();
if (arrayType == ArrayType.Struct)
{
for (int i = 0; i < count; i++)
{
Props = new List <Property>();
try
{
Props = ReadProp(importpcc, p.raw, pos);
}
catch (Exception)
{
}
AllProps.AddRange(Props);
if (Props.Count != 0)
{
pos = Props[Props.Count - 1].offend;
}
}
}
m.Write(BitConverter.GetBytes(size), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(count), 0, 4);
if (AllProps.Count != 0 && (info == null || !UnrealObjectInfo.isImmutable(info.reference, pcc.Game)))
{
foreach (Property pp in AllProps)
{
ImportProperty(pcc, importpcc, pp, className, m, inStruct);
}
}
else if (arrayType == ArrayType.Name)
{
for (int i = 0; i < count; i++)
{
string s = importpcc.getNameEntry(BitConverter.ToInt32(p.raw, 28 + i * 8));
m.Write(BitConverter.GetBytes(pcc.FindNameOrAdd(s)), 0, 4);
//preserve index or whatever the second part of a namereference is
m.Write(p.raw, 32 + i * 8, 4);
}
}
else
{
m.Write(p.raw, 28, size - 4);
}
break;
default:
throw new Exception(type);
}
}
