Merge remote-tracking branch 'origin/main'

Screens/IScreen.cs

@@ -0,0 +1,9 @@
+
+namespace MyGame.Screens
+{
+    public interface IScreen
+    {
+        void Update();
+        void Draw();
+    }
+}

Screens/MenuScreen.cs

@@ -0,0 +1,15 @@
+namespace MyGame.Screens
+{
+    public class MenuScreen : IScreen
+    {
+        public void Update()
+        {
+
+        }
+
+        public void Draw()
+        {
+            
+        }
+    } 
+}

assets/shaders/line.fx

@@ -40,7 +40,7 @@ float4 MainPS(VertexShaderOutput input) : COLOR
 	float4 res = input.Color;
 	float distFromLine = length(input.Normal);
     float alpha =  1.0 - ((clamp(distFromLine, (1.0 - feather),1.0) - (1.0 - feather)) / feather);	
-	res.a = alpha;
+	//res.a = alpha;
 	return res;
 }
 

src/Primitives/Line.cs

@@ -1,14 +1,20 @@
 using System.Collections.Generic;
+using System.Linq;
 using System.Diagnostics;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
+using System.Collections;
+using System;
+
 
 namespace MyGame.Primitives
 {
+
+
     public class Line
     {
         private List<Vector2> points;
-        private float thickness = 1.0f;
+        private float thickness;
 
         public enum JoinType
         {
@@ -25,71 +31,289 @@ namespace MyGame.Primitives
         }
 
         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;
+            public int Count { get; set; }
-            this.LineColor = Color.Black;
+
+            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();
+            }
         }
 
+        private abstract class LinkedMeshListNode
+        {
+            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)
-            this.points = points;
+        { }
-            this.thickness = thickness;
-            this.LineColor = 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];
-
+                meshList.Append(new Segment(p, pNext, this.LineColor));
-                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));
             }
 
-            for (int i = 0; i < vertices.Count; i += 4)
+            var curNode = meshList.FirstNode;
+            while (curNode != null && curNode.Next != null)
             {
-                indices.Add((ushort)(i));
+                meshList.AddAfter(curNode, new BevelLineJoin(this.LineColor));
-                indices.Add((ushort)(i + 1));
+                curNode = curNode.Next.Next;
-                indices.Add((ushort)(i + 2));
-
-                indices.Add((ushort)(i + 2));
-                indices.Add((ushort)(i + 1));
-                indices.Add((ushort)(i + 3));
             }
 
+            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());
@@ -100,7 +324,8 @@ namespace MyGame.Primitives
             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)

src/Program.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 using Microsoft.Xna.Framework.Input;
@@ -7,7 +8,7 @@ using MyGame.Primitives;
 
 namespace Barbs
 {
-    class Program : Game
+    class Program : Game, IDisposable
     {
         Texture2D ballTexture;
         private GraphicsDeviceManager graphics;
@@ -26,10 +27,10 @@ namespace Barbs
 
         protected override void Initialize()
         {
-            // TODO: Add your initialization logic here
+            graphics.PreferredBackBufferHeight = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height;
-            graphics.PreferredBackBufferHeight = 1824;
+            graphics.PreferredBackBufferWidth = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width;
-            graphics.PreferredBackBufferWidth = 2736;
             graphics.ApplyChanges();
+            Window.IsBorderless = true;
             
             base.Initialize();
         }
@@ -41,18 +42,24 @@ namespace Barbs
             ballTexture = Content.Load<Texture2D>("ball");
 
             world = Matrix.CreateTranslation(0, 0, 0);
-            view = Matrix.CreateLookAt(new Vector3(0, 0, 3), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
+            view = Matrix.CreateLookAt(new Vector3(0.3f, 0, 2.0f), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
             projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45), 800f / 480f, 0.01f, 100f);
  
             basicEffect = new BasicEffect(GraphicsDevice);
             lineEffect = Content.Load<Effect>("shaders/line");
 
             Vector2[] arr = { new Vector2(0.0f,0.0f), new Vector2(0.2f,0.5f), new Vector2(0.2f,0.0f), new Vector2(0.5f,0.0f),
-            new Vector2(0.7f,-0.5f)};
+            new Vector2(0.7f,-0.5f), new Vector2(1.0f, 1.0f)};
             this.testLine = new Line(new List<Vector2>(arr), 0.01f, Color.DarkSlateGray);
             this.testLine.InitOnGraphicalDevice(GraphicsDevice);
         }
 
+        protected void Dispose()
+        {
+            //Cleanup
+            // OR Final call before shutdown
+        }
+
         protected override void Update(GameTime gameTime)
         {
             if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
@@ -84,8 +91,11 @@ namespace Barbs
 
         static void Main(string[] args)
         {
-            var pro = new Program();
+
-            pro.Run();
+            using (Program game = new Program())
+            {
+                game.Run();
+            }
         }
     }
 }