Beispiel #1
0
        private static void WriteNode(XmlTextWriter writer, TextureNode node, string filePath)
        {
            WriteElement(writer, "Node", new string[] { "name" }, new string[] { node.Text });

            WriteElement(writer, "Position", new string[] { "x", "y" }, new string[] { node.xLocation.ToString(), node.yLocation.ToString() }, true);
            WriteElement(writer, "Center", new string[] { "x", "y" }, new string[] { node.xCenter.ToString(), node.yCenter.ToString() }, true);

            if (node.Texture != null)
            {
                WriteElement(writer, "Texture", new string[] { "name", "safeName" }, new string[] { GetRelativPath(node.TextureName, filePath), node.SafeTextureName }, true);
            }

            Color color = node.Color;

            WriteElement(writer, "Color", new string[] { "A", "R", "G", "B" }, new string[] { color.A.ToString(), color.R.ToString(), color.G.ToString(), color.B.ToString() }, true);
            WriteElement(writer, "Dimension", new string[] { "Size", "Aspect" }, new string[] { node.NodeSize.ToString(), node.AspectRatio.ToString() }, true);
            WriteElement(writer, "Rotation", new string[] { "value" }, new string[] { node.Rotation.ToString() }, true);
            WriteElement(writer, "Layer", new string[] { "value" }, new string[] { node.Layer.ToString() }, true);

            foreach (TreeNode child in node.Nodes)
            {
                WriteNode(writer, child as TextureNode, filePath);
            }

            writer.WriteEndElement();
        }
Beispiel #2
0
        public static void WriteChar(string fileName, TextureNode root, List <Pose> poseList, Pose basePose)
        {
            XmlTextWriter writer = new XmlTextWriter(fileName, null);

            writer.WriteStartDocument();
            writer.Formatting = Formatting.Indented;
            writer.WriteStartElement("Char");   // + char name ?

            writer.WriteStartElement("Nodes");
            WriteNode(writer, root, Path.GetFullPath(fileName));
            writer.WriteEndElement();

            if (basePose != null && poseList.IndexOf(basePose) != -1 && poseList.Count > 1)
            {
                writer.WriteStartElement("Poses");
                foreach (Pose pose in poseList)
                {
                    writePose(writer, pose, basePose, root);
                }
                writer.WriteEndElement();
            }

            writer.WriteEndElement();
            writer.WriteEndDocument();
            writer.Close();
        }
Beispiel #3
0
 public PoseNode GetNode(TextureNode node)
 {
     foreach (PoseNode pnv in this.PoseNodes)
     {
         if (node == pnv.Node)
         {
             return(pnv);
         }
     }
     return(null);
 }
Beispiel #4
0
        public void Create(TextureNode root, string[] properties, Pose basePose = null)
        {
            this.ClearPoseNodes();
            this.DifferentPropertiesCount = 0;
            List <TextureNode> nodes = new List <TextureNode>();

            nodes.Add(root);
            int baseIndex = 0;

            while (nodes.Count > 0)
            {
                PoseNode pnv = new PoseNode(nodes[0]);
                foreach (string property in properties)
                {
                    if (basePose == null)
                    {
                        pnv.SetProperty(property, nodes[0].GetProperty(property));
                    }
                    else
                    {
                        if (basePose.PoseNodes.Count > baseIndex && basePose.PoseNodes[baseIndex].Properties.ContainsKey(property))
                        {
                            float val1 = (float)nodes[0].GetProperty(property);
                            float val2 = (float)basePose.PoseNodes[baseIndex].Properties[property];
                            if (val1 != val2)
                            {
                                pnv.SetProperty(property, val1);
                            }
                        }
                        else
                        {
                            throw new IndexOutOfRangeException("base pose is not correct initialized");
                        }
                    }
                }
                if (pnv.Properties.Count > 0)
                {
                    this.PoseNodes.Add(pnv);
                    this.DifferentPropertiesCount += pnv.Properties.Count;
                }
                else
                {
                    pnv.Clear();
                }
                baseIndex++;
                foreach (TreeNode n in nodes[0].Nodes)
                {
                    nodes.Add(n as TextureNode);
                }
                nodes.RemoveAt(0);
            }
        }
