Dashboard/Dashboard.Drawing/DrawQueue.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;

namespace Dashboard.Drawing
{
    public class DrawQueue : IDisposable
    {
        private readonly HashList<IDrawExtension> _extensions = new HashList<IDrawExtension>();
        private readonly HashList<IDrawCommand> _commands = new HashList<IDrawCommand>();
        private readonly HashList<IDrawResource> _resources = new HashList<IDrawResource>();
        private readonly DrawController _controller;
        private readonly MemoryStream _commandStream = new MemoryStream();

        /// <summary>
        /// The absolute boundary of all graphics objects.
        /// </summary>
        public Box3d Bounds { get; set; }

        /// <summary>
        /// The extensions required to draw the image.
        /// </summary>
        public IReadOnlyList<IDrawExtension> Extensions => _extensions;

        /// <summary>
        /// The resources used by this draw queue.
        /// </summary>
        public IReadOnlyList<IDrawResource> Resources => _resources;

        /// <summary>
        /// The list of commands used by the extension.
        /// </summary>
        public IReadOnlyList<IDrawCommand> Command => _commands;

        public DrawQueue()
        {
            _controller = new DrawController(this);
        }

        /// <summary>
        /// Clear the queue.
        /// </summary>
        public void Clear()
        {
            _resources.Clear();
            _commands.Clear();
            _extensions.Clear();
            _commandStream.Capacity = 0;
        }

        public int RequireExtension(IDrawExtension extension)
        {
            foreach (IDrawExtension super in extension.Requires)
                RequireExtension(super);

            return _extensions.Intern(extension);
        }

        public int RequireResource(IDrawResource resource)
        {
            RequireExtension(resource.Kind);
            return _resources.Intern(resource);
        }

        internal IDrawController GetController(IDrawExtension extension)
        {
            _extensions.Intern(extension);
            return _controller;
        }

        private void Write(IDrawCommand command)
        {
            if (command.Length > 0)
                throw new InvalidOperationException("This command has a finite length argument.");

            int cmdIndex = _commands.Intern(command);

            Span<byte> cmd = stackalloc byte[6];
            int sz;

            if (command.Length == 0)
            {
                // Write a fixed command.
                sz = ToVlq(cmdIndex, cmd);
            }
            else
            {
                // Write a variadic with zero length.
                sz = ToVlq(cmdIndex, cmd);
                cmd[sz++] = 0;
            }

            _commandStream.Write(cmd[..sz]);
        }

        private void Write(IDrawCommand command, ReadOnlySpan<byte> param)
        {
            if (command.Length < 0)
            {
                Span<byte> cmd = stackalloc byte[10];
                int cmdIndex = _commands.Intern(command);
                int sz = ToVlq(cmdIndex, cmd);
                sz += ToVlq(param.Length, cmd[sz..]);
                _commandStream.Write(cmd[..sz]);
            }
            else
            {
                if (command.Length != param.Length)
                    throw new ArgumentOutOfRangeException(nameof(param.Length), "Length of the parameter does not match the command.");

                Span<byte> cmd = stackalloc byte[5];
                int cmdIndex = _commands.Intern(command);
                int sz = ToVlq(cmdIndex, cmd);

                _commandStream.Write(cmd[..sz]);
                _commandStream.Write(param);
            }
        }

        private static int ToVlq(int value, Span<byte> bytes)
        {
            if (value < 0)
                throw new ArgumentOutOfRangeException(nameof(value), "Must be a positive integer.");
            else if (bytes.Length < 5)
                throw new ArgumentOutOfRangeException(nameof(bytes), "Must at least be five bytes long.");

            int i;

            for (i = 0; i < 5 && value != 0; i++, value >>= 7)
            {
                if (i > 0)
                    bytes[i - 1] |= 1 << 7;

                bytes[i] = (byte)(value & 0x7F);
            }

            return i;
        }

        private static int FromVlq(ReadOnlySpan<byte> bytes)
        {
            int value = 0;

            for (int i = 0; i < bytes.Length; i++)
            {
                byte b = bytes[i];

                value = (value << 7) | b;

                if ((b & (1 << 7)) == 0)
                    break;
            }

            return value;
        }

        public void Dispose()
        {
            throw new NotImplementedException();
        }

        private class DrawController(DrawQueue Queue) : IDrawController
        {
            public void EnsureBounds(Box3d bounds)
            {
                Queue.Bounds = Box3d.Union(Queue.Bounds, bounds);
            }

            public void Write(IDrawCommand command)
            {
                Queue.Write(command);
            }

            public void Write(IDrawCommand command, ReadOnlySpan<byte> bytes)
            {
                Queue.Write(command, bytes);
            }

            public void Write<T>(IDrawCommand command, T param) where T : IParameterSerializer<T>
            {
                int length = param.Serialize(Queue, Span<byte>.Empty);
                Span<byte> bytes = stackalloc byte[length];

                param.Serialize(Queue, bytes);
                Write(command, bytes);
            }

            public void Write<T1, T2>(T2 command, T1 param) where T2 : IDrawCommand<T1>
            {
                int length = command.WriteParams(Queue, param, Span<byte>.Empty);
                Span<byte> bytes = stackalloc byte[length];

                command.WriteParams(Queue, param, bytes);
                Write(command, bytes);
            }
        }
    }

    public interface IDrawController
    {
        /// <summary>
        /// Ensures that the canvas is at least a certain size.
        /// </summary>
        /// <param name="bounds">The bounding box.</param>
        void EnsureBounds(Box3d bounds);

        /// <summary>
        /// Write into the command stream.
        /// </summary>
        /// <param name="command">The command to write.</param>
        void Write(IDrawCommand command);

        /// <summary>
        /// Write into the command stream.
        /// </summary>
        /// <param name="command">The command to write.</param>
        /// <param name="param">Any data associated with the command.</param>
        void Write(IDrawCommand command, ReadOnlySpan<byte> param);

        /// <summary>
        /// Write into the command stream.
        /// </summary>
        /// <param name="command">The command to write.</param>
        /// <param name="param">Any data associated with the command.</param>
        void Write<T>(IDrawCommand command, T param) where T : IParameterSerializer<T>;

        /// <summary>
        /// Write into the command stream.
        /// </summary>
        /// <param name="command">The command to write.</param>
        /// <param name="param">Any data associated with the command.</param>
        void Write<T1, T2>(T2 command, T1 param) where T2 : IDrawCommand<T1>;
    }
}