Removed GraphicsApi & fixed shaders work

src/Hypercube.Core/Config.cs

@@ -1,5 +1,6 @@
 using Hypercube.Graphics;
-using Hypercube.GraphicsApi;
+using Hypercube.Graphics.Rendering;
+using Hypercube.Mathematics;
 using Hypercube.Utilities.Configuration;
 
 namespace Hypercube.Core;
@@ -22,34 +23,54 @@ public static class Config
         });
 
     /** 
-     * API
+     * Rendering
      */
 
-    public static readonly ConfigField<WindowingApi> Windowing =
-        new("Windowing", WindowingApi.Glfw);
-
     public static readonly ConfigField<RenderingApi> Rendering =
         new("Rendering", RenderingApi.OpenGl);
+
+    public static readonly ConfigField<Color> RenderingClearColor =
+        new("RenderingClearColor", Color.Black);
+
+    public static readonly ConfigField<int> RenderingMaxVertices =
+        new("RenderingMaxVertices", 65532);    
+
+    public static readonly ConfigField<int> RenderingIndicesPerVertex =
+        new("RenderingIndicesPerVertex", 6);
 
     /**
-     * Render threading
+     * Windowing
      */
 
-    public static readonly ConfigField<bool> RenderThreading =
-        new("RenderThreading", true);
+    public static readonly ConfigField<WindowingApi> Windowing =
+        new("Windowing", WindowingApi.Glfw);
 
-    public static readonly ConfigField<string> RenderThreadName =
-        new("RenderThreadName", "Windowing");
-
-    public static readonly ConfigField<ThreadPriority> RenderThreadPriority =
-        new("RenderThreadPriority", ThreadPriority.AboveNormal);
 
-    public static readonly ConfigField<int> RenderThreadStackSize =
-        new("RenderThreadStackSize", 8 * 1024 * 1024); // 8MByte
+    public static readonly ConfigField<int> WindowingWaitEventsTimeout =
+        new("WindowingWaitEventsTimeout", 0);
+
+    /**
+     * Windowing threading
+     */
 
-    public static readonly ConfigField<int> RenderThreadReadySleepDelay =
-        new("RenderThreadReadySleepDelay", 10);
-
+    public static readonly ConfigField<bool> WindowingThreading =
+        new("WindowingThreading", true);
+
+    public static readonly ConfigField<string> WindowingThreadName =
+        new("WindowingThreadName", "Windowing");
+
+    public static readonly ConfigField<ThreadPriority> WindowingThreadPriority =
+        new("WindowingThreadPriority", ThreadPriority.AboveNormal);
+
+    public static readonly ConfigField<int> WindowingThreadStackSize =
+        new("WindowingThreadStackSize", 8 * 1024 * 1024); // 8MByte
+
+    public static readonly ConfigField<int> WindowingThreadReadySleepDelay =
+        new("WindowingThreadReadySleepDelay", 10);
+
+    public static readonly ConfigField<int> WindowingThreadEventBridgeBufferSize =
+        new("WindowingThreadEventBridgeBufferSize", 32);
+
     /**
      *  Render batching
      */

src/Hypercube.Core/Execution/Runtime.cs

@@ -1,12 +1,13 @@
 using System.Reflection;
 using Hypercube.Core.Execution.Attributes;
 using Hypercube.Core.Execution.Enums;
+using Hypercube.Core.Utilities.Helpers;
 using Hypercube.Graphics;
 using Hypercube.Graphics.Rendering;
 using Hypercube.Graphics.Rendering.Api;
 using Hypercube.Graphics.Windowing.Api;
 using Hypercube.Graphics.Windowing.Settings;
-using Hypercube.GraphicsApi;
+using Hypercube.Mathematics;
 using Hypercube.Resources.Loader;
 using Hypercube.Utilities.Configuration;
 using Hypercube.Utilities.Debugging.Logger;
@@ -57,23 +58,12 @@ public void Start()
 
         _renderer.Init(new RendererSettings
         {
-            Thread = Config.RenderThreading ? new RendererThreadSettings
-            {
-                Name = Config.RenderThreadName,
-                StackSize = Config.RenderThreadStackSize,
-                Priority = Config.RenderThreadPriority,
-            } : null,
-            WindowingApi = WindowingApiSettings.DefaultGlfw,
-            RenderingApi = new RenderingApiSettings
-            {
-                Api = RenderingApi.OpenGl,
-                IndicesPerVertex = 6,
-                MaxVertices = 65532
-            },
-            ReadySleepDelay = Config.RenderThreadReadySleepDelay
+            Thread = WindowingThreadSettingsHelper.FromConfig(),
+            WindowingApi = WindowingApiSettingsHelper.FromConfig(),
+            RenderingApi = RenderingApiSettingsHelper.FromConfig(),
+            ReadySleepDelay = Config.WindowingThreadReadySleepDelay
         });
 