Beispiel #5
0
        private static Pose ReadPose(XmlTextReader reader, TextureNode root)
        {
            Pose pose = new Pose(reader.GetAttribute(0));

            pose.Mode = reader.GetAttribute(1).Equals(PoseMode.Collection.ToString()) ? PoseMode.Collection : PoseMode.Pose;

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.EndElement)
                {
                    if (reader.Name == "Pose")
                    {
                        return(pose);
                    }
                }

                if (reader.NodeType == XmlNodeType.Element)
                {
                    if (reader.Name == "PoseNode")
                    {
                        string[] path = reader.GetAttribute(1).Split('.');
                        TreeNode node = root;
                        node = root;
                        for (int index = 0; index < path.Length; index++)
                        {
                            if (path.Length > 0)
                            {
                                int i = 0;
                                if (int.TryParse(path[index], out i))
                                {
                                    node = node.Nodes[i];
                                }
                            }
                        }
                        PoseNode poseNode = new PoseNode(node as TextureNode);

                        ReadProperty(reader, poseNode);
                        pose.MergeAdd(poseNode);
                    }

                    if (reader.Name == "Pose")      // if Pose is collection
                    {
                        Pose pose2 = ReadPose(reader, root);
                        pose.Nodes.Add(pose2);
                    }
                }
            }

            return(pose);
        }
Beispiel #6
0
        private void createRootItem()
        {
            TextureNode root = new TextureNode("Root");

            root.Checked             = true;
            this.nodeViewer.Root     = root;
            this.nodeViewer.Selected = root;

            Pose basePose = new Pose("Base");

            this.poseViewer.BasePose = basePose;
            this.poseViewer.Selected = basePose;

            resetZoomScrollClickEvent(this, EventArgs.Empty);
        }
Beispiel #7
0
        public static TextureNode ReadChar(string fileName, Form1 form)
        {
            TextureNode   root     = null;
            Pose          basePose = null;
            List <Pose>   allPoses = new List <Pose>();
            XmlTextReader reader   = new XmlTextReader(fileName);

            try
            {
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        if (reader.Name == "Node")
                        {
                            root = ReadNode(reader, Path.GetFullPath(fileName), form);
                        }

                        if (reader.Name == "Pose" && root != null)
                        {
                            Pose pose = ReadPose(reader, root);
                            if (pose != null)
                            {
                                allPoses.Add(pose);
                            }
                        }
                    }

                    if (root != null && basePose == null)
                    {
                        basePose = new Pose("Base");
                        basePose.Create(root, new string[] { "Rotation", "NodeSize" });
                        allPoses.Add(basePose);
                    }
                }

                reader.Close();
                form.poseViewer.Poses    = allPoses;
                form.poseViewer.Selected = basePose;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }

            return(root);
        }
Beispiel #8
0
        public bool CurrentlyChanging(TextureNode node)
        {
            bool result = this.IsCurrentlyChanging;

            if (!this.IsCurrentlyChanging)
            {
                if (Vector2.Distance(node.GlobalPosition, this.NewMousePos) < 10)
                {
                    this.SetMode(EditorSubMode.CenterMoveMode);
                }
                else
                {
                    Vector4 mT = Vector2.Transform(this.NewMousePos, node.TransformInv);
                    this.CheckMouseMode(new Vector2(mT.X, mT.Y), new Vector2(node.Destination.Width, node.Destination.Height), 10);
                }
            }
            return(result);
        }
