public void UpdateId(ref int nodeNameCount, ref int attributeNameCount)
{
PssgSchema.Node sNode = this.NodeInfo;
if (sNode.Id == -1)
{
sNode.Id = ++nodeNameCount;
}
//this.id = sNode.Id;
if (Attributes != null)
{
foreach (PssgAttribute attr in Attributes)
{
attr.UpdateId(ref attributeNameCount);
}
}
if (ChildNodes != null)
{
foreach (PssgNode node in ChildNodes)
{
node.UpdateId(ref nodeNameCount, ref attributeNameCount);
}
}
}
public PssgNode(XElement elem, PssgFile file, PssgNode node)
{
this.File = file;
this.ParentNode = node;
this.NodeInfo = PssgSchema.AddNode(elem.Name.LocalName);// PssgSchema.GetNode(elem.Name.LocalName);
this.Attributes = new PssgAttributeCollection();
PssgAttribute attr;
foreach (XAttribute xAttr in elem.Attributes())
{
attr = new PssgAttribute(xAttr, file, this);
this.Attributes.Add(attr);
}
// Add data, and sub nodes code here
if (elem.FirstNode != null && elem.FirstNode is XText)
{
this.data = this.FromString(elem.Value);
this.ChildNodes = new PssgNodeCollection();
}
else
{
this.data = new byte[0];
this.ChildNodes = new PssgNodeCollection(elem.Elements().Count());
int nodeCount = 0;
foreach (XElement subElem in elem.Elements())
{
this.ChildNodes.Add(new PssgNode(subElem, file, this));
++nodeCount;
}
}
PssgSchema.SetNodeDataTypeIfNull(this.NodeInfo, this.ValueType);
}
public static void SetNodeDataTypeIfNull(PssgSchema.Node node, Type dataType)
{
if (node.DataType == typeof(System.Exception))
{
node.DataType = dataType;
}
}
public PssgNode(string name, PssgFile file, PssgNode node)
{
this.File = file;
this.ParentNode = node;
this.NodeInfo = PssgSchema.AddNode(name);
this.Attributes = new PssgAttributeCollection();
this.data = new byte[0];
this.ChildNodes = new PssgNodeCollection();
}
public static PssgSchema.Node RenameNode(PssgNode pssgNode, string nodeName)
{
PssgSchema.Node node = PssgSchema.AddNode(nodeName);
foreach (PssgAttribute attr in pssgNode.Attributes)
{
PssgSchema.AddAttribute(node.Name, attr.AttributeInfo.Name, attr.AttributeInfo.DataType);
}
return(node);
}
private Type GetValueType()
{
PssgSchema.Node sNode = this.NodeInfo;// PssgSchema.GetNode(this.Name);
if (sNode == null)
{
return(typeof(byte[]));
}
if (!string.IsNullOrEmpty(sNode.LinkAttributeName))
{
PssgNode node;
string linkAttrName;
if (sNode.LinkAttributeName[0] == '^')
{
if (this.ParentNode == null)
{
throw new InvalidOperationException("Node without parent cannot reference a parent's attribute.");
}
node = this.ParentNode;
linkAttrName = sNode.LinkAttributeName.Substring(1);
}
else
{
node = this;
linkAttrName = sNode.LinkAttributeName;
}
if (node.HasAttribute(linkAttrName))
{
PssgAttribute attr = node.Attributes[linkAttrName];
if (attr.Value is string)
{
string format = (string)attr.Value;
if (format.Contains("float"))
{
return(typeof(Single[]));
}
else if (format.Contains("ushort"))
{
return(typeof(UInt16[]));
}
}
}
}
return(sNode.DataType);
}
private Type GetValueType()
{
PssgSchema.Node sNode = this.NodeInfo;// PssgSchema.GetNode(this.Name);
if (sNode == null)
{
return(typeof(byte[]));
}
if (!string.IsNullOrEmpty(sNode.LinkAttributeName))
{
PssgAttributeCollection attrs;
string linkAttrName;
if (sNode.LinkAttributeName[0] == '^')
{
attrs = this.ParentNode.Attributes;
linkAttrName = sNode.LinkAttributeName.Substring(1);
}
else
{
attrs = this.Attributes;
linkAttrName = sNode.LinkAttributeName;
}
PssgAttribute attr = attrs[linkAttrName];
if (attr != null && attr.Value is string)
{
string format = (string)attr.Value;
if (format.Contains("float"))
{
return(typeof(Single[]));
}
else if (format.Contains("ushort"))
{
return(typeof(UInt16[]));
}
}
}
return(sNode.DataType);
}
static void GetNodeAttributeNameCount(PssgFile file, out int nodeNameCount, out int attributeNameCount)
{
nodeNameCount = 0;
attributeNameCount = 0;
foreach (var node in file.GetNodes())
{
PssgSchema.Node sNode = node.NodeInfo;
if (sNode.Id == -1)
{
// change this so we don't count it twice
sNode.Id = ++nodeNameCount;
}
foreach (PssgAttribute attr in node.Attributes)
{
if (attr.AttributeInfo.Id == -1)
{
// change this so we don't count it twice
attr.AttributeInfo.Id = ++attributeNameCount;
}
}
}
}
public PssgNode(PssgNode nodeToCopy)
{
this.File = nodeToCopy.File;
this.ParentNode = nodeToCopy.ParentNode;
this.NodeInfo = nodeToCopy.NodeInfo;
this.size = nodeToCopy.size;
this.attributeSize = nodeToCopy.attributeSize;
this.Attributes = new PssgAttributeCollection();
PssgAttribute attr;
foreach (PssgAttribute attrToCopy in nodeToCopy.Attributes)
{
attr = new PssgAttribute(attrToCopy);
attr.ParentNode = this;
this.Attributes.Add(attr);
}
if (nodeToCopy.IsDataNode)
{
this.data = nodeToCopy.data;
this.ChildNodes = new PssgNodeCollection();
}
else
{
this.data = new byte[0];
// Each node at least 12 bytes (id + size + arg size)
this.ChildNodes = new PssgNodeCollection(nodeToCopy.ChildNodes.Count);
foreach (PssgNode subNodeToCopy in nodeToCopy.ChildNodes)
{
PssgNode node = new PssgNode(subNodeToCopy);
node.ParentNode = this;
this.ChildNodes.Add(node);
}
}
}
public override string ToString()
{
PssgSchema.Node sNode = this.NodeInfo;// PssgSchema.GetNode(this.Name);
if (ValueType == typeof(Single[]))
{
string result = string.Empty;
for (int i = 0; i < ((Single[])Value).Length; i++)
{
if (i % sNode.ElementsPerRow == 0)
{
result += Environment.NewLine;
}
result += ((Single[])Value)[i].ToString("e9", System.Globalization.CultureInfo.InvariantCulture);
result += " ";
}
return(result);
}
else if (ValueType == typeof(UInt16[]))
{
string result = string.Empty;
for (int i = 0; i < ((UInt16[])Value).Length; i++)
{
if (i % sNode.ElementsPerRow == 0)
{
result += Environment.NewLine;
}
result += ((UInt16[])Value)[i].ToString();
result += " ";
}
return(result);
}
else
{
return(HexHelper.ByteArrayToHexViaLookup32((byte[])Value, sNode.ElementsPerRow));
}
}
public void Rename(string nodeName)
{
this.NodeInfo = PssgSchema.RenameNode(this, nodeName);
}
public PssgNode(PssgBinaryReader reader, PssgFile file, PssgNode node, bool useDataNodeCheck)
{
this.File = file;
this.ParentNode = node;
int id = reader.ReadInt32();
this.NodeInfo = PssgSchema.GetNode(id);
this.size = reader.ReadInt32();
long end = reader.BaseStream.Position + size;
this.attributeSize = reader.ReadInt32();
long attributeEnd = reader.BaseStream.Position + attributeSize;
if (attributeEnd > reader.BaseStream.Length || end > reader.BaseStream.Length)
{
throw new Exception("This file is improperly saved and not supported by this version of the PSSG editor." + Environment.NewLine + Environment.NewLine +
"Get an older version of the program if you wish to take out its contents, but, put it back together using this program and a non-modded version of the pssg file.");
}
// Each attr is at least 8 bytes (id + size), so take a conservative guess
this.Attributes = new PssgAttributeCollection();
PssgAttribute attr;
while (reader.BaseStream.Position < attributeEnd)
{
attr = new PssgAttribute(reader, file, this);
this.Attributes.Add(attr);
}
bool isDataNode = false;
switch (Name)
{
case "BOUNDINGBOX":
case "DATA":
case "DATABLOCKDATA":
case "DATABLOCKBUFFERED":
case "INDEXSOURCEDATA":
case "INVERSEBINDMATRIX":
case "MODIFIERNETWORKINSTANCEUNIQUEMODIFIERINPUT":
case "NeAnimPacketData_B1":
case "NeAnimPacketData_B4":
case "RENDERINTERFACEBOUNDBUFFERED":
case "SHADERINPUT":
case "TEXTUREIMAGEBLOCKDATA":
case "TRANSFORM":
isDataNode = true;
break;
}
if (isDataNode == false && useDataNodeCheck == true)
{
long currentPos = reader.BaseStream.Position;
// Check if it has subnodes
while (reader.BaseStream.Position < end)
{
int tempID = reader.ReadInt32();
if (tempID < 0)//tempID > file.nodeInfo.Length ||
{
isDataNode = true;
break;
}
else
{
int tempSize = reader.ReadInt32();
if ((reader.BaseStream.Position + tempSize > end) || (tempSize == 0 && tempID == 0) || tempSize < 0)
{
isDataNode = true;
break;
}
else if (reader.BaseStream.Position + tempSize == end)
{
break;
}
else
{
reader.BaseStream.Position += tempSize;
}
}
}
reader.BaseStream.Position = currentPos;
}
if (isDataNode)
{
this.data = reader.ReadNodeValue(GetValueType(), (int)(end - reader.BaseStream.Position));
this.ChildNodes = new PssgNodeCollection();
//data = reader.ReadBytes((int)(end - reader.BaseStream.Position));
}
else
{
this.data = new byte[0];
// Each node at least 12 bytes (id + size + arg size)
this.ChildNodes = new PssgNodeCollection((int)(end - reader.BaseStream.Position) / 12);
int nodeCount = 0;
while (reader.BaseStream.Position < end)
{
this.ChildNodes.Add(new PssgNode(reader, file, this, useDataNodeCheck));
nodeCount++;
}
}
PssgSchema.SetNodeDataTypeIfNull(this.NodeInfo, this.ValueType);
}