-
         _renderer.CreateMainWindow(new WindowCreateSettings
         {
             Api = new ApiSettings
@@ -89,6 +79,12 @@ public void Start()
             Floating = Config.MainWindowFloating,
             TransparentFramebuffer = Config.MainWindowTransparentFramebuffer,
         });
+
+        var graphicsPreloader = new GraphicsPreloader();
+        _dependencies.Inject(graphicsPreloader);
+        graphicsPreloader.PreloadShaders();
+
+        _renderer.Load();
 
         _logger.Info("Preparation is complete, start the main application cycle");
         EntryPointsExecute(EntryPointLevel.AfterInit);

src/Hypercube.Core/Execution/Timing/ITiming.cs

@@ -0,0 +1,6 @@
+namespace Hypercube.Core.Execution.Timing;
+
+public interface ITiming
+{
+    uint Frame { get; }
+}

src/Hypercube.Core/Execution/Timing/Timing.cs

@@ -0,0 +1,6 @@
+namespace Hypercube.Core.Execution.Timing;
+
+public class Timing : ITiming
+{
+    public uint Frame { get; private set; }
+}

src/Hypercube.Core/Hypercube.Core.csproj

@@ -28,7 +28,6 @@
     </ItemGroup>
 
     <ItemGroup>
-      <ProjectReference Include="..\Hypercube.GraphicsApi\Hypercube.GraphicsApi.csproj" />
       <ProjectReference Include="..\Hypercube.Graphics\Hypercube.Graphics.csproj" />
       <ProjectReference Include="..\Hypercube.Resources\Hypercube.Resources.csproj" />
     </ItemGroup>

src/Hypercube.Core/Utilities/Helpers/RenderingApiSettingsHelper.cs

@@ -0,0 +1,17 @@
+using Hypercube.Graphics.Rendering.Api;
+
+namespace Hypercube.Core.Utilities.Helpers;
+
+public static class RenderingApiSettingsHelper
+{
+    public static RenderingApiSettings FromConfig()
+    {
+        return new RenderingApiSettings
+        {
+            Api = Config.Rendering,
+            ClearColor = Config.RenderingClearColor,
+            MaxVertices = Config.RenderingMaxVertices,
+            IndicesPerVertex = Config.RenderingIndicesPerVertex
+        };
+    }
+}

src/Hypercube.Core/Utilities/Helpers/WindowingApiSettingsHelper.cs

@@ -0,0 +1,16 @@
+using Hypercube.Graphics.Windowing.Api;
+
+namespace Hypercube.Core.Utilities.Helpers;
+
+public static class WindowingApiSettingsHelper
+{
+    public static WindowingApiSettings FromConfig()
+    {
+        return new WindowingApiSettings
+        {
+            Api = Config.Windowing,
+            WaitEventsTimeout = Config.WindowingWaitEventsTimeout,
+            EventBridgeBufferSize = Config.WindowingThreadEventBridgeBufferSize
+        };
+    }
+}

src/Hypercube.Core/Utilities/Helpers/WindowingThreadSettingsHelper.cs

@@ -0,0 +1,16 @@
+using Hypercube.Graphics.Rendering;
+
+namespace Hypercube.Core.Utilities.Helpers;
+
+public static class WindowingThreadSettingsHelper
+{
+    public static WindowingThreadSettings? FromConfig()
+    {
+        return Config.WindowingThreading ? new WindowingThreadSettings
+        {
+            Name = Config.WindowingThreadName,
+            StackSize = Config.WindowingThreadStackSize,
+            Priority = Config.WindowingThreadPriority,
+        } : null;
+    }
+}

src/Hypercube.Graphics/ApiFactory.cs

@@ -1,8 +1,8 @@
-using Hypercube.Graphics.Rendering.Api;
+using Hypercube.Graphics.Rendering;
+using Hypercube.Graphics.Rendering.Api;
 using Hypercube.Graphics.Rendering.Api.OpenGlRenderer;
 using Hypercube.Graphics.Windowing.Api;
 using Hypercube.Graphics.Windowing.Api.GlfwWindowing;