Beispiel #9
0
        public void Update(bool updateChilds)
        {
            if (this.Parent != null && this.Parent is TextureNode)
            {
                TextureNode parent = this.Parent as TextureNode;
                this.ReferenceLength   = parent.ReferenceLength * parent.NodeSize;;
                this.GlobalRotation    = this.Rotation + parent.GlobalRotation;
                this.GlobalAspectRatio = this.AspectRatio;// need rework: +parent.GlobalAspectRatio;
                Vector4 posNew = Vector2.Transform(this.ReferenceLength * this.position, Matrix.RotationZ(parent.GlobalRotation));
                this.dest.Location = parent.GlobalPosition + new Vector2(posNew.X, posNew.Y);
            }
            else
            {   // Update Root
                if (this.TreeView != null)
                {
                    Game1 game = (this.TreeView.TopLevelControl as Form1).Game;
                    this.ReferenceLength   = game.ReferenceLength;
                    this.dest.Location     = game.GameCenter + this.position * this.ReferenceLength;
                    this.GlobalRotation    = this.Rotation;
                    this.GlobalAspectRatio = this.AspectRatio;
                }
            }

            this.dest.Height    = this.ReferenceLength * this.NodeSize;
            this.dest.Width     = dest.Height * this.GlobalAspectRatio;
            this.GlobalPosition = this.dest.Location;

            this.Transform =
                Matrix.Translation(-new Vector3(this.Destination.Width * this.Center.X, this.Destination.Height * this.Center.Y, 0))
                * Matrix.RotationZ(this.GlobalRotation)
                * Matrix.Translation(new Vector3(this.Destination.X, this.Destination.Y, 0));
            this.TransformInv = Matrix.Invert(this.Transform);

            if (updateChilds)
            {
                foreach (TreeNode node in this.Nodes)
                {
                    if (node is TextureNode)
                    {
                        (node as TextureNode).Update(true);
                    }
                }
            }
        }
Beispiel #10
0
        private void LoadFileOkEvent(object sender, CancelEventArgs e)
        {
            this.nodeViewer.SelectNothing();
            clearTree();
            TextureNode newRoot = CharXML.ReadChar(this.openFileDialog1.FileName, this);

            if (newRoot != null)
            {
                this.nodeViewer.Root = newRoot;
                this.nodeViewer.Root.Update(true);
                this.statusLabel.Text = this.openFileDialog1.SafeFileName;
            }
            else
            {
                clearTree();
                createRootItem();
            }
            this.nodeViewer.SelectNothing();
        }
Beispiel #11
0
        public void Draw(TextureNode node, float width, float height)
        {
            for (int index = 0; index < 4; index++)
            {
                Vector2 vec  = GameMode.ModePoints[index] * new Vector2(node.Destination.Width, node.Destination.Height);
                Vector4 pos  = Vector2.Transform(vec, node.Transform);
                Vector3 pos2 = new Vector3(2 * pos.X / width - 1.0f, 2 * pos.Y / -height + 1.0f, 0);
                vertices[index * 2].Position = pos2;
            }
            for (int index = 0; index < 4; index++)
            {
                vertices[index * 2 + 1].Position = (vertices[index * 2].Position + vertices[index * 2 + 2].Position) / 2;
            }


            vertices[8] = vertices[0];

            effect.CurrentTechnique.Passes[0].Apply();
            batch.Begin();
            batch.Draw(PrimitiveType.LineStrip, vertices);
            batch.End();
        }
Beispiel #12
0
 public void Clear()
 {
     this.Node = null;
     this.Properties.Clear();
 }
Beispiel #13
0
        private static void writePose(XmlTextWriter writer, Pose pose, Pose basePose, TextureNode root)
        {
            if (basePose != pose)     // exclude BasePose
            {
                PoseMode poseMode = pose.Mode;
                WriteElement(writer, "Pose", new string[] { "name", "type" }, new string[] { pose.Text, poseMode.ToString() });

                if (pose.PoseNodes.Count > 0 && poseMode == PoseMode.Pose)
                {
                    foreach (PoseNode poseNode in pose.PoseNodes)
                    {
                        PoseNode baseNode = basePose.GetNode(poseNode.Node);    // check null ?

                        string[] values = { poseNode.Node.Text, poseNode.Node.GetIndexPath() };
                        WriteElement(writer, "PoseNode", new string[] { "name", "path" }, values);

                        foreach (string property in poseNode.Properties.Keys)
                        {
                            string[] pValues = new string[] { property, poseNode.Properties[property].ToString() };
                            WriteElement(writer, "Property", new string[] { "name", "value" }, pValues, true);
                        }

                        writer.WriteEndElement();
                    }
                }
                else
                {
                    WriteElement(writer, "Equals", new string[] { "Pose" }, new String[] { basePose.Text }, true);
                }

                foreach (TreeNode subPose in pose.Nodes)
                {
                    writePose(writer, subPose as Pose, basePose, root);
                }

                writer.WriteEndElement();
            }
        }
