public StaticMeshCollectionActor(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
case "bCanStepUpOn":
if (p.raw[p.raw.Length - 1] == 1)
bCanStepUpOn = true;
break;
case "Tag":
Tag = p.Value.IntValue;
break;
case "CreationTime":
CreationTime = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
}
ReadObjects();
ReadMatrices();
}
public SkeletalMesh(ME3Package pcc, int Index)
{
Loaded = true;
MyIndex = Index;
Owner = pcc;
Flags = (int)(pcc.Exports[Index].ObjectFlags >> 32);
int start = GetPropertyEnd();
byte[] data = pcc.Exports[Index].Data;
byte[] buff = new byte[data.Length - start];
for (int i = 0; i < data.Length - start; i++)
{
buff[i] = data[i + start];
}
MemoryStream m = new MemoryStream(buff);
SerializingContainer Container = new SerializingContainer(m);
Container.isLoading = true;
Serialize(Container);
try
{
for (int i = 0; i < Materials.Count; i++)
{
MatInsts.Add(new MaterialInstanceConstant(Owner, Materials[i] - 1));
}
}
catch
{
}
GenerateDXMeshes();
}
public UDKCopy(ME3Package _pcc, int obj, int lod)
{
pcc = _pcc;
SelectedObject = obj;
SelectedLOD = lod;
InitializeComponent();
}
public BioPlaypenVolumeAdditive(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
case "Tag":
Tag = p.Value.IntValue;
break;
case "Brush":
Brush = p.Value.IntValue;
break;
case "BrushComponent":
BrushComponent = p.Value.IntValue;
if (pcc.isExport(BrushComponent - 1) && pcc.Exports[BrushComponent - 1].ClassName == "BrushComponent")
brush = new BrushComponent(pcc, BrushComponent - 1);
break;
case "CollisionComponent":
CollisionComponent = p.Value.IntValue;
break;
case "location":
location.X = BitConverter.ToSingle(p.raw, p.raw.Length - 12);
location.Y = BitConverter.ToSingle(p.raw, p.raw.Length - 8);
location.Z = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
}
MyMatrix = Matrix.Translation(location);
}
/// <summary>
/// Queues a texture for eventual loading.
/// </summary>
/// <param name="pcc">The full path of the pcc where the texture export is.</param>
public PreviewTextureEntry LoadTexture(string pcc, int exportid)
{
foreach (PreviewTextureEntry e in cache)
{
if (e.PCCPath == pcc && e.ExportID == exportid)
{
return(e);
}
}
using (ME3Package texpcc = MEPackageHandler.OpenME3Package(pcc))
{
PreviewTextureEntry entry = new PreviewTextureEntry(pcc, exportid);
Unreal.Classes.Texture2D metex = new Unreal.Classes.Texture2D(texpcc, exportid);
Texture2DDescription desc = new Texture2DDescription();
try
{
entry.Texture = metex.generatePreviewTexture(Device, out desc);
entry.TextureView = new ShaderResourceView(Device, entry.Texture);
cache.Add(entry);
return(entry);
} catch
{
return(null);
}
}
}
public UDKCopy(ME3Package _pcc, int obj, int lod)
{
pcc = _pcc;
SelectedObject = obj;
SelectedLOD = lod;
InitializeComponent();
}
public AnimSet(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
{
data = pcc.Exports[Index].Data;
}
Props = PropertyReader.getPropList(pcc.Exports[Index]);
Sequences = new List <int>();
foreach (PropertyReader.Property p in Props)
{
switch (pcc.getNameEntry(p.Name))
{
case "PreviewSkelMeshName":
PreviewSkelMeshName = p.Value.IntValue;
break;
case "m_pBioAnimSetData":
m_pBioAnimSetData = p.Value.IntValue;
if (pcc.isExport(m_pBioAnimSetData - 1) && pcc.Exports[m_pBioAnimSetData - 1].ClassName == "BioAnimSetData")
{
SetData = new BioAnimSetData(pcc, m_pBioAnimSetData - 1);
}
break;
case "Sequences":
ReadSequences(p.raw);
break;
}
}
}
public WwiseStream(ME3Package pcc, int index)
{
Index = index;
memory = pcc.Exports[Index].Data;
memsize = memory.Length;
Deserialize(pcc);
}
public void AddLevel(ME3Package pcc)
{
try
{
Levelfile l = new Levelfile();
l.path = pcc.FileName;
l.pcc = pcc;
IReadOnlyList <IExportEntry> Exports = l.pcc.Exports;
for (int i = 0; i < Exports.Count; i++)
{
IExportEntry e = Exports[i];
if (e.ClassName == "Level")
{
DebugOutput.Clear();
l.level = new Level(l.pcc, i);
TreeNode t = new TreeNode(Path.GetFileName(pcc.FileName));
t.Nodes.Add(l.level.ToTree(i));
GlobalTree.Visible = false;
GlobalTree.Nodes.Add(t);
GlobalTree.Visible = true;
//DirectXGlobal.Cam.dir = new Vector3(1.0f, 1.0f, 1.0f);
Levels.Add(l);
}
}
}
catch (Exception ex)
{
MessageBox.Show("Error:\n" + ex.Message);
}
}
private static ClassInfo generateClassInfo(int index, ME3Package pcc)
{
ClassInfo info = new ClassInfo();
info.baseClass = pcc.Exports[index].ClassParent;
info.exportIndex = index;
info.pccPath = new string(pcc.FileName.Skip(pcc.FileName.LastIndexOf("BIOGame") + 8).ToArray());
foreach (ME3ExportEntry entry in pcc.Exports)
{
if (entry.idxLink - 1 == index && entry.ClassName != "ScriptStruct" && entry.ClassName != "Enum" &&
entry.ClassName != "Function" && entry.ClassName != "Const" && entry.ClassName != "State")
{
//Skip if property is transient (only used during execution, will never be in game files)
if ((BitConverter.ToUInt64(entry.Data, 24) & 0x0000000000002000) == 0 && !info.properties.ContainsKey(entry.ObjectName))
{
PropertyInfo p = getProperty(pcc, entry);
if (p != null)
{
info.properties.Add(entry.ObjectName, p);
}
}
}
}
return(info);
}
public BioAnimSetData(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
TrackBoneNames = new List<string>();
UseTranslationBoneNames = new List<string>();
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
case "bAnimRotationOnly":
if (p.raw[p.raw.Length - 1] == 1)
bAnimRotationOnly = true;
break;
case "TrackBoneNames":
ReadTBN(p.raw);
break;
case "UseTranslationBoneNames":
ReadUTBN(p.raw);
break;
}
}
public string ToString(ME3Package p)
{
if (val == -1)
return enumName + ", " + values[0];
else
return p.getNameEntry(type) + ", " + p.getNameEntry(val);
}
public WwiseStream(ME3Package pcc, int index)
{
Index = index;
memory = pcc.Exports[Index].Data;
memsize = memory.Length;
Deserialize(pcc);
}
public AnimNodeSlot(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
Children = new List<ChildrenEntry>();
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
case "bSkipTickWhenZeroWeight":
if (p.raw[p.raw.Length - 1] == 1)
bSkipTickWhenZeroWeight = true;
break;
case "NodeName":
NodeName = p.Value.IntValue;
break;
case "NodeTotalWeight":
NodeTotalWeight = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
case "Children":
ReadChildren(p.raw);
break;
}
}
public StaticMeshCollectionActor(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
{
data = pcc.Exports[Index].Data;
}
Props = PropertyReader.getPropList(pcc.Exports[Index]);
foreach (PropertyReader.Property p in Props)
{
switch (pcc.getNameEntry(p.Name))
{
case "bCanStepUpOn":
if (p.raw[p.raw.Length - 1] == 1)
{
bCanStepUpOn = true;
}
break;
case "Tag":
Tag = p.Value.IntValue;
break;
case "CreationTime":
CreationTime = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
}
}
ReadObjects();
ReadMatrices();
}
public string DumpArray(ME3Package pcc, byte[] raw, int pos, int depth)
{
string res = "";
List<PropertyReader.Property> p = PropertyReader.ReadProp(pcc, raw, pos);
for (int i = 0; i < p.Count; i++)
{
if (p[i].TypeVal == PropertyType.StringRefProperty)
{
for (int j = 0; j < depth; j++)
res += "\t";
res += i + " : " + PropertyReader.PropertyToText(p[i], pcc) + "\n";
}
if (p[i].TypeVal == PropertyType.ArrayProperty)
{
//for (int j = 0; j < depth; j++)
// res += "\t";
//res += "in Property #" + i + " : " + PropertyReader.PropertyToText(p[i], pcc) + "\n";
res += DumpArray(pcc, raw, p[i].offsetval + 4, depth + 1);
}
if (p[i].TypeVal == PropertyType.StructProperty)
{
//for (int j = 0; j < depth; j++)
// res += "\t";
//res += "in Property #" + i + " : " + PropertyReader.PropertyToText(p[i], pcc) + "\n";
res += DumpArray(pcc, raw, p[i].offsetval + 8, depth + 1);
}
}
return res;
}
public AnimTree(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
AnimGroups = new List<AnimGroupEntry>();
ComposePrePassBoneNames = new List<string>();
SkelControlLists = new List<SkelControlListEntry>();
Children = new List<ChildrenEntry>();
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
case "NodeTotalWeight":
NodeTotalWeight = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
case "AnimGroups":
ReadAnimGroups(p.raw);
break;
case "ComposePrePassBoneNames":
ReadPrePassBoneNames(p.raw);
break;
case "SkelControlLists":
ReadSkelControlLists(p.raw);
break;
case "Children":
ReadChildren(p.raw);
break;
}
}
public WwiseAmbientSound(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
case "bAutoPlay":
if (p.raw[p.raw.Length - 1] == 1)
bAutoPlay = true;
break;
case "Tag":
Tag = p.Value.IntValue;
break;
case "UniqueTag":
UniqueTag = p.Value.IntValue;
break;
case "location":
location = new Vector3(BitConverter.ToSingle(p.raw, p.raw.Length - 12),
BitConverter.ToSingle(p.raw, p.raw.Length - 8),
BitConverter.ToSingle(p.raw, p.raw.Length - 4));
break;
}
MyMatrix = Matrix.Translation(location);
GenerateMesh();
}
public AnimSet(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
Sequences = new List<int>();
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
case "PreviewSkelMeshName":
PreviewSkelMeshName = p.Value.IntValue;
break;
case "m_pBioAnimSetData":
m_pBioAnimSetData = p.Value.IntValue;
if (pcc.isExport(m_pBioAnimSetData - 1) && pcc.Exports[m_pBioAnimSetData - 1].ClassName == "BioAnimSetData")
SetData = new BioAnimSetData(pcc, m_pBioAnimSetData - 1);
break;
case "Sequences":
ReadSequences(p.raw);
break;
}
}
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
int n = listBox1.SelectedIndex;
if (n == -1)
{
return;
}
DBEntry l = database[n];
if (File.Exists(l.filepath))
{
try
{
using (ME3Package pcc = MEPackageHandler.OpenME3Package(l.filepath))
{
Level lev = new Level(pcc, l.index, true);
string s = "";
s += "Loading Level from : " + Path.GetFileName(l.filepath) + "\n";
s += "Object count : " + lev.Objects.Count + "\n==============\n\n";
for (int i = 0; i < lev.Objects.Count(); i++)
{
int index = lev.Objects[i];
s += "(" + i + "/" + (lev.Objects.Count() - 1) + ") ";
s += "#" + index + " : \"" + pcc.Exports[index].ObjectName + "\" Class : \"" + pcc.Exports[index].ClassName + "\"\n";
}
rtb1.Text = s;
}
}
catch (Exception ex)
{
MessageBox.Show("Error:\n" + ex.Message);
}
}
}
public InterpGroup(int idx, ME3Package pccobj)
: base()
{
index = idx;
pcc = pccobj;
title = new SText("");
if (pcc.Exports[index].ClassName == "InterpGroupDirector")
{
GroupName = "DirGroup";
}
listEntry = PPath.CreateRectangle(0, 0, Timeline.ListWidth, Timeline.TrackHeight);
listEntry.Brush = GroupBrush;
listEntry.Pen = null;
PPath p = PPath.CreatePolygon(7, 5, 12, 10, 7, 15);
p.Brush = Brushes.Black;
listEntry.AddChild(p);
listEntry.AddChild(PPath.CreateLine(0, listEntry.Bounds.Bottom, Timeline.ListWidth, listEntry.Bounds.Bottom));
colorAccent = new PNode();
colorAccent.Brush = null;
colorAccent.Bounds = new RectangleF(Timeline.ListWidth - 10, 0, 10, listEntry.Bounds.Bottom);
listEntry.AddChild(colorAccent);
title.TranslateBy(20, 3);
listEntry.AddChild(title);
listEntry.MouseDown += listEntry_MouseDown;
collapsed = true;
InterpTracks = new List <InterpTrack>();
LoadData();
if (bIsParented)
{
listEntry.TranslateBy(10, 0);
}
}
public BioAnimSetData(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
{
data = pcc.Exports[Index].Data;
}
Props = PropertyReader.getPropList(pcc.Exports[Index]);
TrackBoneNames = new List <string>();
UseTranslationBoneNames = new List <string>();
foreach (PropertyReader.Property p in Props)
{
switch (pcc.getNameEntry(p.Name))
{
case "bAnimRotationOnly":
if (p.raw[p.raw.Length - 1] == 1)
{
bAnimRotationOnly = true;
}
break;
case "TrackBoneNames":
ReadTBN(p.raw);
break;
case "UseTranslationBoneNames":
ReadUTBN(p.raw);
break;
}
}
}
public string DumpArray(ME3Package pcc, byte[] raw, int pos, int depth)
{
string res = "";
List <PropertyReader.Property> p = PropertyReader.ReadProp(pcc, raw, pos);
for (int i = 0; i < p.Count; i++)
{
if (p[i].TypeVal == PropertyType.StringRefProperty)
{
for (int j = 0; j < depth; j++)
{
res += "\t";
}
res += i + " : " + PropertyReader.PropertyToText(p[i], pcc) + "\n";
}
if (p[i].TypeVal == PropertyType.ArrayProperty)
{
//for (int j = 0; j < depth; j++)
// res += "\t";
//res += "in Property #" + i + " : " + PropertyReader.PropertyToText(p[i], pcc) + "\n";
res += DumpArray(pcc, raw, p[i].offsetval + 4, depth + 1);
}
if (p[i].TypeVal == PropertyType.StructProperty)
{
//for (int j = 0; j < depth; j++)
// res += "\t";
//res += "in Property #" + i + " : " + PropertyReader.PropertyToText(p[i], pcc) + "\n";
res += DumpArray(pcc, raw, p[i].offsetval + 8, depth + 1);
}
}
return(res);
}
public MantleMarker(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
#region
case "bHasCrossLevelPaths":
if (p.raw[p.raw.Length - 1] == 1)
bHasCrossLevelPaths = true;
break;
case "Tag":
Tag = p.Value.IntValue;
break;
case "nextNavigationPoint":
nextNavigationPoint = p.Value.IntValue;
break;
case "CylinderComponent":
CylinderComponent = p.Value.IntValue;
break;
case "Owner":
Owner = p.Value.IntValue;
break;
case "Base":
Base = p.Value.IntValue;
break;
case "CollisionComponent":
CollisionComponent = p.Value.IntValue;
break;
case "CreationTime":
CreationTime = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
case "visitedWeight":
visitedWeight = p.Value.IntValue;
break;
case "bestPathWeight":
bestPathWeight = p.Value.IntValue;
break;
case "NetworkID":
NetworkID = p.Value.IntValue;
break;
case "ApproximateLineOfFire":
ApproximateLineOfFire = p.Value.IntValue;
break;
case "location":
location = new Vector3(BitConverter.ToSingle(p.raw, p.raw.Length - 12),
BitConverter.ToSingle(p.raw, p.raw.Length - 8),
BitConverter.ToSingle(p.raw, p.raw.Length - 4));
break;
#endregion
}
MyMatrix = Matrix.Translation(location);
GenerateMesh();
}
public WwiseBank(ME3Package Pcc, int Index)
{
MyIndex = Index;
pcc = Pcc;
memory = pcc.Exports[Index].Data;
memsize = memory.Length;
Deserialize();
}
public MaterialInstanceConstant(ME3Package Pcc, int Idx)
{
pcc = Pcc;
index = Idx;
memory = pcc.Exports[index].Data;
memsize = memory.Length;
ReadProperties();
}
public Level(ME3Package Pcc, int index, bool SimpleRead = false)
{
memory = Pcc.Exports[index].Data;
memlength = memory.Length;
pcc = Pcc;
Index = index;
Deserialize(SimpleRead);
}
public Level(ME3Package Pcc, int index, bool SimpleRead = false)
{
memory = Pcc.Exports[index].Data;
memlength = memory.Length;
pcc = Pcc;
Index = index;
Deserialize(SimpleRead);
}
public TreeNode ToTree(int MyIndex, ME3Package pcc)
{
string s = "";
if (Text.Length != 0)
{
s = Text.Substring(0, Text.Length - 1);
}
TreeNode res = new TreeNode(MyIndex + " : " + s + " " + ME3TalkFiles.findDataById(refText));
TreeNode t = new TreeNode("Reply List");
for (int i = 0; i < ReplyList.Count; i++)
{
EntryListReplyListStruct e = ReplyList[i];
string par = e.Paraphrase;
if (par.Length != 0 && par[par.Length - 1] == '\0')
{
par = par.Substring(0, par.Length - 1);
}
t.Nodes.Add(i + " : "
+ par
+ " "
+ e.refParaphrase
+ " "
+ ME3TalkFiles.findDataById(e.refParaphrase)
+ " "
+ e.Index
+ " "
+ pcc.getNameEntry(e.CategoryValue));
}
res.Nodes.Add(t);
TreeNode t2 = new TreeNode("Speaker List");
for (int i = 0; i < SpeakerList.Count; i++)
{
t2.Nodes.Add(i + " : " + SpeakerList[i]);
}
res.Nodes.Add(t2);
res.Nodes.Add("SpeakerIndex : " + SpeakerIndex);
res.Nodes.Add("ListenerIndex : " + ListenerIndex);
res.Nodes.Add("ConditionalFunc : " + ConditionalFunc);
res.Nodes.Add("ConditionalParam : " + ConditionalParam);
res.Nodes.Add("StateTransition : " + StateTransition);
res.Nodes.Add("StateTransitionParam : " + StateTransitionParam);
res.Nodes.Add("ExportID : " + ExportID);
res.Nodes.Add("ScriptIndex : " + ScriptIndex);
res.Nodes.Add("CameraIntimacy : " + CameraIntimacy);
res.Nodes.Add("Skippable : " + Skippable);
res.Nodes.Add("FireConditional : " + FireConditional);
res.Nodes.Add("Ambient : " + Ambient);
res.Nodes.Add("NonTextline : " + NonTextline);
res.Nodes.Add("IgnoreBodyGestures : " + IgnoreBodyGestures);
res.Nodes.Add("AlwaysHideSubtitle : " + AlwaysHideSubtitle);
res.Nodes.Add("Text : " + Text);
res.Nodes.Add("refText : " + refText + " " + ME3TalkFiles.findDataById(refText, true));
res.Nodes.Add("GUIStyle : (" + pcc.getNameEntry(GUIStyleType) + ") " + pcc.getNameEntry(GUIStyleValue));
return(res);
}
public Function(byte[] raw, ME3Package Pcc)
{
pcc = Pcc;
memory = raw;
memsize = raw.Length;
flagint = GetFlagInt();
nativeindex = GetNatIdx();
Deserialize();
}
public WwiseBank(ME3Package Pcc, int Index)
{
MyIndex = Index;
pcc = Pcc;
memory = pcc.Exports[Index].Data;
memsize = memory.Length;
Deserialize();
}
public Function(byte[] raw, ME3Package Pcc)
{
pcc = Pcc;
memory = raw;
memsize = raw.Length;
flagint = GetFlagInt();
nativeindex = GetNatIdx();
Deserialize();
}
public MaterialInstanceConstant(ME3Package Pcc,int Idx)
{
pcc = Pcc;
index = Idx;
memory = pcc.Exports[index].Data;
memsize = memory.Length;
ReadProperties();
}
public LightVolume(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
{
data = pcc.Exports[Index].Data;
}
Props = PropertyReader.getPropList(pcc.Exports[Index]);
foreach (PropertyReader.Property p in Props)
{
switch (pcc.getNameEntry(p.Name))
{
#region
case "bColored":
if (p.raw[p.raw.Length - 1] == 1)
{
bColored = true;
}
break;
case "Tag":
Tag = p.Value.IntValue;
break;
case "Brush":
Brush = p.Value.IntValue;
break;
case "BrushComponent":
BrushComponent = p.Value.IntValue;
if (pcc.isExport(BrushComponent - 1) && pcc.Exports[BrushComponent - 1].ClassName == "BrushComponent")
{
brush = new BrushComponent(pcc, BrushComponent - 1);
}
break;
case "CollisionComponent":
CollisionComponent = p.Value.IntValue;
break;
case "CreationTime":
CreationTime = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
case "location":
location = new Vector3(BitConverter.ToSingle(p.raw, p.raw.Length - 12),
BitConverter.ToSingle(p.raw, p.raw.Length - 8),
BitConverter.ToSingle(p.raw, p.raw.Length - 4));
break;
#endregion
}
}
MyMatrix = Matrix.Translation(location);
}
public TreeNode ToTree(int index, ME3Package pcc)
{
TreeNode root = new TreeNode(index + ": " + fTime);
root.Nodes.Add("pObject : " + pObject);
root.Nodes.Add("nKeyIndex : " + nKeyIndex);
root.Nodes.Add("fTime : " + fTime);
root.Nodes.Add("bPreloadFired : " + bPreloadFired);
return(root);
}
public SFXSceneGroup(int idx, ME3Package pccobj)
: base(idx, pccobj)
{
LoadData();
listEntry[0].RotateInPlace(90);
listEntry[0].TranslateBy(5, 5);
collapsed = false;
//hack to undo the triangle rotation
listEntry.MouseDown += listEntry_MouseDown;
}
public static PropertyCollection getDefaultStructValue(string className)
{
if (Structs.ContainsKey(className))
{
bool immutable = isImmutable(className);
ClassInfo info = Structs[className];
try
{
string filepath = (Path.Combine(ME3Directory.gamePath, @"BIOGame\" + info.pccPath));
if (File.Exists(info.pccPath))
{
filepath = info.pccPath; //Used for dynamic lookup
}
using (ME3Package importPCC = MEPackageHandler.OpenME3Package(filepath))
{
byte[] buff;
//Plane and CoverReference inherit from other structs, meaning they don't have default values (who knows why)
//thus, I have hardcoded what those default values should be
if (className == "Plane")
{
buff = PlaneDefault;
}
else if (className == "CoverReference")
{
buff = CoverReferenceDefault;
}
else
{
buff = importPCC.Exports[info.exportIndex].Data.Skip(0x24).ToArray();
}
PropertyCollection props = PropertyCollection.ReadProps(importPCC, new MemoryStream(buff), className);
List <UProperty> toRemove = new List <UProperty>();
foreach (var prop in props)
{
//remove transient props
if (!info.properties.ContainsKey(prop.Name) && info.baseClass == "Class")
{
toRemove.Add(prop);
}
}
foreach (var prop in toRemove)
{
props.Remove(prop);
}
return(props);
}
}
catch
{
return(null);
}
}
return(null);
}
//call this method to regenerate ME3ObjectInfo.json
//Takes a long time (~5 minutes maybe?). Application will be completely unresponsive during that time.
public static void generateInfo()
{
string path = ME3Directory.gamePath;
string[] files = Directory.GetFiles(path, "*.pcc", SearchOption.AllDirectories);
string objectName;
int length = files.Length;
for (int i = 0; i < length; i++)
{
if (files[i].ToLower().EndsWith(".pcc"))
{
using (ME3Package pcc = MEPackageHandler.OpenME3Package(files[i]))
{
IReadOnlyList <IExportEntry> Exports = pcc.Exports;
IExportEntry exportEntry;
for (int j = 0; j < Exports.Count; j++)
{
exportEntry = Exports[j];
if (exportEntry.ClassName == "Enum")
{
generateEnumValues(j, pcc);
}
else if (exportEntry.ClassName == "Class")
{
objectName = exportEntry.ObjectName;
if (!Classes.ContainsKey(objectName))
{
Classes.Add(objectName, generateClassInfo(j, pcc));
}
if ((objectName.Contains("SeqAct") || objectName.Contains("SeqCond") || objectName.Contains("SequenceLatentAction") ||
objectName == "SequenceOp" || objectName == "SequenceAction" || objectName == "SequenceCondition") && !SequenceObjects.ContainsKey(objectName))
{
SequenceObjects.Add(objectName, generateSequenceObjectInfo(j, pcc));
}
}
else if (exportEntry.ClassName == "ScriptStruct")
{
objectName = exportEntry.ObjectName;
if (!Structs.ContainsKey(objectName))
{
Structs.Add(objectName, generateClassInfo(j, pcc));
}
}
}
}
}
System.Diagnostics.Debug.WriteLine($"{i} of {length} processed");
}
File.WriteAllText(Application.StartupPath + "//exec//ME3ObjectInfo.json",
JsonConvert.SerializeObject(new { SequenceObjects = SequenceObjects, Classes = Classes, Structs = Structs, Enums = Enums }));
MessageBox.Show("Done");
}
public DecalActor(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
case "bCanStepUpOn":
if (p.raw[p.raw.Length - 1] == 1)
bCanStepUpOn = true;
break;
case "Tag":
Tag = p.Value.IntValue;
break;
case "Group":
Group = p.Value.IntValue;
break;
case "Decal":
Decal = p.Value.IntValue;
break;
case "DrawScale":
DrawScale = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
case "DrawScale3D":
DrawScale3D = new Vector3(BitConverter.ToSingle(p.raw, p.raw.Length - 12),
BitConverter.ToSingle(p.raw, p.raw.Length - 8),
BitConverter.ToSingle(p.raw, p.raw.Length - 4));
break;
case "Rotation":
Rotator = new Vector3(BitConverter.ToInt32(p.raw, p.raw.Length - 12),
BitConverter.ToInt32(p.raw, p.raw.Length - 8),
BitConverter.ToInt32(p.raw, p.raw.Length - 4));
break;
case "location":
location = new Vector3(BitConverter.ToSingle(p.raw, p.raw.Length - 12),
BitConverter.ToSingle(p.raw, p.raw.Length - 8),
BitConverter.ToSingle(p.raw, p.raw.Length - 4));
break;
}
if (pcc.isExport(Decal - 1) && pcc.Exports[Decal - 1].ClassName == "DecalComponent")
DC = new DecalComponent(pcc, Decal - 1);
MyMatrix = Matrix.Identity;
MyMatrix *= Matrix.Scaling(DrawScale3D);
MyMatrix *= Matrix.Scaling(new Vector3(DrawScale, DrawScale, DrawScale));
Vector3 rot = RotatorToDX(Rotator);
MyMatrix *= Matrix.RotationYawPitchRoll(rot.X, rot.Y, rot.Z);
MyMatrix *= Matrix.Translation(location);
}
private void startScanToolStripMenuItem_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(ME3Directory.cookedPath))
{
MessageBox.Show("This functionality requires ME3 to be installed. Set its path at:\n Options > Set Custom Path > Mass Effect 3");
return;
}
string pathcook = ME3Directory.cookedPath;
DebugOutput.StartDebugger("ScriptDB");
string[] files = Directory.GetFiles(pathcook, "*.pcc");
int count = 1;
database = new List <ScriptEntry>();
foreach (string file in files)
{
DebugOutput.PrintLn(count + "\\" + files.Length + " : Scanning " + Path.GetFileName(file) + " ...");
try
{
using (ME3Package pcc = MEPackageHandler.OpenME3Package(file))
{
int count2 = 0;
foreach (IExportEntry ent in pcc.Exports)
{
if (ent.ClassName == "Function")
{
Function f = new Function(ent.Data, ent);
ScriptEntry n = new ScriptEntry();
n.file = Path.GetFileName(file);
n.name = ent.PackageFullName + "." + ent.ObjectName;
f.ParseFunction();
n.script = f.ScriptText;
database.Add(n);
DebugOutput.PrintLn("\tFound \"" + n.name + "\"", false);
}
count2++;
}
}
}
catch (Exception ex)
{
MessageBox.Show("Error:\n" + ex.Message);
DebugOutput.PrintLn("Could not open file: " + Path.GetFileName(file));
}
{
pb1.Maximum = files.Length;
pb1.Value = count;
}
count++;
}
RefreshList();
}
private static SequenceObjectInfo generateSequenceObjectInfo(int i, ME3Package pcc)
{
SequenceObjectInfo info = new SequenceObjectInfo();
var inLinks = pcc.Exports[i + 1].GetProperty <ArrayProperty <StructProperty> >("InputLinks");
if (inLinks != null)
{
foreach (var seqOpInputLink in inLinks)
{
info.inputLinks.Add(seqOpInputLink.GetProp <StrProperty>("LinkDesc").Value);
}
}
return(info);
}
public WwiseEnvironmentVolume(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
case "bHiddenEdGroup":
if (p.raw[p.raw.Length - 1] == 1)
bHiddenEdGroup = true;
break;
case "Tag":
Tag = p.Value.IntValue;
break;
case "UniqueTag":
UniqueTag = p.Value.IntValue;
break;
case "Group":
Group = p.Value.IntValue;
break;
case "Settings":
Settings = p.Value.IntValue;
break;
case "Brush":
Brush = p.Value.IntValue;
break;
case "BrushComponent":
BrushComponent = p.Value.IntValue;
if (pcc.isExport(BrushComponent - 1) && pcc.Exports[BrushComponent - 1].ClassName == "BrushComponent")
brush = new BrushComponent(pcc, BrushComponent - 1);
break;
case "CollisionComponent":
CollisionComponent = p.Value.IntValue;
break;
case "Priority":
Priority = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
case "location":
location.X = BitConverter.ToSingle(p.raw, p.raw.Length - 12);
location.Y = BitConverter.ToSingle(p.raw, p.raw.Length - 8);
location.Z = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
}
MyMatrix = Matrix.Translation(location);
}
public TreeNode ToTree(int MyIndex, ME3Package pcc)
{
string s = "";
if (Text.Length != 0)
s = Text.Substring(0, Text.Length - 1);
TreeNode res = new TreeNode(MyIndex + " : " + s + " " + ME3TalkFiles.findDataById(refText));
TreeNode t = new TreeNode("Reply List");
for (int i = 0; i < ReplyList.Count; i++)
{
EntryListReplyListStruct e = ReplyList[i];
string par = e.Paraphrase;
if (par.Length != 0 && par[par.Length - 1] == '\0')
par = par.Substring(0, par.Length - 1);
t.Nodes.Add(i + " : "
+ par
+ " "
+ e.refParaphrase
+ " "
+ ME3TalkFiles.findDataById(e.refParaphrase)
+ " "
+ e.Index
+ " "
+ pcc.getNameEntry(e.CategoryValue));
}
res.Nodes.Add(t);
TreeNode t2 = new TreeNode("Speaker List");
for (int i = 0; i < SpeakerList.Count; i++)
t2.Nodes.Add(i + " : " + SpeakerList[i]);
res.Nodes.Add(t2);
res.Nodes.Add("SpeakerIndex : " + SpeakerIndex);
res.Nodes.Add("ListenerIndex : " + ListenerIndex);
res.Nodes.Add("ConditionalFunc : " + ConditionalFunc);
res.Nodes.Add("ConditionalParam : " + ConditionalParam);
res.Nodes.Add("StateTransition : " + StateTransition);
res.Nodes.Add("StateTransitionParam : " + StateTransitionParam);
res.Nodes.Add("ExportID : " + ExportID);
res.Nodes.Add("ScriptIndex : " + ScriptIndex);
res.Nodes.Add("CameraIntimacy : " + CameraIntimacy);
res.Nodes.Add("Skippable : " + Skippable);
res.Nodes.Add("FireConditional : " + FireConditional);
res.Nodes.Add("Ambient : " + Ambient);
res.Nodes.Add("NonTextline : " + NonTextline);
res.Nodes.Add("IgnoreBodyGestures : " + IgnoreBodyGestures);
res.Nodes.Add("AlwaysHideSubtitle : " + AlwaysHideSubtitle);
res.Nodes.Add("Text : " + Text);
res.Nodes.Add("refText : " + refText + " " + ME3TalkFiles.findDataById(refText, true));
res.Nodes.Add("GUIStyle : (" + pcc.getNameEntry(GUIStyleType) + ") " + pcc.getNameEntry(GUIStyleValue));
return res;
}
public void Deserialize(ME3Package pcc)
{
props = PropertyReader.getPropList(pcc.Exports[Index]);
int off = props[props.Count - 1].offend + 8;
ValueOffset = off;
DataSize = BitConverter.ToInt32(memory, off);
DataOffset = BitConverter.ToInt32(memory, off + 4);
for (int i = 0; i < props.Count; i++)
{
if (pcc.Names[props[i].Name] == "Filename")
FileName = pcc.Names[props[i].Value.IntValue];
if (pcc.Names[props[i].Name] == "Id")
Id = props[i].Value.IntValue;
}
}
public AnimSequence(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
Unknown = BitConverter.ToInt32(data, 0);
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
case "RotationCompressionFormat":
RotationCompressionFormat = p.Value.IntValue;
break;
case "KeyEncodingFormat":
KeyEncodingFormat = p.Value.IntValue;
break;
case "bIsAdditive":
if (p.raw[p.raw.Length - 1] == 1)
bIsAdditive = true;
break;
case "bNoLoopingInterpolation":
if (p.raw[p.raw.Length - 1] == 1)
bNoLoopingInterpolation = true;
break;
case "SequenceName":
SequenceName = p.Value.IntValue;
break;
case "m_pBioAnimSetData":
m_pBioAnimSetData = p.Value.IntValue;
break;
case "SequenceLength":
SequenceLength = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
case "RateScale":
RateScale = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
case "NumFrames":
NumFrames = p.Value.IntValue;
break;
case "CompressedTrackOffsets":
ReadTrackOffsets(p.raw);
break;
}
ReadCompressedBlob();
}
private void buttonCompressPCC_Click(object sender, EventArgs e)
{
if (openPccDialog.ShowDialog() == DialogResult.OK)
{
string fileName = openPccDialog.FileName;
string backupFile = fileName + ".bak";
if (File.Exists(fileName))
{
try
{
using (ME3Package pccObj = MEPackageHandler.OpenME3Package(fileName))
{
if (!pccObj.CanReconstruct)
{
var res = MessageBox.Show("This file contains a SeekFreeShaderCache. Compressing will cause a crash when ME3 attempts to load this file.\n" +
"Do you want to visit a forum thread with more information and a possible solution?",
"I'm sorry, Dave. I'm afraid I can't do that.", MessageBoxButtons.YesNo, MessageBoxIcon.Stop);
if (res == DialogResult.Yes)
{
System.Diagnostics.Process.Start("http://me3explorer.freeforums.org/research-how-to-turn-your-dlc-pcc-into-a-vanilla-one-t2264.html");
}
return;
}
DialogResult dialogResult = MessageBox.Show("Do you want to make a backup file?", "Make Backup", MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
File.Copy(fileName, backupFile);
}
pccObj.saveByReconstructing(fileName, true);
}
MessageBox.Show("File " + Path.GetFileName(fileName) + " was successfully compressed.", "Succeed", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception exc)
{
MessageBox.Show("An error occurred while compressing " + Path.GetFileName(fileName) + ":\n" + exc.Message, "Exception Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
//recovering backup file
if (File.Exists(backupFile))
{
File.Delete(fileName);
File.Move(backupFile, fileName);
}
}
}
}
}
private void ExtractWav(string path, string name = "", bool askSave = true)
{
if (!File.Exists(path))
{
return;
}
string loc = Path.GetDirectoryName(Application.ExecutablePath) + "\\exec";
Stream fs = new FileStream(path, FileMode.Open, FileAccess.Read);
if (path.EndsWith(".pcc"))
{
using (ME3Package package = MEPackageHandler.OpenME3Package(path))
{
if (package.IsCompressed)
{
Stream result = CompressionHelper.DecompressME3(fs);
fs.Dispose();
fs = result;
}
}
}
if (DataOffset + DataSize > fs.Length)
{
return;
}
ExtractRawFromStream(fs);
ConvertRiffToWav();
SaveFileDialog d = new SaveFileDialog();
d.Filter = "Wave Files(*.wav)|*.wav";
d.FileName = name + ".wav";
if (askSave)
{
if (d.ShowDialog() == DialogResult.OK)
{
File.Copy(loc + "\\out.wav", d.FileName);
}
}
else
{
File.Copy(loc + "\\out.wav", name, true);
}
if (askSave)
{
MessageBox.Show("Done.");
}
}
public SplineActor(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
case "Physics":
Physics = p.Value.IntValue;
break;
case "bEdShouldSnap":
if (p.raw[p.raw.Length - 1] == 1)
bEdShouldSnap = true;
break;
case "bDisableDestination":
if (p.raw[p.raw.Length - 1] == 1)
bDisableDestination = true;
break;
case "Tag":
Tag = p.Value.IntValue;
break;
case "UniqueTag":
UniqueTag = p.Value.IntValue;
break;
case "Rotation":
Rotator = new Vector3(BitConverter.ToInt32(p.raw, p.raw.Length - 12),
BitConverter.ToInt32(p.raw, p.raw.Length - 8),
BitConverter.ToInt32(p.raw, p.raw.Length - 4));
break;
case "location":
location = new Vector3(BitConverter.ToSingle(p.raw, p.raw.Length - 12),
BitConverter.ToSingle(p.raw, p.raw.Length - 8),
BitConverter.ToSingle(p.raw, p.raw.Length - 4));
if(to == new Vector3())
to = location;
break;
case "Connections" :
Connections = p.raw;
break;
}
ProcessConnections();
}
private static void generateEnumValues(int index, ME3Package pcc)
{
string enumName = pcc.Exports[index].ObjectName;
if (!Enums.ContainsKey(enumName))
{
List <string> values = new List <string>();
byte[] buff = pcc.Exports[index].Data;
//subtract 1 so that we don't get the MAX value, which is an implementation detail
int count = BitConverter.ToInt32(buff, 20) - 1;
for (int i = 0; i < count; i++)
{
values.Add(pcc.Names[BitConverter.ToInt32(buff, 24 + i * 8)]);
}
Enums.Add(enumName, values);
}
}
public static Vector3 GetLocation(ME3Package Pcc, int Index)
{
Vector3 r = new Vector3();
if (!Pcc.isExport(Index))
return new Vector3();
List<PropertyReader.Property> pp = PropertyReader.getPropList(Pcc.Exports[Index]);
foreach (PropertyReader.Property p in pp)
switch (Pcc.getNameEntry(p.Name))
{
case "location":
r = new Vector3(BitConverter.ToSingle(p.raw, p.raw.Length - 12),
BitConverter.ToSingle(p.raw, p.raw.Length - 8),
BitConverter.ToSingle(p.raw, p.raw.Length - 4));
break;
}
return r;
}
private void startScanToolStripMenuItem_Click(object sender, EventArgs e)
{
string path = ME3Directory.cookedPath;
if (string.IsNullOrEmpty(path))
{
MessageBox.Show("This functionality requires ME3 to be installed. Set its path at:\n Options > Set Custom Path > Mass Effect 3");
return;
}
string[] files = Directory.GetFiles(path, "*.pcc");
filenames = new List <string>();
int count = 1;
foreach (string file in files)
{
try
{
using (ME3Package _pcc = MEPackageHandler.OpenME3Package(file))
{
DebugOutput.PrintLn((count++) + "/" + files.Length + " : Scanning file " + Path.GetFileName(file) + " ...");
bool found = false;
IReadOnlyList <IExportEntry> Exports = _pcc.Exports;
foreach (IExportEntry ex in Exports)
{
if (ex.ClassName == "AnimTree" || ex.ClassName == "AnimSet")
{
DebugOutput.PrintLn("Found Animation!");
found = true;
break;
}
}
if (found)
{
filenames.Add(file);
}
}
}
catch (Exception ex)
{
MessageBox.Show("Error:\n" + ex.Message);
DebugOutput.PrintLn("Could not open " + Path.GetFileName(file));
}
}
RefreshLists();
}
/*
* This method is called when using the -compresspcc command line argument
*/
public static int autoCompressPcc(string sourceFile, string outputFile)
{
if (!File.Exists(sourceFile))
{
MessageBox.Show("PCC to compress does not exist:\n" + sourceFile, "Auto Compression Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(1);
}
using (ME3Package pccObj = MEPackageHandler.OpenME3Package(sourceFile))
{
if (!pccObj.CanReconstruct)
{
MessageBox.Show("Cannot compress files with a SeekFreeShaderCache", "Auto Compression Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(1);
}
pccObj.saveByReconstructing(outputFile, true);
}
return(0);
}
public TextureGroup(ME3Package pccObj, byte[] data)
{
enumTextureGroups = new List<ByteProp>();
pccRef = pccObj;
MemoryStream buffer = new MemoryStream(data);
firstVal = buffer.ReadValueU32();
buffer.Seek(16, SeekOrigin.Begin);
otherVal = buffer.ReadValueU32();
int numEnums = buffer.ReadValueS32();
for (int i = 0; i < numEnums; i++)
{
ByteProp aux = new ByteProp(pccRef.Names[buffer.ReadValueS32()], buffer.ReadValueS32());
enumTextureGroups.Add(aux);
}
}
public void PlaySound()
{
if (listView1.SelectedItems.Count != 1 || pcc == null)
{
return;
}
ListViewItem item = listView1.SelectedItems[0];
int index = Convert.ToInt32(item.Name);
if (pcc.Exports[index].ClassName == "WwiseStream")
{
using (ME3Package package = MEPackageHandler.OpenME3Package(pcc.pccFileName))
{
w = new WwiseStream(package, index);
w.Play(pathCooked);
}
}
}
public LightVolume(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
#region
case "bColored":
if (p.raw[p.raw.Length - 1] == 1)
bColored = true;
break;
case "Tag":
Tag = p.Value.IntValue;
break;
case "Brush":
Brush = p.Value.IntValue;
break;
case "BrushComponent":
BrushComponent = p.Value.IntValue;
if (pcc.isExport(BrushComponent - 1) && pcc.Exports[BrushComponent - 1].ClassName == "BrushComponent")
brush = new BrushComponent(pcc, BrushComponent - 1);
break;
case "CollisionComponent":
CollisionComponent = p.Value.IntValue;
break;
case "CreationTime":
CreationTime = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
case "location":
location = new Vector3(BitConverter.ToSingle(p.raw, p.raw.Length - 12),
BitConverter.ToSingle(p.raw, p.raw.Length - 8),
BitConverter.ToSingle(p.raw, p.raw.Length - 4));
break;
#endregion
}
MyMatrix = Matrix.Translation(location);
}
private static ClassInfo generateClassInfo(int index, ME3Package pcc)
{
ClassInfo info = new ClassInfo();
info.baseClass = pcc.Exports[index].ClassParent;
info.exportIndex = index;
info.pccPath = new string(pcc.FileName.Skip(pcc.FileName.LastIndexOf("BIOGame") + 8).ToArray());
foreach (ME3ExportEntry entry in pcc.Exports)
{
if (entry.idxLink - 1 == index && entry.ClassName != "ScriptStruct" && entry.ClassName != "Enum"
&& entry.ClassName != "Function" && entry.ClassName != "Const" && entry.ClassName != "State")
{
//Skip if property is transient (only used during execution, will never be in game files)
if ((BitConverter.ToUInt64(entry.Data, 24) & 0x0000000000002000) == 0 && !info.properties.ContainsKey(entry.ObjectName))
{
PropertyInfo p = getProperty(pcc, entry);
if (p != null)
{
info.properties.Add(entry.ObjectName, p);
}
}
}
}
return info;
}
private static void generateEnumValues(int index, ME3Package pcc)
{
string enumName = pcc.Exports[index].ObjectName;
if (!Enums.ContainsKey(enumName))
{
List<string> values = new List<string>();
byte[] buff = pcc.Exports[index].Data;
//subtract 1 so that we don't get the MAX value, which is an implementation detail
int count = BitConverter.ToInt32(buff, 20) - 1;
for (int i = 0; i < count; i++)
{
values.Add(pcc.Names[BitConverter.ToInt32(buff, 24 + i * 8)]);
}
Enums.Add(enumName, values);
}
}
private static PropertyInfo getProperty(ME3Package pcc, IExportEntry entry)
{
PropertyInfo p = new PropertyInfo();
switch (entry.ClassName)
{
case "IntProperty":
p.type = PropertyType.IntProperty;
break;
case "StringRefProperty":
p.type = PropertyType.StringRefProperty;
break;
case "FloatProperty":
p.type = PropertyType.FloatProperty;
break;
case "BoolProperty":
p.type = PropertyType.BoolProperty;
break;
case "StrProperty":
p.type = PropertyType.StrProperty;
break;
case "NameProperty":
p.type = PropertyType.NameProperty;
break;
case "DelegateProperty":
p.type = PropertyType.DelegateProperty;
break;
case "ObjectProperty":
case "ClassProperty":
case "ComponentProperty":
p.type = PropertyType.ObjectProperty;
p.reference = pcc.getObjectName(BitConverter.ToInt32(entry.Data, entry.Data.Length - 4));
break;
case "StructProperty":
p.type = PropertyType.StructProperty;
p.reference = pcc.getObjectName(BitConverter.ToInt32(entry.Data, entry.Data.Length - 4));
break;
case "BioMask4Property":
case "ByteProperty":
p.type = PropertyType.ByteProperty;
p.reference = pcc.getObjectName(BitConverter.ToInt32(entry.Data, entry.Data.Length - 4));
break;
case "ArrayProperty":
p.type = PropertyType.ArrayProperty;
PropertyInfo arrayTypeProp = getProperty(pcc, pcc.Exports[BitConverter.ToInt32(entry.Data, 44) - 1]);
if (arrayTypeProp != null)
{
switch (arrayTypeProp.type)
{
case PropertyType.ObjectProperty:
case PropertyType.StructProperty:
case PropertyType.ArrayProperty:
p.reference = arrayTypeProp.reference;
break;
case PropertyType.ByteProperty:
if (arrayTypeProp.reference == "")
p.reference = arrayTypeProp.type.ToString();
else
p.reference = arrayTypeProp.reference;
break;
case PropertyType.IntProperty:
case PropertyType.FloatProperty:
case PropertyType.NameProperty:
case PropertyType.BoolProperty:
case PropertyType.StrProperty:
case PropertyType.StringRefProperty:
case PropertyType.DelegateProperty:
p.reference = arrayTypeProp.type.ToString();
break;
case PropertyType.None:
case PropertyType.Unknown:
default:
System.Diagnostics.Debugger.Break();
p = null;
break;
}
}
else
{
p = null;
}
break;
case "InterfaceProperty":
default:
p = null;
break;
}
return p;
}
public TargetPoint(ME3Package Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc.Exports[Index]);
foreach (PropertyReader.Property p in Props)
switch (pcc.getNameEntry(p.Name))
{
#region
case "Physics":
Physics = p.Value.IntValue;
break;
case "bHardAttach":
if (p.raw[p.raw.Length - 1] == 1)
bHardAttach = true;
break;
case "bShadowParented":
if (p.raw[p.raw.Length - 1] == 1)
bShadowParented = true;
break;
case "bLockLocation":
if (p.raw[p.raw.Length - 1] == 1)
bLockLocation = true;
break;
case "bIgnoreBaseRotation":
if (p.raw[p.raw.Length - 1] == 1)
bIgnoreBaseRotation = true;
break;
case "bHidden":
if (p.raw[p.raw.Length - 1] == 1)
bHidden = true;
break;
case "bEdShouldSnap":
if (p.raw[p.raw.Length - 1] == 1)
bEdShouldSnap = true;
break;
case "Tag":
Tag = p.Value.IntValue;
break;
case "UniqueTag":
UniqueTag = p.Value.IntValue;
break;
case "Group":
Group = p.Value.IntValue;
break;
case "BaseBoneName":
BaseBoneName = p.Value.IntValue;
break;
case "Base":
Base = p.Value.IntValue;
break;
case "BaseSkelComponent":
BaseSkelComponent = p.Value.IntValue;
break;
case "DrawScale":
DrawScale = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
case "TickFrequencyAtEndDistance":
TickFrequencyAtEndDistance = BitConverter.ToSingle(p.raw, p.raw.Length - 4);
break;
case "location":
location = new Vector3(BitConverter.ToSingle(p.raw, p.raw.Length - 12),
BitConverter.ToSingle(p.raw, p.raw.Length - 8),
BitConverter.ToSingle(p.raw, p.raw.Length - 4));
break;
#endregion
}
MyMatrix = Matrix.Translation(location);
GenerateMesh();
}
private static SequenceObjectInfo generateSequenceObjectInfo(int i, ME3Package pcc)
{
SequenceObjectInfo info = new SequenceObjectInfo();
PropertyReader.Property inputLinks = PropertyReader.getPropOrNull(pcc.Exports[i + 1], "InputLinks");
if (inputLinks != null)
{
int pos = 28;
byte[] global = inputLinks.raw;
int count = BitConverter.ToInt32(global, 24);
for (int j = 0; j < count; j++)
{
List<PropertyReader.Property> p2 = PropertyReader.ReadProp(pcc, global, pos);
info.inputLinks.Add(p2[0].Value.StringValue);
for (int k = 0; k < p2.Count(); k++)
pos += p2[k].raw.Length;
}
}
return info;
}