-using Hypercube.GraphicsApi;
 
 namespace Hypercube.Graphics;
 

src/Hypercube.Core/GraphicsPreloader.cs → src/Hypercube.Graphics/GraphicsPreloader.cs

@@ -5,35 +5,51 @@
 using Hypercube.Utilities.Debugging.Logger;
 using Hypercube.Utilities.Dependencies;
 
-namespace Hypercube.Core;
+namespace Hypercube.Graphics;
 
 public class GraphicsPreloader
 {
+    [Dependency] private readonly DependenciesContainer _dependencies = default!;
+
     [Dependency] private readonly ILogger _logger = default!;
     [Dependency] private readonly IResourceLoader _resourceLoader = default!;
     [Dependency] private readonly IResourceStorage _resourceStorage = default!;
 
     public void PreloadShaders()
     {
         _logger.Info("Preloading shaders...");
+
         var stopwatch = Stopwatch.StartNew();
         var count = 0;
 
-        foreach (var path in _resourceLoader.FindContentFiles("/Shaders/"))
+        new ResourceShader().Init(_dependencies);
+
+        foreach (var path in _resourceLoader.FindContentFiles("/shaders/"))
         {
-            if (path.Extension != ".frag" && path.Extension != ".vert")
+            if (!ResourceShader.Extension.Values.Contains(path.Extension))
                 continue;
 
             var basePath = $"{path.ParentDirectory}/{path.Filename}";
+
             if (_resourceStorage.Cached<ResourceShader>(basePath))
                 continue;
 
-            var resource = new ResourceShader(basePath);
-            _resourceStorage.CacheResource(basePath, resource);
+            var resource = new ResourceShader();
+
+            resource.Load(basePath);
+            resource.ShaderProgram?.Label(path.Filename);
+
+            if (!_resourceStorage.TryCacheResource(basePath, resource))
+            {
+                _logger.Critical($"Cached failed: {path}");
+                continue;
+            }
+
             count++;
         }
 
         stopwatch.Stop();
+
         _logger.Info($"Preloaded {count} shaders in {stopwatch.Elapsed}");
     }
 }

src/Hypercube.Graphics/Hypercube.Graphics.csproj

@@ -8,7 +8,6 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <ProjectReference Include="..\Hypercube.GraphicsApi\Hypercube.GraphicsApi.csproj" />
       <ProjectReference Include="..\Hypercube.Resources\Hypercube.Resources.csproj" />
     </ItemGroup>
 

src/Hypercube.Graphics/Patching/IPatch.cs

@@ -1,8 +1,8 @@
-using Hypercube.Graphics.Rendering;
+using Hypercube.Graphics.Rendering.Context;
 
 namespace Hypercube.Graphics.Patching;
 
 public interface IPatch
 {
-    void Draw(IRenderer renderer);
+    void Draw(IRenderContext renderer);
 }

src/Hypercube.Graphics/Patching/Patch.cs

@@ -1,8 +1,8 @@
-using Hypercube.Graphics.Rendering;
+using Hypercube.Graphics.Rendering.Context;
 
 namespace Hypercube.Graphics.Patching;
 
 public abstract class Patch : IPatch
 {
-    public abstract void Draw(IRenderer renderer);
+    public abstract void Draw(IRenderContext renderer);
 }

src/Hypercube.Graphics/Rendering/Api/BaseRenderingApi.Internal.cs

@@ -1,4 +1,6 @@
 using Hypercube.Graphics.Rendering.Batching;
+using Hypercube.Graphics.Rendering.Shaders;
+using Hypercube.Resources.Storage;
 
 namespace Hypercube.Graphics.Rendering.Api;
 
@@ -7,9 +9,14 @@ public abstract partial class BaseRenderingApi
     protected abstract string InternalInfo { get; }
 
     protected abstract bool InternalInit(IContextInfo contextInfo);
+    protected abstract void InternalLoad(IResourceStorage resourceStorage);
     protected abstract void InternalTerminate();
     protected abstract void InternalRender(Batch batch);
     protected abstract void InternalRenderSetup();
     protected abstract void InternalRenderSetupData(Vertex[] vertices, uint[] indices);
     protected abstract void InternalRenderUnsetup();
+
+    protected abstract IShader InternalCreateShader(string source, ShaderType type);
+    protected abstract IShaderProgram InternalCreateShaderProgram(IEnumerable<IShader> shaders);
+    protected abstract IShaderProgram InternalCreateShaderProgram(List<IShader> shaders);
 }