Beispiel #14
0
        private static TextureNode ReadNode(XmlTextReader reader, string path, Form1 form)
        {
            TextureNode output = new TextureNode(reader.GetAttribute(0));

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.EndElement)
                {
                    if (reader.Name == "Node")
                    {
                        return(output);
                    }
                }

                if (reader.NodeType == XmlNodeType.Element)
                {
                    if (reader.Name == "Node")
                    {
                        output.Nodes.Add(ReadNode(reader, path, form));
                    }

                    if (reader.Name == "Position")
                    {
                        output.xLocation = float.Parse(reader.GetAttribute(0));
                        output.yLocation = float.Parse(reader.GetAttribute(1));
                    }

                    if (reader.Name == "Center")
                    {
                        output.xCenter = float.Parse(reader.GetAttribute(0));
                        output.yCenter = float.Parse(reader.GetAttribute(1));
                    }

                    if (reader.Name == "Texture")
                    {
                        output.TextureName     = Path.GetFullPath(Path.Combine(path, reader.GetAttribute(0)));
                        output.SafeTextureName = reader.GetAttribute(1);
                        output.Texture         = form.Game.Content.Load <SharpDX.Toolkit.Graphics.Texture2D>(output.TextureName);
                        output.Image           = System.Drawing.Image.FromFile(output.TextureName);
                        output.Checked         = true;
                    }

                    if (reader.Name == "Color")
                    {
                        Color color = new Color();
                        color.A      = byte.Parse(reader.GetAttribute(0));
                        color.R      = byte.Parse(reader.GetAttribute(1));
                        color.G      = byte.Parse(reader.GetAttribute(2));
                        color.B      = byte.Parse(reader.GetAttribute(3));
                        output.Color = color;
                    }

                    if (reader.Name == "Dimension")
                    {
                        output.NodeSize    = float.Parse(reader.GetAttribute(0));
                        output.AspectRatio = float.Parse(reader.GetAttribute(1));
                    }

                    if (reader.Name == "Rotation")
                    {
                        output.Rotation = float.Parse(reader.GetAttribute(0));
                    }

                    if (reader.Name == "Layer")
                    {
                        output.Layer = float.Parse(reader.GetAttribute(0));
                    }
                }
            }

            return(output);
        }
Beispiel #15
0
        protected override void Draw(XGame.XGameTime gameTime)
        {
            this.GraphicsDevice.Clear(this.backColor);

            if (this.OnDraw != null)
            {
                this.OnDraw(this, EventArgs.Empty);
            }

            if (this.DrawGrid && this.Window != null)
            {
                this.gridDrawer.Draw(this.Scroll, this.ReferenceLength);
            }

            if (this.form.nodeViewer.Root != null)
            {
                spritebatch.Begin(spritemode: SpriteSortMode.BackToFront);
                this.form.nodeViewer.Root.Draw(spritebatch);
                spritebatch.End();
            }

            if (this.selectedNode != null)
            {
                TextureNode n = this.selectedNode;

                textureBorderDrawer.Draw(n, (this.Window as DXGameWindow).Control.ClientSize.Width, (this.Window as DXGameWindow).Control.ClientSize.Height);

                spritebatch.Begin();

                spritebatch.Draw(
                    this.overlayTex.Texture, n.Destination, null, this.overlayColor,
                    n.GlobalRotation, n.Center * this.overlayTex.Size, SpriteEffects.None, 0.6f);

                if (n.Texture != null)
                {
                    Color c = n.Color;
                    c.A = byte.MaxValue;
                    spritebatch.Draw(n.Texture, n.Destination, null, c, n.GlobalRotation, n.Origin, SpriteEffects.None, 0.5f);
                }

                if (this.Mode.BasePoseSelected)
                {
                    spritebatch.Draw(
                        this.centerTex.Texture, n.GlobalPosition, null, Color.Red, 0,
                        this.centerTex.Origin, 0.25f, SpriteEffects.None, 0f);
                }

                Vector4 point;
                Vector2 vec;
                for (int index = 0; index < (this.Mode.BasePoseSelected ? 8 : 4); index++)
                {
                    vec   = GameMode.ModePoints[index];
                    point = Vector2.Transform(new Vector2(vec.X * n.Destination.Width, vec.Y * n.Destination.Height), n.Transform);
                    spritebatch.Draw(
                        this.circleTex.Texture, new Vector2(point.X, point.Y), null, Color.White,
                        n.GlobalRotation, this.circleTex.Origin, 0.025f, SpriteEffects.None, 0f);
                }

                spritebatch.End();
            }
        }
