Push from tablet

Line.cs

@@ -1,12 +1,15 @@
 using System.Collections.Generic;
+using System.Linq;
 using System.Diagnostics;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
+using System.Collections;
+using System;
 
 public class Line
 {
     private List<Vector2> points;
-    private float thickness = 1.0f;
+    private float thickness;
 
     public enum JoinType
     {
@@ -23,71 +26,285 @@ public class Line
     }
 
     private Color LineColor { get; set; }
+    private LineCaps LineEndings { get; set; }
+    private JoinType JoinTypes { get; set; }
 
     //Graphical representation
     private VertexBuffer vbo;
     private IndexBuffer ibo;
     private GraphicsDevice gDevice;
 
-    public Line(List<Vector2> points)
+    private class LinkedMeshList : IEnumerable<LinkedMeshListNode>
     {
-        this.points = points;
-        this.LineColor = Color.Black;
+        public int Count { get; set; }
+
+        public LinkedMeshListNode FirstNode { get; private set; }
+
+        public LinkedMeshListNode LastNode { get; private set; }
+
+        public LinkedMeshList()
+        {
+            this.Count = 0;
+        }
+
+        public void Remove(LinkedMeshListNode node)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void AddBefore(LinkedMeshListNode node, LinkedMeshListNode beforeNode)
+        {
+            var oldBefore = node.Previous;
+
+            oldBefore.Next = beforeNode;
+            beforeNode.Previous = oldBefore;
+
+            beforeNode.Next = node;
+            node.Previous = beforeNode;
+
+            Count++;
+        }
+
+        public void AddAfter(LinkedMeshListNode node, LinkedMeshListNode afterNode)
+        {
+            var oldNext = node.Next;
+
+            node.Next = afterNode;
+            afterNode.Previous = node;
+
+            afterNode.Next = oldNext;
+            oldNext.Previous = afterNode;
+
+            Count++;
+        }
+
+        public void Append(LinkedMeshListNode node)
+        {
+            if(this.Count == 0)
+            {
+                this.FirstNode = node;
+                this.LastNode = node;
+                Count++;
+                return;
+            }
+
+            this.LastNode.Next = node;
+            node.Previous = this.LastNode;
+            this.LastNode = node;
+            this.Count++;
+        }
+
+        public List<VertexPositionColorTexture> GetVerticeList()
+        {
+            List<VertexPositionColorTexture> verticesList = new List<VertexPositionColorTexture>();
+            foreach(var node in this)
+            {
+                verticesList.AddRange(node.GenerateVerticeList());
+            }
+            return verticesList;
+        }
+
+        public List<ushort> GetIndiceList()
+        {
+            List<ushort> indeicesList = new List<ushort>();
+            foreach(var node in this)
+            {
+                indeicesList.AddRange(node.GenerateIndiceList());
+            }
+            return indeicesList;
+        }
+
+        public IEnumerator<LinkedMeshListNode> GetEnumerator()
+        {
+            LinkedMeshListNode curNode = this.FirstNode;
+            while(curNode != null)
+            {
+                yield
+                return curNode;
+                curNode = curNode.Next;
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            throw new NotImplementedException();
+        }
     }
 
-    public Line(List<Vector2> points, float thickness)
+    private abstract class LinkedMeshListNode
     {
-        this.points = points;
-        this.thickness = thickness;
-        this.LineColor = Color.Black;
+        public LinkedMeshListNode Next { get; set; }
+
+        private LinkedMeshListNode previous;
+        public LinkedMeshListNode Previous { 
+            get {
+                return this.previous;
+            }
+            set {
+                this.IndexOffset = value.IndexOffset + value.GetVertexCount();
+                this.previous = value;
+            }
+        }
+
+        public int IndexOffset { get; private set; }
+
+        public abstract int GetVertexCount();
+
+        public abstract List<VertexPositionColorTexture> GenerateVerticeList();
+        public abstract List<ushort> GenerateIndiceList();
+
+        public LinkedMeshListNode()
+        {
+            this.IndexOffset = 0;
+        }
     }
 
+    private class Segment : LinkedMeshListNode   {
+        public Vector2 Start { get; private set; }
+        public Vector2 End { get; private set; }
+        public Vector2 Normal { get; private set; }
+        public const ushort INDEX_BL = 0;
+        public const ushort INDEX_BR = 1;
+        public const ushort INDEX_TL = 2;
+        public const ushort INDEX_TR = 3;
+        private Color color { get; set; }
+        
+        public Segment(Vector2 start, Vector2 end, Color color) : base()
+        {
+            this.Start = start;
+            this.End = end;
+            Vector2 dir = end - start;
+            Vector2 perpendincularVector = new Vector2(dir.Y, -dir.X);
+            perpendincularVector.Normalize();
+            this.Normal = perpendincularVector;
+            this.color = color;
+        }
+
+        public override List<VertexPositionColorTexture> GenerateVerticeList()
+        {
+            List<VertexPositionColorTexture> vertices = new List<VertexPositionColorTexture>();
+            var offsetPoint1 = new Vector3(this.Start.X, this.Start.Y ,0.0f);
+            vertices.Add(new VertexPositionColorTexture(offsetPoint1, this.color, this.Normal));
+            vertices.Add(new VertexPositionColorTexture(offsetPoint1, this.color, this.Normal * -1));
+            var offsetPoint1Next = new Vector3(this.End.X, this.End.Y ,0.0f);
+            vertices.Add(new VertexPositionColorTexture(offsetPoint1Next, this.color, this.Normal));
+            vertices.Add(new VertexPositionColorTexture(offsetPoint1Next, this.color, this.Normal * -1));
+            return vertices;
+        }
+
+        public override List<ushort> GenerateIndiceList()
+        {
+            List<ushort> indices = new List<ushort>();
+            indices.Add((ushort)(this.IndexOffset + INDEX_BL));
+            indices.Add((ushort)(this.IndexOffset + INDEX_BR));
+            indices.Add((ushort)(this.IndexOffset + INDEX_TL));
+
+            indices.Add((ushort)(this.IndexOffset + INDEX_TL));
+            indices.Add((ushort)(this.IndexOffset + INDEX_BR));
+            indices.Add((ushort)(this.IndexOffset + INDEX_TR));
+
+            return indices;
+        }
+
+        public override int GetVertexCount()
+        {
+            return 4;
+        }
+    }
+
+    private class BevelLineJoin : LinkedMeshListNode
+    {
+        private Color color { get; set; }
+
+        public BevelLineJoin(Color color) : base()
+        {
+            this.color = color;
+        }
+
+        public override List<ushort> GenerateIndiceList()
+        {
+            Debug.Assert(this.Previous != null);
+            Debug.Assert(this.Previous is Segment);
+            Debug.Assert(this.Next != null);
+            Debug.Assert(this.Next is Segment);
+            var next = this.Next as Segment;
+            var previous = this.Previous as Segment;
+
+            ushort lastOffset = (ushort) previous.IndexOffset;
+            ushort nextOffset = (ushort) next.IndexOffset;
+
+            List<ushort> indices = new List<ushort>();
+            indices.Add((ushort)(lastOffset+Segment.INDEX_TL));
+            indices.Add((ushort)(lastOffset+Segment.INDEX_TR));
+            indices.Add((ushort)(nextOffset+Segment.INDEX_BL));
+
+            indices.Add((ushort)(lastOffset+Segment.INDEX_TL));
+            indices.Add((ushort)(lastOffset+Segment.INDEX_TR));
+            indices.Add((ushort)(nextOffset+Segment.INDEX_BR));
+            return indices;
+        }
+
+        public override List<VertexPositionColorTexture> GenerateVerticeList()
+        {
+            return new List<VertexPositionColorTexture>();
+        }
+
+        public override int GetVertexCount()
+        {
+            return 0;
+        }
+    }
+
+    public Line(List<Vector2> points) 
+    : this(points, 1.0f)
+    {}
+
+    public Line(List<Vector2> points, float thickness) 
+    : this(points, thickness, Color.Black)
+    {}
+
     public Line(List<Vector2> points, float thickness, Color color)
+    : this(points,thickness, color, JoinType.None)
+    {}
+
+    public Line(List<Vector2> points, float thickness, Color color, JoinType joinType)
+    : this(points, thickness, color, joinType, LineCaps.None)
+    {}
+
+    public Line(List<Vector2> points, float thickness, Color color, JoinType joinType, LineCaps caps)
     {
         this.points = points;
         this.thickness = thickness;
         this.LineColor = color;
+        this.JoinTypes = joinType;
+        this.LineEndings = caps;
     }
 
     public void InitOnGraphicalDevice(GraphicsDevice device)
     {
         this.gDevice = device;
         Debug.Assert(this.points.Count >= 2);
-        List<VertexPositionColorTexture> vertices = new List<VertexPositionColorTexture>();
-        List<ushort> indices = new List<ushort>();
+
+        LinkedMeshList meshList = new LinkedMeshList();
         
         for(int i = 0; i < this.points.Count - 1 ; i++)
         {
             var p = this.points[i];
             var pNext = this.points[i+1];
-
-            Vector2 dir = pNext - p;
-            Vector2 perpendincularVector = new Vector2(dir.Y, -dir.X);
-            perpendincularVector.Normalize();
-            
-            var offsetPoint1 = new Vector3(p.X, p.Y ,0.0f);
-            var offsetPoint2 = new Vector3(p.X, p.Y ,0.0f);
-            vertices.Add(new VertexPositionColorTexture(offsetPoint1,this.LineColor, perpendincularVector));
-            vertices.Add(new VertexPositionColorTexture(offsetPoint2,this.LineColor, perpendincularVector * -1));
-            var offsetPoint1Next = new Vector3(pNext.X, pNext.Y ,0.0f);
-            var offsetPoint2Next = new Vector3(pNext.X, pNext.Y ,0.0f);
-            vertices.Add(new VertexPositionColorTexture(offsetPoint1Next,this.LineColor, perpendincularVector));
-            vertices.Add(new VertexPositionColorTexture(offsetPoint2Next,this.LineColor, perpendincularVector * -1));
+            meshList.Append(new Segment(p, pNext, this.LineColor));
         }
 
-        for (int i = 0; i < vertices.Count; i+=4)
+        var curNode = meshList.FirstNode;
+        while(curNode != null && curNode.Next != null)
         {
-            indices.Add((ushort)(i));
-            indices.Add((ushort)(i + 1));
-            indices.Add((ushort)(i + 2));
-
-            indices.Add((ushort)(i + 2));
-            indices.Add((ushort)(i + 1));
-            indices.Add((ushort)(i + 3));
+            meshList.AddAfter(curNode, new BevelLineJoin(this.LineColor));
+            curNode = curNode.Next.Next;
         }
 
+        List<VertexPositionColorTexture> vertices = meshList.GetVerticeList();
+        List<ushort> indices = meshList.GetIndiceList();
 
-        this.vbo = new VertexBuffer(device, typeof(VertexPositionColorTexture), (this.points.Count - 1) * 4, BufferUsage.WriteOnly);
+        this.vbo = new VertexBuffer(device, typeof(VertexPositionColorTexture), vertices.Count, BufferUsage.WriteOnly);
         this.vbo.SetData<VertexPositionColorTexture>(vertices.ToArray());
         this.ibo = new IndexBuffer(device, typeof(ushort), indices.Count,BufferUsage.WriteOnly);
         this.ibo.SetData<ushort>(indices.ToArray());
@@ -98,7 +315,8 @@ public class Line
         this.gDevice.SetVertexBuffer(this.vbo);
         this.gDevice.Indices = this.ibo;
         RasterizerState rasterizerState = new RasterizerState();
-        rasterizerState.CullMode = CullMode.None;
+        // rasterizerState.CullMode = CullMode.None;
+        //rasterizerState.FillMode = FillMode.WireFrame;
         this.gDevice.RasterizerState = rasterizerState;
         lineEffect.Parameters["thickness"].SetValue(this.thickness);
         foreach (EffectPass pass in lineEffect.CurrentTechnique.Passes)