Add MeshBuilder class to build MeshData components

Author: chances

Engine/Buffers/VertexBuffer.cs

@@ -10,30 +10,34 @@ namespace Engine.Buffers
 {
     public class VertexBuffer<T> : Buffer, IResource where T : struct, IVertexBufferDescription
     {
-        private readonly T[] _vertexData;
+        private readonly T[] _vertices;
 
-        public VertexBuffer([NotNull] IEnumerable<T> vertexData, [NotNull] ushort[] indices)
+        public VertexBuffer([NotNull] IEnumerable<IVertexBufferDescription> vertices, [NotNull] ushort[] indices)
         {
-            var vertexDataArray = vertexData as T[] ?? vertexData.ToArray();
-            Guard.AgainstNullArgument(nameof(vertexData), vertexDataArray);
-            if (vertexDataArray.Length == 0)
+            var verticesArray = vertices as IVertexBufferDescription[] ?? vertices.ToArray();
+            Guard.AgainstNullArgument(nameof(vertices), verticesArray);
+            if (!verticesArray.All(vertex => vertex is T))
             {
-                throw new ArgumentException("Given vertex data must not be empty.", nameof(vertexData));
+                throw new ArgumentException("Given vertices must all be of same type.", nameof(vertices));
             }
-            _vertexData = vertexDataArray;
+            if (verticesArray.Length == 0)
+            {
+                throw new ArgumentException("Given vertices must not be empty.", nameof(vertices));
+            }
+            _vertices = verticesArray.Cast<T>().ToArray();
 
             Indices = new IndexBuffer(indices);
         }
 
-        public VertexLayoutDescription LayoutDescription => _vertexData[0].LayoutDescription;
+        public VertexLayoutDescription LayoutDescription => _vertices[0].LayoutDescription;
 
         public IndexBuffer Indices { get; }
 
         public void Initialize(ResourceFactory factory, GraphicsDevice device)
         {
-            var size = (uint) (_vertexData.Length * _vertexData[0].SizeInBytes);
+            var size = (uint) (_vertices.Length * _vertices[0].SizeInBytes);
             _buffer = factory.CreateBuffer(new BufferDescription(size, BufferUsage.VertexBuffer));
-            device.UpdateBuffer(_buffer, 0, _vertexData);
+            device.UpdateBuffer(_buffer, 0, _vertices);
 
             Indices.Initialize(factory, device);
         }

Engine/Buffers/VertexPositionNormalColor.cs

@@ -16,14 +16,18 @@ public VertexPositionNormalColor(Vector3 position, Vector3 normal, Vector4 color
             Color = color;
         }
 
-        private static readonly VertexLayoutDescription _layoutDescription = new VertexLayoutDescription(
-            new VertexElementDescription(nameof(Position), VertexElementSemantic.Position, VertexElementFormat.Float3),
-            new VertexElementDescription(nameof(Normal), VertexElementSemantic.Normal, VertexElementFormat.Float3),
-            new VertexElementDescription(nameof(Color), VertexElementSemantic.Color, VertexElementFormat.Float4));
+        public static VertexPositionNormalColor FromVertexPositionNormal(VertexPositionNormal vertex) =>
+            new VertexPositionNormalColor(vertex.Position, vertex.Normal, RgbaFloat.Grey.ToVector4());
 
         public VertexLayoutDescription LayoutDescription => _layoutDescription;
 
         // float is 4 bytes(?)
         public uint SizeInBytes => 40;
+
+        // ReSharper disable once InconsistentNaming
+        private static readonly VertexLayoutDescription _layoutDescription = new VertexLayoutDescription(
+            new VertexElementDescription(nameof(Position), VertexElementSemantic.Position, VertexElementFormat.Float3),
+            new VertexElementDescription(nameof(Normal), VertexElementSemantic.Normal, VertexElementFormat.Float3),
+            new VertexElementDescription(nameof(Color), VertexElementSemantic.Color, VertexElementFormat.Float4));
     }
 }

Engine/Components/MeshData.cs

@@ -1,9 +1,10 @@
 using Engine.Buffers;
+using Engine.ECS;
 using Veldrid;
 
 namespace Engine.Components
 {
-    public class MeshData<T> : ECS.Component, IResource where T : struct, IVertexBufferDescription
+    public class MeshData<T> : Component, IResource where T : struct, IVertexBufferDescription
     {
         public MeshData(string name, VertexBuffer<T> vertexBuffer,
             FrontFace frontFace = FrontFace.Clockwise,

Engine/Primitives/MeshBuilder.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Engine.Buffers;
+using Engine.Components;
+using JetBrains.Annotations;
+using LiteGuard;
+using Veldrid;
+
+namespace Engine.Primitives
+{
+    public class MeshBuilder
+    {
+        private IVertexBufferDescription[] _vertices;
+        private ushort[] _indices = new ushort[0];
+        private readonly RgbaFloat? _color;
+
+        public MeshBuilder(RgbaFloat? color = null)
+        {
+            _vertices = null;
+            _color = color;
+        }
+
+        public MeshBuilder WithVertex([NotNull] IVertexBufferDescription vertex)
+        {
+            Guard.AgainstNullArgument(nameof(vertex), vertex);
+
+            return new MeshBuilder(_color)
+            {
+                _vertices = _vertices.Append(vertex).ToArray(),
+                _indices = _indices
+            };
+        }
+
+        public MeshBuilder WithVertices([NotNull] IEnumerable<IVertexBufferDescription> vertices)
+        {
+            var verticesArray = vertices as IVertexBufferDescription[] ?? vertices.ToArray();
+            Guard.AgainstNullArgument(nameof(vertices), verticesArray);
+            if (verticesArray.Length == 0)
+            {
+                throw new ArgumentException("Given vertex data must not be empty.", nameof(vertices));
+            }
+
+            return new MeshBuilder(_color)
+            {
+                _vertices = _vertices,
+                _indices = _indices
+            };
+        }
+
+        /// <summary>
+        /// Instantiates a <see cref="MeshData{T}"/> with stored vertices and indices
+        /// </summary>
+        /// <param name="name">Name to give the instantiated <see cref="Engine.ECS.Component"/></param>
+        /// <returns>Guaranteed to return an instance of <see cref="MeshData{T}"/></returns>
+        /// <exception cref="InvalidOperationException">Zero vertices are stored</exception>
+        public object Build(string name)
+        {
+            if (_vertices == null || _vertices.Length == 0)
+            {
+                throw new InvalidOperationException("This builder contains zero vertices");
+            }
+
+            if (_color == null)
+                return new MeshData<VertexPositionNormal>(name,
+                    new VertexBuffer<VertexPositionNormal>(_vertices, _indices));
+
+            return new MeshData<VertexPositionNormalColor>(name,
+                new VertexBuffer<VertexPositionNormalColor>(_vertices, _indices));
+        }
+    }
+}