SolutionRunner.cs

using Silk.NET.OpenGL;
using Silk.NET.Windowing;
using System.Diagnostics;
using static GraphicsApiBenchmark.GLHelper;

namespace GraphicsApiBenchmark
{
    public abstract class SolutionRunner
    {
        private readonly int resolution;
        private readonly int frameCountPerSolution;
        private readonly IWindow window;
        private readonly NoOpSolution noOpSolution = new();
        private readonly List<ISolution> solutions;
        protected Dictionary<string, string> textResources = [];
        private int currentFrameIndex = 0;
        private int currentSolutionIndex = -1;
        private string gpuName = "Unknown renderer";

        protected SolutionRunner(int resolution, int frameCountPerSolution)
        {
            this.resolution = resolution;
            this.frameCountPerSolution = frameCountPerSolution;
            window = CreateWindow();
            LoadResources();
            solutions = CreateSolutions();
        }

        public void Run()
        {
            RunSolutions();
            PrintResults();
        }

        protected abstract void LoadResources();

        protected abstract List<ISolution> CreateSolutions();

        private void RunSolutions()
        {
            window.Run();
            window.Dispose();
        }

        private IWindow CreateWindow()
        {
#if DEBUG
            var contextFlags = ContextFlags.Debug;
#else
            var contextFlags = ContextFlags.ForwardCompatible;
#endif
            currentFrameIndex = 0;
            var options = WindowOptions.Default with
            {
                VSync = false,
                Size = new(resolution),
                Title = "Sandbox",
                API = new(ContextAPI.OpenGL, ContextProfile.Core, contextFlags, new(4, 6))
            };
            var window = Window.Create(options);
            window.Load += () =>
            {
                gl = window.CreateOpenGL();
                InitializeLogging();
                gpuName = GetRenderer();
            };
            window.Render += (double dt) =>
            {
                var solution = currentSolutionIndex == -1 ? noOpSolution : solutions[currentSolutionIndex];
                if (currentFrameIndex == 0)
                {
                    solution.Initialize();
                    UpdateProgress();
                }
                if (currentFrameIndex < frameCountPerSolution)
                {
                    solution.Render((float)dt);
                    currentFrameIndex++;
                }
                if (currentFrameIndex >= frameCountPerSolution)
                {
                    solution.Dispose();
                    currentFrameIndex = 0;
                    currentSolutionIndex++;
                    if (currentSolutionIndex >= solutions.Count)
                    {
                        window.Close();
                    }
                }
            };
            window.Closing += () =>
            {
                gl.Dispose();
                ResetCursor();
            };
            return window;
        }

        [Conditional("RELEASE")]
        private void UpdateProgress()
        {
            if (currentSolutionIndex != -1)
            {
                Console.CursorLeft = 0;
                Console.Write($"{currentSolutionIndex + 1} / {solutions.Count}");
            }
        }

        [Conditional("RELEASE")]
        private static void ResetCursor()
        {
            Console.CursorLeft = 0;
        }

        protected abstract void PrintResults();

        protected void PrintGeneralInformations()
        {
            PrintBuildConfiguration();
            Console.WriteLine($"GPU: {gpuName}");
            Console.WriteLine($"Resolution: {resolution}x{resolution} px");
            Console.WriteLine($"Rendered frames per solution: {frameCountPerSolution}");
        }

        protected static void PrintBuildConfiguration()
        {
#if DEBUG
            Console.ForegroundColor = ConsoleColor.Black;
            Console.BackgroundColor = ConsoleColor.Red;
            Console.WriteLine("DEBUG MODE");
            Console.ResetColor();
#else
            Console.WriteLine("RELEASE MODE");
#endif
        }

        protected void PrintSolutionResults()
        {
            foreach (var solution in solutions)
            {
                solution.PrintResults();
            }
        }

        public IWindow GetWindow()
        {
            return window;
        }

        public int GetCurrentFrameIndex()
        {
            return currentFrameIndex;
        }

        public IReadOnlyDictionary<string, string> GetTextResources()
        {
            return textResources;
        }
    }
}