public BioAnimSetData(PCCObject Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc, data);
BitConverter.IsLittleEndian = true;
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;
}
}
private static Type getType(PCCObject pcc, int type)
{
switch (pcc.getNameEntry(type))
{
case "None": return(Type.None);
case "StructProperty": return(Type.StructProperty);
case "IntProperty": return(Type.IntProperty);
case "FloatProperty": return(Type.FloatProperty);
case "ObjectProperty": return(Type.ObjectProperty);
case "NameProperty": return(Type.NameProperty);
case "BoolProperty": return(Type.BoolProperty);
case "ByteProperty": return(Type.ByteProperty);
case "ArrayProperty": return(Type.ArrayProperty);
case "DelegateProperty": return(Type.DelegateProperty);
case "StrProperty": return(Type.StrProperty);
case "StringRefProperty": return(Type.StringRefProperty);
default:
return(Type.Unknown);
}
}
public static List <Property> getPropList(PCCObject pcc, PCCObject.ExportEntry export)
{
Application.DoEvents();
int start = detectStart(pcc, export.Data, export.ObjectFlags);
return(ReadProp(pcc, export.Data, start));
}
public AnimNodeSlot(PCCObject Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc, data);
BitConverter.IsLittleEndian = true;
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;
}
}
private void openGUIDCacheToolStripMenuItem_Click(object sender, EventArgs e)
{
BitConverter.IsLittleEndian = true;
pcc = new PCCObject(ME3Directory.cookedPath + "GuidCache.pcc");
ReadGUIDs(pcc.Exports[0].Data);
RefreshLists();
}
public string DumpArray(PCCObject pcc,byte [] raw, int pos, string s, 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 == PropertyReader.Type.StringRefProperty)
{
for (int j = 0; j < depth; j++)
res += "\t";
res += i + " : " + PropertyReader.PropertyToText(p[i], pcc) + "\n";
}
if (p[i].TypeVal == PropertyReader.Type.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, res, depth + 1);
}
if (p[i].TypeVal == PropertyReader.Type.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, res, depth + 1);
}
}
return res;
}
public WwiseAmbientSound(PCCObject Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc, data);
BitConverter.IsLittleEndian = true;
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();
}
private void startScanToolStripMenuItem_Click(object sender, EventArgs e)
{
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) + " ...");
PCCObject pcc = new PCCObject(file);
int count2 = 0;
foreach (PCCObject.ExportEntry ent in pcc.Exports)
{
if (ent.ClassName == "Function")
{
Function f = new Function(ent.Data, pcc);
ScriptEntry n = new ScriptEntry();
n.file = Path.GetFileName(file);
n.name = ent.PackageFullName + "." + ent.ObjectName;
n.script = f.ToRawText(false);
database.Add(n);
DebugOutput.PrintLn("\tFound \"" + n.name + "\"",false);
}
count2++;
}
{
pb1.Maximum = files.Length;
pb1.Value = count;
}
count++;
}
RefreshList();
}
public ExportEntry(PCCObject pccFile, byte[] importData, uint exportOffset)
{
pccRef = pccFile;
info = (byte[])importData.Clone();
offset = exportOffset;
hasChanged = false;
}
public string ToString(PCCObject p)
{
if (val == -1)
return enumName + ", " + values[0];
else
return p.getNameEntry(type) + ", " + p.getNameEntry(val);
}
public AnimSet(PCCObject Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc, data);
BitConverter.IsLittleEndian = true;
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 Level(PCCObject Pcc, int index, bool SimpleRead = false)
{
memory = Pcc.Exports[index].Data;
memlength = memory.Length;
pcc = Pcc;
Deserialize(SimpleRead);
}
public AnimTree(PCCObject Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc, data);
BitConverter.IsLittleEndian = true;
AnimGroups = new List<AnimGroupEntry>();
ComposePrePassBoneNames = new List<string>();
SkelControlLists = new List<SkelControlListEntry>();
Children = new List<ChildrenEntry>();
BitConverter.IsLittleEndian = true;
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 static List <Property> getPropList(PCCObject pcc, byte[] raw)
{
Application.DoEvents();
int start = detectStart(pcc, raw);
return(ReadProp(pcc, raw, start));
}
public WwiseStream(PCCObject Pcc, byte[] Raw)
{
pcc = Pcc;
memory = Raw;
memsize = memory.Length;
Deserialize();
}
public StaticMeshCollectionActor(PCCObject Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc, data);
BitConverter.IsLittleEndian = true;
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 MantleMarker(PCCObject Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc, data);
BitConverter.IsLittleEndian = true;
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 SAction(int idx, float x, float y, PCCObject p)
: base(idx, x, y, p)
{
GetVarLinks();
GetOutputLinks();
originalX = x;
originalY = y;
}
public SAction(int idx, float x, float y, PCCObject p, GraphEditor grapheditor)
: base(idx, x, y, p, grapheditor)
{
GetVarLinks();
GetOutputLinks();
originalX = x;
originalY = y;
}
public void LoadFile(string path)
{
pcc = new PCCObject(path);
Objects = new List<int>();
for (int i = 0; i < pcc.Exports.Count; i++)
if (pcc.Exports[i].ClassName == "Function")
Objects.Add(i);
RefreshLists();
}
public static CustomProperty PropertyToGrid(Property p, PCCObject pcc)
{
string cat = p.TypeVal.ToString();
CustomProperty pg;
switch (p.TypeVal)
{
case Type.BoolProperty:
pg = new CustomProperty(pcc.Names[p.Name], cat, (p.Value.IntValue == 1), typeof(bool), false, true);
break;
case Type.FloatProperty:
byte[] buff = BitConverter.GetBytes(p.Value.IntValue);
float f = BitConverter.ToSingle(buff, 0);
pg = new CustomProperty(pcc.Names[p.Name], cat, f, typeof(float), false, true);
break;
case Type.ByteProperty:
case Type.NameProperty:
NameProp pp = new NameProp();
pp.name = pcc.getNameEntry(p.Value.IntValue);
pp.nameindex = p.Value.IntValue;
pg = new CustomProperty(pcc.Names[p.Name], cat, pp, typeof(NameProp), false, true);
break;
case Type.ObjectProperty:
ObjectProp ppo = new ObjectProp();
ppo.name = pcc.getObjectName(p.Value.IntValue);
ppo.nameindex = p.Value.IntValue;
pg = new CustomProperty(pcc.Names[p.Name], cat, ppo, typeof(ObjectProp), false, true);
break;
case Type.StructProperty:
StructProp ppp = new StructProp();
ppp.name = pcc.getNameEntry(p.Value.IntValue);
ppp.nameindex = p.Value.IntValue;
byte[] buf = new byte[p.Value.Array.Count()];
for (int i = 0; i < p.Value.Array.Count(); i++)
{
buf[i] = (byte)p.Value.Array[i].IntValue;
}
List <int> buf2 = new List <int>();
for (int i = 0; i < p.Value.Array.Count() / 4; i++)
{
buf2.Add(BitConverter.ToInt32(buf, i * 4));
}
ppp.data = buf2.ToArray();
pg = new CustomProperty(pcc.Names[p.Name], cat, ppp, typeof(StructProp), false, true);
break;
default:
pg = new CustomProperty(pcc.Names[p.Name], cat, p.Value.IntValue, typeof(int), false, true);
break;
}
return(pg);
}
private void openPccToolStripMenuItem_Click(object sender, EventArgs e)
{
OpenFileDialog d = new OpenFileDialog();
d.Filter = "*.pcc|*.pcc";
if (d.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
pcc = new PCCObject(d.FileName);
ListRefresh();
}
}
public void LoadPCC(string fileName)
{
objects.Clear();
pcc = new PCCObject(fileName);
CurrentFile = fileName;
for (int i = 0; i < pcc.Exports.Count; i++)
if (pcc.Exports[i].ClassName == "InterpData")
objects.Add(i);
RefreshCombo();
}
public void LoadPCC(string path)
{
MeshplorerMode = 0;
CurrFile = path;
pcc = new PCCObject(path);
Materials = new List<int>();
for (int i = 0; i < pcc.Exports.Count; i++)
if (pcc.Exports[i].ClassName == "Material" || pcc.Exports[i].ClassName == "MaterialInstanceConstant")
Materials.Add(i);
RefreshList1();
}
/*
* This method is called when using the -decompresspcc command line argument
*/
private int autoDecompressPcc(string sourceFile, string outputFile)
{
if (!File.Exists(sourceFile)){
MessageBox.Show("PCC to decompress does not exist:\n" + sourceFile, "Auto Decompression Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return 1;
}
System.Console.WriteLine("Automating Pcc Decompressor: " + sourceFile + " => " + outputFile);
PCCObject pccObj = new PCCObject(sourceFile);
pccObj.saveToFile(outputFile,false);
return 0;
}
private void startScanToolStripMenuItem_Click(object sender, EventArgs e)
{
string path = ME3Directory.cookedPath;
string[] files = Directory.GetFiles(path, "*.pcc");
pb1.Maximum = files.Length;
DebugOutput.Clear();
database = new List<DBEntry>();
int count = 0;
foreach (string file in files)
{
pb1.Value = count++;
DebugOutput.PrintLn("Scanning file : " + Path.GetFileName(file) + " ...");
PCCObject pcc = new PCCObject(file);
DBEntry ent = new DBEntry();
ent.filename = Path.GetFileName(file);
ent.Objects = new List<ObjInf>();
for (int i = 0; i < pcc.Exports.Count; i++)
{
PCCObject.ExportEntry ex = pcc.Exports[i];
ObjInf obj;
switch (ex.ClassName)
{
case "StaticMesh":
obj = new ObjInf();
obj.Index = i;
obj.Type = 0;
obj.name = ex.ObjectName;
ent.Objects.Add(obj);
break;
case "SkeletalMesh":
obj = new ObjInf();
obj.Index = i;
obj.Type = 1;
obj.name = ex.ObjectName;
ent.Objects.Add(obj);
break;
}
}
if (ent.Objects.Count != 0)
{
DebugOutput.PrintLn("Found " + ent.Objects.Count + " Objects:", false);
//foreach (ObjInf o in ent.Objects)
// DebugOutput.PrintLn("\t" + o.Index + " : " + o.name + " (" + TypeToString(o.Type) + ")", false);
//DebugOutput.Update();
database.Add(ent);
}
else
{
DebugOutput.PrintLn("Nothing...", false);
}
}
RefreshLists();
pb1.Value = 0;
}
public SObj(int idx, float x, float y, PCCObject p)
: base()
{
pcc = p;
index = idx;
comment = new SText(GetComment(index), commentColor, false);
comment.X = 0;
comment.Y = 0 - comment.Height;
comment.Pickable = false;
this.AddChild(comment);
this.Pickable = true;
}
public TreeNode ToTree(string name, PCCObject pcc)
{
TreeNode root = new TreeNode(name);
TreeNode t = new TreeNode("Points");
if(Points != null)
{
for (int i = 0; i < Points.Count; i++)
t.Nodes.Add(Points[i].ToTree(i, pcc));
}
root.Nodes.Add(t);
return root;
}
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))
{
DialogResult dialogResult = MessageBox.Show("Do you want to make a backup file?", "Make Backup", MessageBoxButtons.YesNo);
try
{
if (dialogResult == DialogResult.Yes)
{
File.Copy(fileName, backupFile);
}
PCCObject pccObj = new PCCObject(fileName);
pccObj.saveToFile(true);
//PCCObject pccFile = new PCCObject();
//pccFile.LoadFile(fileName);
/*main function that compress the file
PCCHandler.CompressAndSave(pccFile.SaveFile(),fileName);*/
/*byte[] buffer;
using (FileStream inputStream = File.OpenRead(fileName))
{
buffer = new byte[inputStream.Length];
inputStream.Read(buffer, 0, buffer.Length);
}
if (dialogResult == DialogResult.Yes)
{
File.Copy(fileName, backupFile);
}
//main function that compress the file
PCCHandler.CompressAndSave(buffer,fileName);*/
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);
}
}
}
}
}
public DecalActor(PCCObject Pcc, int Index)
{
pcc = Pcc;
MyIndex = Index;
if (pcc.isExport(Index))
data = pcc.Exports[Index].Data;
Props = PropertyReader.getPropList(pcc, data);
BitConverter.IsLittleEndian = true;
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 loadToolStripMenuItem_Click(object sender, EventArgs e)
{
OpenFileDialog d = new OpenFileDialog();
d.Filter = "PCC Files(*.pcc)|*.pcc";
if (d.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
status.Text = "Loaded : " + d.FileName;
pcc = new PCCObject(d.FileName);
CurrentFile = d.FileName;
LoadMaterials();
}
}
public void CreateDataBase()
{
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;
}
FileStream fs = new FileStream(DataBaseFile, FileMode.Create, FileAccess.Write);
string pathcook = ME3Directory.cookedPath;
DebugOutput.Clear();
DebugOutput.PrintLn("Levelbase.cs: Loading files from :" + pathcook);
string[] files = Directory.GetFiles(pathcook, "*.pcc");
for (int i = 0; i < files.Length; i++)
{
string file = files[i];
DebugOutput.PrintLn(i + "/" + (files.Length - 1) + " Scanning : " + Path.GetFileName(file));
PCCObject pcc = new PCCObject(file);
for (int j = 0; j < pcc.Exports.Count(); j++)
{
PCCObject.ExportEntry e = pcc.Exports[j];
if (e.ClassName == "Level")
{
Level l = new Level(pcc, j, true);
DBEntry entry = new DBEntry();
entry.filepath = file;
entry.index = j;
entry.count = l.Objects.Count();
database.Add(entry);
//foreach(int idx in l.Objects)
// if (pcc.isExport(idx) && pcc.Exports[idx].ClassName == "BioPlaypenVolumeAdditive")
// DebugOutput.PrintLn("#############################found");
DebugOutput.PrintLn("\tfound Level with " + entry.count + " Objects");
}
}
}
database.Sort((a,b) => a.filepath.CompareTo(b.filepath));
BitConverter.IsLittleEndian = true;
byte[] buff = BitConverter.GetBytes(database.Count());
fs.Write(buff, 0, 4);
foreach (DBEntry e in database)
{
buff = BitConverter.GetBytes(e.index);
fs.Write(buff, 0, 4);
buff = BitConverter.GetBytes(e.count);
fs.Write(buff, 0, 4);
buff = BitConverter.GetBytes(e.filepath.Length);
fs.Write(buff, 0, 4);
foreach (char c in e.filepath)
fs.WriteByte((byte)c);
}
fs.Close();
}
private void QMapEditor_Activated(object sender, EventArgs e)
{
string pathcook = ME3Directory.cookedPath;
if (!File.Exists(pathcook + "SFXGameInfoSP_SF.pcc"))
{
MessageBox.Show("File SFXGameInfoSP_SF.pcc not found!");
this.Close();
return;
}
pcc = new PCCObject(pathcook + "SFXGameInfoSP_SF.pcc");
GetEntries();
RefreshTree();
}
public PCCObject.ExportEntry CopyExport(PCCObject.ExportEntry exp)
{
PCCObject.ExportEntry ret = new PCCObject.ExportEntry(pcc, exp.Data, exp.offset);
//ret.childs = exp.childs;
//ret.ClassName = exp.ClassName;
//ret.Data = CopyArray(exp.Data);
//ret.DataSize = exp.DataSize;
//ret.Link = exp.Link;
//ret.ObjectName = exp.ObjectName;
//ret.off = exp.off;
//ret.raw = CopyArray(exp.raw);
return ret;
}
public TreeNode ToTree(int MyIndex, TalkFile talk, PCCObject pcc)
{
string s = "";
if (Text.Length != 0)
s = Text.Substring(0, Text.Length - 1);
TreeNode res = new TreeNode(MyIndex + " : " + s + " " + talk.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
+ " "
+ talk.findDataById(e.refParaphrase)
+ " "
+ e.Index
+ " "
+ pcc.getNameEntry(e.CategoryType)
+ " "
+ 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 + " " + talk.findDataById(refText));
res.Nodes.Add("GUIStyle : (" + pcc.getNameEntry(GUIStyleType) + ") " + pcc.getNameEntry(GUIStyleValue));
return res;
}
public static string PropertyToText(Property p, PCCObject pcc)
{
string s = "";
s = "Name: " + pcc.Names[p.Name];
s += " Type: " + TypeToString((int)p.TypeVal);
s += " Size: " + p.Value.len.ToString();
switch (p.TypeVal)
{
case Type.StructProperty:
s += " \"" + pcc.getNameEntry(p.Value.IntValue) + "\" with " + p.Value.Array.Count.ToString() + " bytes";
break;
case Type.IntProperty:
case Type.ObjectProperty:
case Type.BoolProperty:
case Type.StringRefProperty:
s += " Value: " + p.Value.IntValue.ToString();
break;
case Type.FloatProperty:
byte[] buff = BitConverter.GetBytes(p.Value.IntValue);
float f = BitConverter.ToSingle(buff, 0);
s += " Value: " + f.ToString();
break;
case Type.NameProperty:
s += " " + pcc.Names[p.Value.IntValue];
break;
case Type.ByteProperty:
s += " Value: \"" + p.Value.StringValue + "\" with \"" + pcc.getNameEntry(p.Value.IntValue) + "\"";
break;
case Type.ArrayProperty:
s += " bytes"; //Value: " + p.Value.Array.Count.ToString() + " Elements";
break;
case Type.StrProperty:
if (p.Value.StringValue.Length == 0)
{
break;
}
s += " Value: " + p.Value.StringValue.Substring(0, p.Value.StringValue.Length - 1);
break;
}
return(s);
}
public static int detectStart(PCCObject pcc, byte[] raw, long flags)
{
if ((flags & (long)UnrealFlags.EObjectFlags.HasStack) != 0)
{
return(30);
}
int result = 8;
int test1 = BitConverter.ToInt32(raw, 4);
int test2 = BitConverter.ToInt32(raw, 8);
if (pcc.isName(test1) && test2 == 0)
{
result = 4;
}
if (pcc.isName(test1) && pcc.isName(test2) && test2 != 0)
{
result = 8;
}
return(result);
}
private static PropertyValue ReadValue(PCCObject pcc, byte[] raw, int start, int type)
{
PropertyValue v = new PropertyValue();
switch (pcc.Names[type])
{
case "IntProperty":
case "FloatProperty":
case "ObjectProperty":
case "StringRefProperty":
v.IntValue = BitConverter.ToInt32(raw, start);
v.len = 4;
break;
case "NameProperty":
v.IntValue = BitConverter.ToInt32(raw, start);
var nameRef = new NameReference();
nameRef.index = v.IntValue;
nameRef.count = BitConverter.ToInt32(raw, start + 4);
nameRef.Name = pcc.getNameEntry(nameRef.index);
if (nameRef.count > 0)
{
nameRef.Name += "_" + (nameRef.count - 1);
}
v.NameValue = nameRef;
v.len = 8;
break;
case "BoolProperty":
if (start < raw.Length)
{
v.IntValue = raw[start];
}
v.len = 1;
break;
}
return(v);
}
public static int detectStart(PCCObject pcc, byte[] raw)
{
int result = 8;
int test1 = BitConverter.ToInt32(raw, 4);
if (test1 < 0)
{
result = 30;
}
else
{
int test2 = BitConverter.ToInt32(raw, 8);
if (pcc.isName(test1) && test2 == 0)
{
result = 4;
}
if (pcc.isName(test1) && pcc.isName(test2) && test2 != 0)
{
result = 8;
}
}
return(result);
}
public ImportEntry(PCCObject pccFile, Stream importData)
{
pccRef = pccFile;
header = new byte[ImportEntry.byteSize];
importData.Read(header, 0, header.Length);
}
public static List <Property> ReadProp(PCCObject pcc, byte[] raw, int start)
{
Property p;
PropertyValue v;
int sname;
List <Property> result = new List <Property>();
int pos = start;
if (raw.Length - pos < 8)
{
return(result);
}
int name = (int)BitConverter.ToInt64(raw, pos);
if (!pcc.isName(name))
{
return(result);
}
string t = pcc.Names[name];
if (pcc.Names[name] == "None")
{
p = new Property();
p.Name = name;
p.TypeVal = Type.None;
p.i = 0;
p.offsetval = pos;
p.Size = 8;
p.Value = new PropertyValue();
p.raw = BitConverter.GetBytes((Int64)name);
p.offend = pos + 8;
result.Add(p);
return(result);
}
int type = (int)BitConverter.ToInt64(raw, pos + 8);
int size = BitConverter.ToInt32(raw, pos + 16);
int idx = BitConverter.ToInt32(raw, pos + 20);
if (!pcc.isName(type) || size < 0 || size >= raw.Length)
{
return(result);
}
string tp = pcc.Names[type];
switch (tp)
{
case "DelegateProperty":
p = new Property();
p.Name = name;
p.TypeVal = Type.DelegateProperty;
p.i = 0;
p.offsetval = pos + 24;
v = new PropertyValue();
v.IntValue = BitConverter.ToInt32(raw, pos + 28);
v.len = size;
v.Array = new List <PropertyValue>();
pos += 24;
for (int i = 0; i < size; i++)
{
PropertyValue v2 = new PropertyValue();
if (pos < raw.Length)
{
v2.IntValue = raw[pos];
}
v.Array.Add(v2);
pos++;
}
p.Value = v;
break;
case "ArrayProperty":
int count = (int)BitConverter.ToInt64(raw, pos + 24);
p = new Property();
p.Name = name;
p.TypeVal = Type.ArrayProperty;
p.i = 0;
p.offsetval = pos + 24;
v = new PropertyValue();
v.IntValue = type;
v.len = size - 4;
count = v.len;//TODO can be other objects too
v.Array = new List <PropertyValue>();
pos += 28;
for (int i = 0; i < count; i++)
{
PropertyValue v2 = new PropertyValue();
if (pos < raw.Length)
{
v2.IntValue = raw[pos];
}
v.Array.Add(v2);
pos++;
}
p.Value = v;
break;
case "StrProperty":
count = (int)BitConverter.ToInt64(raw, pos + 24);
p = new Property();
p.Name = name;
p.TypeVal = Type.StrProperty;
p.i = 0;
p.offsetval = pos + 24;
count *= -1;
v = new PropertyValue();
v.IntValue = type;
v.len = count;
pos += 28;
string s = "";
for (int i = 0; i < count; i++)
{
s += (char)raw[pos];
pos += 2;
}
v.StringValue = s;
p.Value = v;
break;
case "StructProperty":
sname = (int)BitConverter.ToInt64(raw, pos + 24);
p = new Property();
p.Name = name;
p.TypeVal = Type.StructProperty;
p.i = 0;
p.offsetval = pos + 24;
v = new PropertyValue();
v.IntValue = sname;
v.len = size;
v.Array = new List <PropertyValue>();
pos += 32;
for (int i = 0; i < size; i++)
{
PropertyValue v2 = new PropertyValue();
if (pos < raw.Length)
{
v2.IntValue = raw[pos];
}
v.Array.Add(v2);
pos++;
}
p.Value = v;
break;
case "ByteProperty":
sname = (int)BitConverter.ToInt64(raw, pos + 24);
p = new Property();
p.Name = name;
p.TypeVal = Type.ByteProperty;
p.i = 0;
p.offsetval = pos + 32;
v = new PropertyValue();
v.StringValue = pcc.getNameEntry(sname);
v.len = size;
pos += 32;
v.IntValue = (int)BitConverter.ToInt64(raw, pos);
pos += size;
p.Value = v;
break;
default:
p = new Property();
p.Name = name;
p.TypeVal = getType(pcc, type);
p.i = 0;
p.offsetval = pos + 24;
p.Value = ReadValue(pcc, raw, pos + 24, type);
pos += p.Value.len + 24;
break;
}
p.raw = new byte[pos - start];
p.offend = pos;
if (pos < raw.Length)
{
for (int i = 0; i < pos - start; i++)
{
p.raw[i] = raw[start + i];
}
}
result.Add(p);
if (pos != start)
{
result.AddRange(ReadProp(pcc, raw, pos));
}
return(result);
}
public static CustomProperty PropertyToGrid(Property p, PCCObject pcc)
{
string cat = p.TypeVal.ToString();
CustomProperty pg;
switch (p.TypeVal)
{
case Type.BoolProperty:
pg = new CustomProperty(pcc.Names[p.Name], cat, (p.Value.IntValue == 1), typeof(bool), false, true);
break;
case Type.FloatProperty:
byte[] buff = BitConverter.GetBytes(p.Value.IntValue);
float f = BitConverter.ToSingle(buff, 0);
pg = new CustomProperty(pcc.Names[p.Name], cat, f, typeof(float), false, true);
break;
case Type.ByteProperty:
case Type.NameProperty:
NameProp pp = new NameProp();
pp.name = pcc.getNameEntry(p.Value.IntValue);
pp.nameindex = p.Value.IntValue;
pg = new CustomProperty(pcc.Names[p.Name], cat, pp, typeof(NameProp), false, true);
break;
case Type.ObjectProperty:
ObjectProp ppo = new ObjectProp();
ppo.name = pcc.getObjectName(p.Value.IntValue);
ppo.nameindex = p.Value.IntValue;
pg = new CustomProperty(pcc.Names[p.Name], cat, ppo, typeof(ObjectProp), false, true);
break;
case Type.StrProperty:
pg = new CustomProperty(pcc.Names[p.Name], cat, p.Value.StringValue, typeof(string), false, true);
break;
case Type.ArrayProperty:
pg = new CustomProperty(pcc.Names[p.Name], cat, BitConverter.ToInt32(p.raw, 24) + " elements", typeof(string), false, true);
break;
case Type.StructProperty:
string structType = pcc.getNameEntry(p.Value.IntValue);
if (structType == "Color")
{
ColorProp cp = new ColorProp();
cp.name = structType;
cp.nameindex = p.Value.IntValue;
System.Drawing.Color color = System.Drawing.Color.FromArgb(BitConverter.ToInt32(p.raw, 32));
cp.Alpha = color.A;
cp.Red = color.R;
cp.Green = color.G;
cp.Blue = color.B;
pg = new CustomProperty(pcc.Names[p.Name], cat, cp, typeof(ColorProp), false, true);
}
else if (structType == "Vector")
{
VectorProp vp = new VectorProp();
vp.name = structType;
vp.nameindex = p.Value.IntValue;
vp.X = BitConverter.ToSingle(p.raw, 32);
vp.Y = BitConverter.ToSingle(p.raw, 36);
vp.Z = BitConverter.ToSingle(p.raw, 40);
pg = new CustomProperty(pcc.Names[p.Name], cat, vp, typeof(VectorProp), false, true);
}
else if (structType == "Rotator")
{
RotatorProp rp = new RotatorProp();
rp.name = structType;
rp.nameindex = p.Value.IntValue;
rp.Pitch = (float)BitConverter.ToInt32(p.raw, 32) * 360f / 65536f;
rp.Yaw = (float)BitConverter.ToInt32(p.raw, 36) * 360f / 65536f;
rp.Roll = (float)BitConverter.ToInt32(p.raw, 40) * 360f / 65536f;
pg = new CustomProperty(pcc.Names[p.Name], cat, rp, typeof(RotatorProp), false, true);
}
else if (structType == "LinearColor")
{
LinearColorProp lcp = new LinearColorProp();
lcp.name = structType;
lcp.nameindex = p.Value.IntValue;
lcp.Red = BitConverter.ToSingle(p.raw, 32);
lcp.Green = BitConverter.ToSingle(p.raw, 36);
lcp.Blue = BitConverter.ToSingle(p.raw, 40);
lcp.Alpha = BitConverter.ToSingle(p.raw, 44);
pg = new CustomProperty(pcc.Names[p.Name], cat, lcp, typeof(VectorProp), false, true);
}
else
{
StructProp ppp = new StructProp();
ppp.name = structType;
ppp.nameindex = p.Value.IntValue;
byte[] buf = new byte[p.Value.Array.Count()];
for (int i = 0; i < p.Value.Array.Count(); i++)
{
buf[i] = (byte)p.Value.Array[i].IntValue;
}
List <int> buf2 = new List <int>();
for (int i = 0; i < p.Value.Array.Count() / 4; i++)
{
buf2.Add(BitConverter.ToInt32(buf, i * 4));
}
ppp.data = buf2.ToArray();
pg = new CustomProperty(pcc.Names[p.Name], cat, ppp, typeof(StructProp), false, true);
}
break;
default:
pg = new CustomProperty(pcc.Names[p.Name], cat, p.Value.IntValue, typeof(int), false, true);
break;
}
return(pg);
}
public ImportEntry(PCCObject pccFile, byte[] importData)
{
pccRef = pccFile;
data = (byte[])importData.Clone();
}
public ImportEntry(PCCObject pccFile, Stream importData)
{
pccRef = pccFile;
data = new byte[ImportEntry.byteSize];
importData.Read(data, 0, data.Length);
}