예제 #1
0
        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);
                }
            }
        }
예제 #2
0
        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);
        }
예제 #3
0
 public static void SetNodeDataTypeIfNull(PssgSchema.Node node, Type dataType)
 {
     if (node.DataType == typeof(System.Exception))
     {
         node.DataType = dataType;
     }
 }
예제 #4
0
 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();
 }
예제 #5
0
        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);
        }
예제 #6
0
        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);
        }
예제 #7
0
        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);
        }
예제 #8
0
            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;
                        }
                    }
                }
            }
예제 #9
0
        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);
                }
            }
        }
예제 #10
0
 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));
     }
 }
예제 #11
0
 public void Rename(string nodeName)
 {
     this.NodeInfo = PssgSchema.RenameNode(this, nodeName);
 }
예제 #12
0
        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);
        }