Beispiel #16
0
 private void nodeViewer_SelectedChanged(object sender, Controls.TreeViewerEventArgs args)
 {
     this.selectedNode = args.Node as TextureNode;
 }
Beispiel #17
0
        private void OnMouseMove()
        {
            if (this.selectedNode != null)
            {
                TextureNode n = this.selectedNode;

                if (this.Mode.CurrentlyChanging(n))
                {
                    switch (this.Mode.Mode)
                    {
                    case EditorMode.None:
                        this.Scroll += (this.Mode.NewMousePos - this.Mode.OldMousePos);
                        this.form.nodeViewer.Root.Update(true);
                        break;

                    case EditorMode.Rotate:
                        Vector2 oldVec = this.Mode.OldMousePos - n.GlobalPosition;
                        Vector2 newVec = this.Mode.NewMousePos - n.GlobalPosition;
                        double  arc    = Math.Atan2(newVec.Y, newVec.X) - Math.Atan2(oldVec.Y, oldVec.X);
                        double  newRot = n.Rotation + arc;
                        if (newRot < 0)
                        {
                            newRot += 2 * Math.PI;
                        }
                        if (newRot >= 2 * Math.PI)
                        {
                            newRot -= 2 * Math.PI;
                        }

                        n.Rotation = (float)newRot;
                        break;

                    case EditorMode.Move:
                        Vector2 mouseDiff = this.Mode.NewMousePos - this.Mode.OldMousePos;
                        Vector4 diff      = Vector2.Transform(mouseDiff, Matrix.RotationZ(-(n.GlobalRotation - n.Rotation)));
                        Vector2 diffXY    = new Vector2(diff.X, diff.Y);
                        if (this.Mode.SubMode == EditorSubMode.CenterMoveMode)
                        {
                            Vector4 diff2 = Vector2.Transform(mouseDiff, Matrix.RotationZ(-n.GlobalRotation));
                            n.xCenter += diff2.X / n.Destination.Width;
                            n.yCenter += diff2.Y / n.Destination.Height;
                        }
                        n.Position += diffXY / n.ReferenceLength;
                        break;

                    case EditorMode.Aspect:
                        Vector4 oldM = Vector2.Transform(this.Mode.OldMousePos, n.TransformInv);
                        Vector4 newM = Vector2.Transform(this.Mode.NewMousePos, n.TransformInv);
                        if (this.Mode.SubMode == EditorSubMode.AspectXMode)
                        {
                            float differ = (newM.X < n.Destination.Width / 2) ? (newM.X - oldM.X) : (oldM.X - newM.X);
                            n.AspectRatio -= differ / (0.5f * n.Destination.Width / n.AspectRatio);
                        }
                        else if (this.Mode.SubMode == EditorSubMode.AspectYMode)
                        {
                            float differ = (newM.Y < n.Destination.Height / 2) ? (newM.Y - oldM.Y) : (oldM.Y - newM.Y);
                            n.AspectRatio += differ / (0.5f * n.Destination.Height / n.AspectRatio);
                            n.NodeSize    *= 1 - (differ / (0.5f * n.Destination.Height));
                        }
                        break;
                    }

                    //UpdateNodeInfo();
                }
            }
        }
Beispiel #18
0
 public PoseNode(TextureNode node)
 {
     this.Node       = node;
     this.Properties = new Dictionary <string, object>();
 }