recrownedathenaeum/RecrownedAthenaeum/Render/PrimitiveBatch.cs

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using RecrownedAthenaeum.Camera;
using System;
using System.Collections.Generic;

namespace RecrownedAthenaeum.Render
{
    /// <summary>
    /// A batch used to draw primitive shapes by batching together vertices.
    /// </summary>
    public class PrimitiveBatch : IDisposable
    {
        List<VertexPositionColor> vertices;
        /// <summary>
        /// The maximum vertices expected. The further off this expectancy is from the true value, the less efficient.
        /// </summary>
        public int MaxVertices { get { return vertices.Capacity; } set { vertices.Capacity = value; } }
        int bufferPosition;
        BasicEffect basicEffect;
        PrimitiveType primitiveType;
        int verticesPerPrimitive;
        GraphicsDevice graphicsDevice;
        bool began;
        bool disposed;

        /// <summary>
        /// Creates a batch used to draw primitives.
        /// </summary>
        /// <param name="graphicsDevice">The current graphics device being used.</param>
        /// <param name="camera">The current camera being used.</param>
        /// <param name="verticesPerBatch">The amount of vertices every batch can hold before flushing. Default is 450. Should be changed to be the most optimal number if possible to prevent unnecessary resizing. Especially if using strip primitive types.</param>
        public PrimitiveBatch(GraphicsDevice graphicsDevice, Camera2D camera, int verticesPerBatch = 500)
        {
            this.graphicsDevice = graphicsDevice ?? throw new ArgumentNullException("Graphics device can't be null.");
            basicEffect = new BasicEffect(graphicsDevice);
            basicEffect.VertexColorEnabled = true;
            basicEffect.View = camera.Matrix;

            vertices = new List<VertexPositionColor>(verticesPerBatch);
        }

        /// <summary>
        /// Starts the batch. Batch cannot be started twice.
        /// </summary>
        /// <param name="primitiveType">The type of primitive this batch would be drawing.</param>
        public void Begin(PrimitiveType primitiveType)
        {
            if (began) throw new InvalidOperationException("Begin is being called twice before being ended.");
            if (disposed) throw new ObjectDisposedException(this.GetType().Name);
            this.primitiveType = primitiveType;
            verticesPerPrimitive = 0;
            switch (primitiveType)
            {
                case PrimitiveType.LineList: verticesPerPrimitive = 2; break;
                case PrimitiveType.TriangleList: verticesPerPrimitive = 3; break;
                default: verticesPerPrimitive = 1; break;
            }

            basicEffect.CurrentTechnique.Passes[0].Apply();
            began = true;
        }

        /// <summary>
        /// Ends the batch. Begin needs to be called before end.
        /// </summary>
        public void End()
        {
            if (disposed) throw new ObjectDisposedException(this.GetType().Name);

            if (!began) throw new InvalidOperationException("Begin must be called before ending.");
            Flush();
        }

        /// <summary>
        /// Adds a vertex position for the primitive being drawn. The batch needs to have beens started before this.
        /// </summary>
        /// <param name="vertex">The vector that represents the vertex.</param>
        /// <param name="color">The color of that vertex.</param>
        public void AddVertex(Vector2 vertex, Color color)
        {
            if (!began) throw new InvalidOperationException("Begin needs to be called before adding vertex.");
            if (disposed) throw new ObjectDisposedException(this.GetType().Name);
            if (bufferPosition + verticesPerPrimitive >= MaxVertices && (bufferPosition % MaxVertices == 0))
            {
                if (primitiveType != PrimitiveType.LineStrip && primitiveType != PrimitiveType.TriangleStrip)
                {
                    Flush();
                }
                else
                {
                    throw new InvalidOperationException("Buffer size isn't large enough.");
                }
            }
            vertices[bufferPosition] = new VertexPositionColor(new Vector3(vertex, 0), color);

            bufferPosition++;
        }

        /// <summary>
        /// Flushes the batch. Automatically called if required if using <see cref="PrimitiveType.LineList"/> or <see cref="PrimitiveType.TriangleList"/>. Otherwise, manual flushing is required.
        /// </summary>
        public void Flush()
        {
            if (!began) throw new InvalidOperationException("Begin needs to be called before flushing.");
            if (disposed) throw new ObjectDisposedException(this.GetType().Name);
            if (bufferPosition == 0) return;

            graphicsDevice.DrawUserPrimitives(primitiveType, vertices.ToArray(), 0, bufferPosition / verticesPerPrimitive);
            bufferPosition = 0;
        }

        /// <summary>
        /// Disposes this.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Overridable dispose.
        /// </summary>
        /// <param name="disposing">True for when user called for this to be disposed. False otherwise.</param>
        public virtual void Dispose(bool disposing)
        {
            if (disposed) throw new ObjectDisposedException(this.GetType().Name);
            disposed = true;
            if (disposing && !disposed)
            {
                basicEffect.Dispose();
            }
        }

        /// <summary>
        /// Destructor.
        /// </summary>
        ~PrimitiveBatch()
        {
            Dispose(false);
        }
    }
}